def getbest(i): g = NEAT.Genome(0, 3, 0, 1, False, NEAT.ActivationFunction.UNSIGNED_SIGMOID, NEAT.ActivationFunction.UNSIGNED_SIGMOID, 0, params, 0) pop = NEAT.Population(g, params, True, 1.0, i) # pop.RNG.Seed(int(time.clock()*100)) pop.RNG.Seed(1234) generations = 0 for generation in range(max_generations): genome_list = NEAT.GetGenomeList(pop) fitness_list = EvaluateGenomeList_Serial(genome_list, evaluate, display=False) # fitness_list = EvaluateGenomeList_Parallel(genome_list, evaluate, display=False) NEAT.ZipFitness(genome_list, fitness_list) pop.Epoch() generations = generation best = max(fitness_list) if best > 15.0: break net = NEAT.NeuralNetwork() pop.GetBestGenome().BuildPhenotype(net) # img = NEAT.viz.Draw(net) # cv2.imshow("current best", img) # cv2.waitKey(1) return generations, net.NumHiddenNeurons(), net.NumConnections()
def evolve(): g = NEAT.Genome(0, 3, 0, 1, False, NEAT.ActivationFunction.UNSIGNED_SIGMOID, NEAT.ActivationFunction.UNSIGNED_SIGMOID, 0, params, 0) pop = NEAT.Population(g, params, True, 1.0, 1) pop.RNG.Seed(int(time.clock()*100)) generations = 0 for generation in range(1000): genome_list = NEAT.GetGenomeList(pop) fitness_list = [] for genome in genome_list: fitness_list.append(evaluate(genome)) NEAT.ZipFitness(genome_list, fitness_list) pop.Epoch() generations = generation best = max(fitness_list) bestG = pop.GetBestGenome() plot_nn(bestG) plt.pause(0.001) plt.ion() plt.show(block=False) print("Mejor fitness [",generation,"]: ",best) if best > 15.9: break return generations
def getbest(): g = NEAT.Genome(0, 3, 0, 1, False, NEAT.ActivationFunction.UNSIGNED_SIGMOID, NEAT.ActivationFunction.UNSIGNED_SIGMOID, 0, params) pop = NEAT.Population(g, params, True, 1.0) generations = 0 for generation in range(1000): genome_list = NEAT.GetGenomeList(pop) fitness_list = NEAT.EvaluateGenomeList_Serial(genome_list, evaluate, display=False) NEAT.ZipFitness(genome_list, fitness_list) best = max([x.GetLeader().GetFitness() for x in pop.Species]) # print 'Best fitness:', best, 'Species:', len(pop.Species) # test net = NEAT.NeuralNetwork() pop.Species[0].GetLeader().BuildPhenotype(net) img = np.zeros((250, 250, 3), dtype=np.uint8) img += 10 NEAT.DrawPhenotype(img, (0, 0, 250, 250), net) cv2.imshow("nn_win", img) cv2.waitKey(1) pop.Epoch() # print "Generation:", generation generations = generation if best > 15.5: break return generations
def getbest(i): g = NEAT.Genome(0, 3, 0, 1, False, NEAT.ActivationFunction.UNSIGNED_SIGMOID, NEAT.ActivationFunction.UNSIGNED_SIGMOID, 0, params) pop = NEAT.Population(g, params, True, 1.0, i) pop.RNG.Seed(i) generations = 0 for generation in range(1000): genome_list = NEAT.GetGenomeList(pop) fitness_list = NEAT.EvaluateGenomeList_Serial(genome_list, evaluate, display=False) NEAT.ZipFitness(genome_list, fitness_list) best = max([x.GetLeader().GetFitness() for x in pop.Species]) pop.Epoch() generations = generation if best > 15.0: break return generations
def run_experiment(config_file, trial_id, n_generations, out_dir, view_results=False, save_results=True): """ The function to run the experiment against hyper-parameters defined in the provided configuration file. The winner genome will be rendered as a graph as well as the important statistics of neuroevolution process execution. Arguments: config_file: The path to the file with experiment configuration trial_id: The ID of current trial n_generations: The number of evolutionary generations out_dir: The directory to save intermediate results. view_results: The flag to control if intermediate results should be displayed after each trial save_results: The flag to control whether intermediate results should be saved after each trial. Returns: The tuple (solution_found, generation, complexity, best_genome_fitness) that has flag indicating whether solution was found, the generation when solution was found, the complextity of best genome, and the fitness of best genome. """ g = NEAT.Genome(0, 4+1, 0, 1+1, False, NEAT.ActivationFunction.TANH, NEAT.ActivationFunction.TANH, 0, params, 0) pop = NEAT.Population(g, params, True, 1.0, trial_id) # set random seed seed = int(time.time()) pop.RNG.Seed(seed) generations = 0 solved = False best_trial_fitness = 0 best_trial_complexity = 0 for generation in range(n_generations): genome_list = NEAT.GetGenomeList(pop) fitness_list = EvaluateGenomeList_Serial(genome_list, evaluate, display=view_results) NEAT.ZipFitness(genome_list, fitness_list) generations = generation best = max(genome_list, key=get_fitness) best_fitness = best.GetFitness() complexity = best.NumNeurons() + best.NumLinks() solved = best_fitness >= cart.MAX_FITNESS # Changed to correspond limit used with other tested libraries if solved: best_trial_fitness = best_fitness best_trial_complexity = complexity print("Trial: %2d\tgeneration: %d\tfitness: %f\tcomplexity: %d\tseed: %d" % (trial_id, generations, best_trial_fitness, complexity, seed)) break # check if best fitness in this generation is better than current maximum if best_fitness > best_trial_fitness: best_trial_complexity = complexity best_trial_fitness = best_fitness # move to the next epoch pop.Epoch() if not solved: print("Trial: %2d\tFAILED\t\tfitness: %f\tcomplexity: %d\tseed: %d" % (trial_id, best_trial_fitness, best_trial_complexity, seed)) return solved, generations, best_trial_complexity, best_trial_fitness
def evolve(): global generations global global_best global rrse_list global mae_list global rows global cols # print("LOO Validation:") g = NEAT.Genome(0, (cols - 1), (3), 1, False, NEAT.ActivationFunction.LINEAR, NEAT.ActivationFunction.LINEAR, 1, params, 1) for test_idx in range(rows): pop = NEAT.Population(g, params, True, 1.0, 0) pop.RNG.Seed(int(time.clock() * 100)) generations = 0 global_best = -99999999 no_improvement = 0 # Run for a maximum of N generations while no_improvement < 7 and generations < 100: #TODO: make max gens into variable and set via command line # Reset the population if this path does not seem promising if (generations > 7 and global_best < -150): pop = NEAT.Population(g, params, True, 1.0, 0) pop.RNG.Seed(int(time.clock() * 100)) generations = 0 global_best = -99999999 no_improvement = 0 genome_list = NEAT.GetGenomeList(pop) fitness_list = [] for genome in genome_list: fitness_list.append(evaluate(genome, test_idx)) NEAT.ZipFitness(genome_list, fitness_list) pop.Epoch() generations += 1 best = max(fitness_list) #print("[ROW:", test_idx, "] ", -global_best, " (", no_improvement, " g. of no improvement)") if best > global_best: no_improvement = 0 global_best = best else: no_improvement += 1 #print("LOO test error (RRSE):") #print(rrse_list[test_idx]) #print("LOO test error (MAE):") #print(mae_list[test_idx]) print(rrse_list) print(mae_list) avg_rrse = np.mean(rrse_list) avg_mae = np.mean(mae_list) return [avg_rrse, avg_mae]
def optimize_neat(config, n_inputs, n_hidden, n_outputs, out_dir): print('Starting Optimization') params = NEAT.Parameters() params.PopulationSize = 60 params.OldAgeTreshold = 10 params.SpeciesMaxStagnation = 20 params.AllowLoops = False for i in range(config['n_morphogens']): addTrait(params, 'K%i' % i, (.03, .08)) addTrait(params, 'F%i' % i, (.01, .06)) addTrait(params, 'diffU%i' % i, (.005, .02)) addTrait(params, 'diffV%i' % i, (.0025, .01)) ######################## Create NEAT objects ############################### fs_neat = False seed_type = 0 out_type = NEAT.ActivationFunction.UNSIGNED_SIGMOID hidden_type = NEAT.ActivationFunction.UNSIGNED_SIGMOID genome_prototye = NEAT.Genome(0, n_inputs, n_hidden, n_outputs, fs_neat, \ out_type, hidden_type, seed_type, params, 0) rand_seed = int(time.time()) pop = NEAT.Population(genome_prototye, params, True, 1.0, rand_seed) ######################## Main evolution loop ############################### top_fitness = 0 # Fitness function is defined in [0, 1] top_grid = None for generation in range(config['generations']): print('Starting generation', generation) genomes = NEAT.GetGenomeList(pop) fitness_list = [simulate_genome(g, config)[0] for g in genomes] NEAT.ZipFitness(genomes, fitness_list) max_fitness = max(fitness_list) print('Generation complete') print('Max fitness', max_fitness) print('Mean fitness', np.mean(fitness_list)) if max_fitness > top_fitness: print('New best fitness') best_genome = genomes[fitness_list.index(max_fitness)] _, best_grid = simulate_genome(best_genome, config) top_fitness = max_fitness top_grid = best_grid np.save(out_dir + '/grid_%i' % generation, best_grid) best_genome.Save(out_dir + '/genome_%i' % generation) pop.Epoch() print()
def getbest(i): g = NEAT.Genome(0, 3, 0, 1, False, NEAT.ActivationFunction.UNSIGNED_SIGMOID, NEAT.ActivationFunction.UNSIGNED_SIGMOID, 0, params) pop = NEAT.Population(g, params, True, 1.0, i) pop.RNG.Seed(int(time.clock()*100)) generations = 0 for generation in range(1000): genome_list = NEAT.GetGenomeList(pop) fitness_list = EvaluateGenomeList_Serial(genome_list, evaluate, display=False) NEAT.ZipFitness(genome_list, fitness_list) pop.Epoch() generations = generation best = max(fitness_list) if best > 15.0: break return generations
def objective_driven(seed): i = seed g = NEAT.Genome(0, 6, 0, 4, False, NEAT.ActivationFunction.SIGNED_SIGMOID, NEAT.ActivationFunction.SIGNED_SIGMOID, 0, params) pop = NEAT.Population(g, params, True, 1.0, i) #pop.RNG.Seed(i) generations = 0 for generation in range(250): genome_list = NEAT.GetGenomeList(pop) fitness_list = NEAT.EvaluateGenomeList_Serial(genome_list, evaluate, display=False) fitness_list = [k[0] for k in fitness_list] NEAT.ZipFitness(genome_list, fitness_list) best_fits = [x.GetLeader().GetFitness() for x in pop.Species] best = max(best_fits) idx = best_fits.index(best) print best, pop.Species[idx].GetLeader().GetFitness() imgs, res = evaluate(pop.Species[idx].GetLeader(), debug=True, save="gen%d.ply" % generation) plt.ion() plt.clf() subfig = 1 t_imgs = len(imgs) for img in imgs: plt.subplot(t_imgs, 1, subfig) plt.title("Confidence: %0.2f%%" % (res[subfig - 1, target_class] * 100.0)) plt.imshow(img) subfig += 1 plt.draw() plt.pause(0.1) plt.savefig("out%d.png" % generation) pop.Epoch() generations = generation return generations
def evolve_neat(params, generations, out_dir, run_id, pool): pop = create_initial_population(params) max_ever = None t = time.time() for generation in range(generations): print(run_id, 'Starting generation', generation) genomes = NEAT.GetGenomeList(pop) if pool: data = [(g, g.GetGenomeTraits(), params) for g in genomes] fitnesses = pool.starmap(evaluate, data) else: fitnesses = [ evaluate(g, g.GetGenomeTraits(), params) for g in genomes ] NEAT.ZipFitness(genomes, fitnesses) maxf, meanf = max(fitnesses), sum(fitnesses) / float(len(fitnesses)) runtime = time.time() - t t = time.time() print() print('Generation %i ran in %f, %f per coral' % \ (generation, runtime, runtime/len(genomes))) print('Max fitness:', maxf, 'Mean fitness:', meanf) if max_ever is None or maxf > max_ever: best = pop.GetBestGenome() max_ever = maxf print('New best fitness.', best.NumNeurons(), best.NumLinks()) coral = simulate_and_save(best, params, out_dir, generation, maxf, meanf)[0] pop.Epoch() print('#' * 80) print('Run Complete.')
def evolve(): g = NEAT.Genome(0, 2, 0, 1, False, NEAT.ActivationFunction.LINEAR, NEAT.ActivationFunction.LINEAR, 0, params, 0) pop = NEAT.Population(g, params, True, 1.0, 1) pop.RNG.Seed(int(time.clock()*100)) generations = 0 for generation in range(50): genome_list = NEAT.GetGenomeList(pop) fitness_list = [] for genome in genome_list: fitness_list.append(evaluate(genome)) NEAT.ZipFitness(genome_list, fitness_list) pop.Epoch() generations = generation best = -max(fitness_list) bestG = pop.GetBestGenome() plot_nn(bestG) plt.pause(0.01) plt.ion() plt.show(block=False) print("Mejor fitness [",generation,"]: ",best) if best < 0.01: break testNet = NEAT.NeuralNetwork() bestG.BuildPhenotype(testNet) for i in range(10): testNet.Flush() testNet.Input(np.array([float(100+2*i), 1])) for _ in range(2): testNet.Activate() o = testNet.Output() print(100+2*i,"/ 2 = ",o[0]) return generations
def run_experiment(params, trial_id, n_generations, out_dir=None, view_results=False, save_results=True): g = NEAT.Genome(0, 3, 0, 1, False, NEAT.ActivationFunction.UNSIGNED_SIGMOID, NEAT.ActivationFunction.UNSIGNED_SIGMOID, 0, params, 0) pop = NEAT.Population(g, params, True, 1.0, trial_id) # set random seed seed = int(time.time()) pop.RNG.Seed(seed) generations = 0 solved = False max_fitness = 0 complexity = 0 for generation in range(n_generations): genome_list = NEAT.GetGenomeList(pop) fitness_list = EvaluateGenomeList_Serial(genome_list, evaluate, display=view_results) NEAT.ZipFitness(genome_list, fitness_list) generations = generation best = max(genome_list, key=get_fitness) best_fitness = best.GetFitness() complexity = best.NumNeurons() + best.NumLinks() solved = best_fitness > 15.5 # Changed to correspond limit used with other tested libraries if solved: max_fitness = best_fitness print("Trial: %2d\tgeneration: %d\tfitness: %f\tcomplexity: %d\tseed: %d" % (trial_id, generations, max_fitness, complexity, seed)) break # check if best fitness in this generation is better than current maximum max_fitness = max(best_fitness, max_fitness) # move to the next epoch pop.Epoch() if not solved: print("Trial: %2d\tFAILED\t\tfitness: %f\tcomplexity: %d\tseed: %d" % (trial_id, max_fitness, complexity, seed)) return solved, generations, complexity, max_fitness
def evolve_local(params, generations, out_dir, run_id, pool, max_size=400, K=10, N=5): max_ever = None archive = Archive(max_size, K) pop = create_initial_population(params) seen_genomes = set() corals_dir = pjoin(out_dir, 'corals') hist_dir = pjoin(out_dir, 'local_fitness_history') best_dir = pjoin(out_dir, 'best') os.mkdir(corals_dir) os.mkdir(hist_dir) os.mkdir(best_dir) # Main loop for generation in range(generations): print('\n' + '#' * 80) print(run_id, 'Starting generation %i' % generation) genomes = NEAT.GetGenomeList(pop) fitness_list, feature_list = evaluate_genomes_novelty( genomes, params, pool) local_fitness_list = archive.calcLocalFitnessAndUpdate( genomes, fitness_list, feature_list) NEAT.ZipFitness(genomes, local_fitness_list) current = {g.GetID(): g for g in genomes} print() maxf, meanf = max(fitness_list), sum(fitness_list) / float( len(fitness_list)) print('Fitness - avg: %f, max:%f' % (meanf, maxf)) print('Local Fitness - avg: %f, max:%f' % (np.mean(local_fitness_list), max(local_fitness_list))) print('Top 5 Local Fitness', sorted(archive.local_fitnesses, reverse=True)[:5]) np.save(pjoin(hist_dir, "%i" % generation), np.array(archive.local_fitnesses)) top_n = archive.topNGenomes(N) avg_local_fitness = sum(f for f, gid in top_n) if max_ever is None or avg_local_fitness > max_ever: print('New best average best local fitness!', avg_local_fitness) max_ever = avg_local_fitness for i, (local_fitness, genome_id) in enumerate(top_n): # Only save a genome if we have not seen it before. if genome_id in current: genome = current[genome_id] traits = genome.GetGenomeTraits() coral_dir = pjoin(corals_dir, "%i_%i" % (generation, genome_id)) os.mkdir(coral_dir) genome.Save(pjoin(coral_dir, 'genome.txt')) with open(pjoin(coral_dir, 'traits.txt'), "w+") as f: for k, v in sorted(traits.items()): f.write("%s\t%f\n" % (k, v)) simulate_genome(genome, traits, [params], export_folder=coral_dir) with open(pjoin(best_dir, '%i.txt' % generation), 'w+') as out: for local_fitness, genome_id in top_n: out.write('%i\t%f\n' % (genome_id, local_fitness)) pop.Epoch()
print(k, '= %3.4f' % v, end=', ') else: print(k, '= {0}'.format(v), end=', ') print() print('Links:') for tr in g.GetLinkTraits(): print(tr[0], tr[1], end=': ') for k, v in tr[2].items(): if isinstance(v, float): print(k, '= %3.4f' % v, end=', ') else: print(k, '= {0}'.format(v), end=', ') print() print() for generation in range(1000): genome_list = NEAT.GetGenomeList(pop) fitness_list = NEAT.EvaluateGenomeList_Serial(genome_list, evaluate, display=False) NEAT.ZipFitness(genome_list, fitness_list) PrintGenomeTraits(pop.GetBestGenome()) print() print('Fitnesss:', max(fitness_list), 'Generation:', generation) print() pop.Epoch()
def main(use_futures, redirect_out=True): comm = MPI.COMM_WORLD rank = comm.Get_rank() # mode = MPI.MODE_CREATE | MPI.MODE_WRONLY if redirect_out: sys.stdout = open('out.txt', 'w') sys.stderr = open('err.txt', 'w') print("Prepare traits and genomes") neat_params = neat.Parameters() system( "grep -v '//' < input/neat_parameters.txt | grep . > input/neat_parameters.filtered.txt" ) neat_params.Load('input/neat_parameters.filtered.txt') system("rm input/neat_parameters.filtered.txt") # system("grep -v '//' < input/global_parameters.json | grep . > input/global_parameters.filtered.json") # network_parameters = json.load(open('input/global_parameters.filtered.json', 'r')) # system("rm input/global_parameters.filtered.json") # mode = MPI.MODE_RDONLY network_parameters = json.load(open('input/global_parameters.json', 'r')) # network_parameters = json.load(open(comm, 'input/global_parameters.json', mode)) for trait_name, trait_value in traits.network_traits.items(): neat_params.SetGenomeTraitParameters(trait_name, trait_value) for trait_name, trait_value in traits.neuron_traits.items(): # change to SetNeuronTraitParameters to let the neuron parameters mutate individually for each neuron neat_params.SetGenomeTraitParameters(trait_name, trait_value) for trait_name, trait_value in traits.synapse_traits.items(): # change to SetLinkTraitParameters to let the synapse parameters mutate individually for each synapse neat_params.SetGenomeTraitParameters(trait_name, trait_value) genome = neat.Genome( 0, # Some genome ID, I don't know what it means. network_parameters['inputs_number'], 2, # ignored for seed_type == 0, specifies number of hidden units if seed_type == 1 network_parameters['outputs_number'], False, #fs_neat. If == 1, a minimalistic perceptron is created: each output is connected to a random input and the bias. neat.ActivationFunction. UNSIGNED_SIGMOID, # output neurons activation function neat.ActivationFunction. UNSIGNED_SIGMOID, # hidden neurons activation function 0, # seedtype neat_params, # global parameters object returned by neat.Parameters() 0 # number of hidden layers ) population = neat.Population( genome, neat_params, True, # whether to randomize the population 0.5, # how much to randomize 0 # the RNG seed ) # fh = MPI.File.Open(comm, "datafile", mode) # line1 = str(comm.rank)*(comm.rank+1) + '\n' # line2 = chr(ord('a')+comm.rank)*(comm.rank+1) + '\n' # fh.Write_ordered(line1) # fh.Write_ordered(line2) # fh.Close() print("Start solving generations") outfile = open('output/fitness.txt', 'w') # mode = MPI.MODE_CREATE | MPI.MODE_WRONLY # outfile = MPI.File.Open(comm, 'output/fitness.txt', mode) # with open('output/fitness.txt', 'w') as outfile: for generation_number in range(network_parameters['generations']): print("Generation " + str(generation_number) + " started") genome_list = neat.GetGenomeList(population) fitnesses_list = [] # map(prepare_genomes, genome_list) for genome in genome_list: prepare_genomes(genome) if use_futures: executor = fut.MPIPoolExecutor() # fitnesses_list = executor.map(evaluate_futures, genome_list) for fitness in executor.map(evaluate_futures, genome_list): fitnesses_list.append(fitness) else: # fitnesses_list = map(evaluate, genome_list) for genome in genome_list: fitnesses_list.append(evaluate(genome)) neat.ZipFitness(genome_list, fitnesses_list) population.GetBestGenome().Save('output/best_genome.txt') # mode = MPI.MODE_APPEND # genomefile = MPI.File.Open(comm, 'output/best_genome.txt', mode) # genomefile.Write_ordered('\n' + str(population.GetBestGenome().GetNeuronTraits()) + # '\n' + str(population.GetBestGenome().GetGenomeTraits())) # genomefile.Close() genomefile = open('output/best_genome.txt', 'a') genomefile.write('\n' + str(population.GetBestGenome().GetNeuronTraits()) + '\n' + str(population.GetBestGenome().GetGenomeTraits())) genomefile.close() # copytree('genome' + str(population.GetBestGenome().GetID()), # 'output/generation' + str(generation_number) + '_best_genome') try: copytree( 'genome' + str(population.GetBestGenome().GetID()), 'output/generation' + str(generation_number) + '_best_genome') except FileExistsError: print('folder generation' + str(generation_number) + '_best_genome exists') # outfile.Write_ordered(str(generation_number) + '\t' + str(max(fitnesses_list)) + '\n') outfile.write( str(generation_number) + '\t' + str(max(fitnesses_list)) + '\n') outfile.flush() # sys.stderr.write( # '\rGeneration ' + str(generation_number) # + ': fitness = ' + str(population.GetBestGenome().GetFitness()) # ) # advance to the next generation print("Generation " + str(generation_number) + \ ": fitness = " + str(population.GetBestGenome().GetFitness())) print("Generation " + str(generation_number) + " finished") population.Epoch() # outfile.Close() outfile.close()
def do_gens(self,gens): evaluate=self.evaluate generations = 0 pop=self.pop #do the requested number of generations of evolution for generation in range(gens): genome_list = NEAT.GetGenomeList(pop) fitness_list=[] behavior_list=[] #get the novb (behavior) for each genome in the pop for genome in genome_list: #evaluate genome in the domain to get behavior and fitness novb,fitness,extra = evaluate(genome) if self.do_magic: #novb=np.sqrt(novb.mean(axis=0).flatten()) novb=np.hstack([novb.max(axis=0),novb.min(axis=0)]).flatten() novb=novb/np.linalg.norm(novb) print novb.max(),novb.min() print novb.shape behavior_list.append(novb) #now calculate novelty scotres if True: print "calculating novelty..." behaviors = behavior_list fitness_list = [] #judge the novelty of a new indiviudal by all the #behaviors of current population + archive compiled_array=numpy.array(self.archive+behavior_list) for k in behavior_list: fitness_list.append(calc_novelty(k,compiled_array)) #randomly add one individual to archive per generation #you can do other things here... see original NS paper if interested.. idx = random.randint(0,len(behaviors)-1) self.archive.append(behaviors[idx]) self.garchive.append(NEAT.Genome(genome_list[idx])) #assign novelty as the fitness for each individual NEAT.ZipFitness(genome_list, fitness_list) if self.checkpoint and generation%self.ci==0: print "saving..." glist = [k for k in genome_list] #to_save = [self.garchive,self.archive,glist,behavior_list] to_save = [self.archive,self.garchive,glist,behavior_list] cPickle.dump(to_save,open("nov%d.pkl"%self.checkpt_counter,"wb")) self.checkpt_counter+=1 print "done!" """ # test net = NEAT.NeuralNetwork() champ=pop.Species[0].GetLeader() champ.BuildPhenotype(net) #evaluate(champ,False) if vis: img = np.zeros((500, 500, 3), dtype=np.uint8) img += 10 NEAT.DrawPhenotype(img, (0, 0, 500, 500), net ) cv2.imshow("nn_win", img) cv2.waitKey(1000) """ print "before epoch" pop.Epoch() print "after epoch" generations = generation