def run(config_file): # Load configuration. config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_file) # Create the population, which is the top-level object for a NEAT run. p = neat.Population(config) # Add a stdout reporter to show progress in the terminal. p.add_reporter(neat.StdOutReporter(True)) stats = neat.StatisticsReporter() p.add_reporter(stats) p.add_reporter(neat.Checkpointer(50)) # Run for up to 300 generations. winner = p.run(eval_genomes, 300) # Display the winning genome. print('\nBest genome:\n{!s}'.format(winner)) # Show output of the most fit genome against training data. print('\nOutput:') winner_net = neat.nn.FeedForwardNetwork.create(winner, config) for xi, xo in zip(xor_inputs, xor_outputs): output = winner_net.activate(xi) print("input {!r}, expected output {!r}, got {!r}".format(xi, xo, output)) node_names = {-1:'A', -2: 'B', 0:'A XOR B'} visualize.draw_net(config, winner, True, node_names=node_names) visualize.plot_stats(stats, ylog=False, view=True) visualize.plot_species(stats, view=True) p = neat.Checkpointer.restore_checkpoint('neat-checkpoint-49') p.run(eval_genomes, 10)
def run(): # Determine path to configuration file. local_dir = os.path.dirname(__file__) config_path = os.path.join(local_dir, 'config') config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_path) # Demonstration of saving a configuration back to a text file. config.save('test_save_config.txt') # Demonstration of how to add your own custom activation function. # This sinc function will be available if my_sinc_function is included in the # config file activation_options option under the DefaultGenome section. config.genome_config.add_activation('my_sinc_function', sinc) pop = neat.Population(config) stats = neat.StatisticsReporter() pop.add_reporter(stats) pop.add_reporter(neat.StdOutReporter(True)) if 1: pe = neat.ParallelEvaluator(4, eval_genome) winner = pop.run(pe.evaluate, 1000) else: winner = pop.run(eval_genomes, 1000) # Log statistics. stats.save() # Show output of the most fit genome against a random input. print('\nBest genome:\n{!s}'.format(winner)) print('\nOutput:') winner_net = neat.nn.RecurrentNetwork.create(winner, config) num_correct = 0 for n in range(num_tests): print('\nRun {0} output:'.format(n)) seq = [random.choice((0.0, 1.0)) for _ in range(N)] winner_net.reset() for s in seq: inputs = [s, 0.0] winner_net.activate(inputs) print('\tseq {0}'.format(inputs)) correct = True for s in seq: output = winner_net.activate([0, 1]) print("\texpected {0:1.5f} got {1:1.5f}".format(s, output[0])) correct = correct and round(output[0]) == s print("OK" if correct else "FAIL") num_correct += 1 if correct else 0 print("{0} of {1} correct {2:.2f}%".format(num_correct, num_tests, num_correct/num_tests)) node_names = {-1: 'input', -2: 'gate', 0: 'output'} visualize.draw_net(config, winner, True, node_names=node_names) visualize.plot_stats(stats, ylog=False, view=True)
def eval_genomes(self, genomes, config): for genome_id, genome in genomes: net = neat.nn.FeedForwardNetwork.create(genome, config) genome.fitness = self.evalNet(net) if self.bestFitness < genome.fitness: self.bestFitness = genome.fitness print("New Best Fitness: " + str(self.circuit.getFitness())) self.circuit.drawResult() visualize.plot_stats(self.stats, ylog=False, view=True)
def main(config_file='config.txt', save_dir='nets'): # Parse command-line arguments parser = argparse.ArgumentParser() parser.add_argument('-g', '--ngen', type=int, required=False, help='Number of generations to run') parser.add_argument('-r', '--reps', type=int, default=10, required=False, help='Number of repetitions per genome') parser.add_argument('-v', '--viz', dest='visualize', action='store_true') parser.add_argument('-s', '--seed', type=int, required=False, help='Seed for random number generator') args = parser.parse_args() # Set random seed if indicated random.seed(args.seed) # Make directory for pickling nets, if it doesn't already exist _makedir(save_dir) # Load configuration. config = CopterConfig(config_file, args.reps) # Create the population, which is the top-level object for a NEAT run. p = neat.Population(config) # Add a stdout reporter to show progress in the terminal. p.add_reporter(neat.StdOutReporter(True)) stats = neat.StatisticsReporter() p.add_reporter(stats) # Create a parallel fitness evaluator pe = neat.ParallelEvaluator(multiprocessing.cpu_count(), eval_genome) # Runn for number of generations specified in config file winner = p.run(pe.evaluate) if args.ngen is None else p.run( pe.evaluate, args.ngen) # Pickle the winner filename = '%s/%f.dat' % (save_dir, winner.fitness) print('Saving %s' % filename) pickle.dump((winner, config), open(filename, 'wb')) # Visualize results if indicated if args.visualize: visualize.plot_stats(stats, ylog=False, view=True) visualize.plot_species(stats, view=True)
def run(config_file): global env # Load configuration. config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_file) # Create the population, which is the top-level object for a NEAT run. p = neat.Population(config) #p = neat.Checkpointer.restore_checkpoint('neat-checkpoint-9') # Add a stdout reporter to show progress in the terminal. p.add_reporter(neat.StdOutReporter(True)) stats = neat.StatisticsReporter() p.add_reporter(stats) p.add_reporter(neat.Checkpointer(10)) reward_list = [] #for j in range(20): # Run for up to 300 generations. winner = p.run(eval_genomes, 300) print(reward_list) # Display the winning genome. print('\nBest genome:\n{!s}'.format(winner)) # Show output of the most fit genome against training data. print('\nOutput:') visualize.draw_net(config, winner, True) visualize.plot_stats(stats, ylog=False, view=True) visualize.plot_species(stats, view=True) visualize.draw_net(config, winner, view=True, filename="winner-feedforward-evabled-pruneg.gv", show_disabled=False, prune_unused=True) winner_net = neat.nn.FeedForwardNetwork.create(winner, config) final_reward = 0 #env = wrappers.Monitor(env, '/mnt/c/Users/bc/Documents/EA/neat/BipedalWalker/movies', force=True) observation = env.reset() while True: action = winner_net.activate(observation) action = np.clip(action, -1, 1) observation, reward, done, info = env.step(action) final_reward += reward if done: print("final_reward :", final_reward) break #winner_net = neat.nn.FeedForwardNetwork.create(winner, config) for n, g in enumerate([winner]): visualize.draw_net(config, g, view=False, filename=str(j) + "-net-enabled-pruned.gv", show_disabled=False, prune_unused=True)
def run(config_file): # Load configuration. config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_file) # Create the population, which is the top-level object for a NEAT run. p = neat.Population(config) # Add a stdout reporter to show progress in the terminal. # True == show all species, False == don't show species p.add_reporter(neat.StdOutReporter(False)) stats = neat.StatisticsReporter() p.add_reporter(stats) p.add_reporter(neat.Checkpointer(5)) # Stop running after n=n_generations # if n=None runs until solution is found winner = p.run(eval_genomes, n=n_generations) # Display the winning genome. print('\nBest genome:\n{!s}'.format(winner)) # Show output of the most fit genome against testing data. print('\nTest Output, Actual, Diff:') winner_net = neat.nn.FeedForwardNetwork.create(winner, config) predicted = [] for xi, xo in zip(test_x, test_y): output = winner_net.activate(xi) predicted.append(output) node_names = { -1: '4', -2: '3', -3: '2', -4: '1', -5: '0', 0: 'Predict Change' } visualize.draw_net(config, winner, True, node_names=node_names) visualize.plot_stats(stats, ylog=False, view=True) visualize.plot_species(stats, view=True) # ? save? #p = neat.Checkpointer.restore_checkpoint('neat-checkpoint') #p.run(eval_genomes, n_evaluate) # plot predictions vs actual plt.plot(test_y, 'g', label='Actual') plt.plot(predicted, 'r-', label='Predicted') plt.title('Test Data') plt.legend() plt.show()
def run(config_file): # Load configuration. config = neat.Config( neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_file, ) # Create the population, which is the top-level object for a NEAT run. p = neat.Population(config) # Add a stdout reporter to show progress in the terminal. p.add_reporter(neat.StdOutReporter(True)) stats = neat.StatisticsReporter() p.add_reporter(stats) # Run for up to 300 generations. pe = neat.ParallelEvaluator(multiprocessing.cpu_count(), eval_genome) winner = p.run(pe.evaluate, 500) # Display the winning genome. print("\nBest genome:\n{!s}".format(winner)) # Show output of the most fit genome against training data. print("\nOutput:") winner_net = neat.nn.FeedForwardNetwork.create(winner, config) for xi, xo in zip(xor_inputs, xor_outputs): output = winner_net.activate(xi) # print("input {!r}, expected output {!r}, got {!r}".format(xi, xo, output)) df=pd.read_csv(inputs + 'bpusd_test_X.csv', sep=' ',header=None) new_test_X = df.values X_test_inputs = [] for i in range(len(new_test_X)): X_test_inputs.append(tuple(new_test_X[i])) predictions_enn = [] for xi in X_test_inputs: output = winner_net.activate(xi) predictions_enn.append(output) np.savetxt(inputs + 'predictions_enn.csv', np.array(predictions_enn), delimiter=',') real_y=pd.read_csv(inputs + 'bpusd_test_Y.csv', sep=' ',header=None) mse = np.sum((np.array(real_y) - predictions_enn)**2)/(len(predictions_enn)) mae = np.average(np.abs(np.array(real_y) - predictions_enn)) print("MSE:", mse) print("MAE:", mae) node_names = {-1: "t-7", -2: "t-6", -3: "t-5", -4:"t-4", -5:"t-3", -6:"t-2", -7:"t-1",0: "Target"} visualize.draw_net(config, winner, True, node_names=node_names) visualize.plot_stats(stats, ylog=False, view=False) visualize.plot_species(stats, view=False)
def run(config_file): # Load configuration. config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_file) # Create the population, which is the top-level object for a NEAT run. p = neat.Population(config) # Add a stdout reporter to show progress in the terminal. p.add_reporter(neat.StdOutReporter(True)) stats = neat.StatisticsReporter() p.add_reporter(stats) p.add_reporter(neat.Checkpointer(300)) # Run for up to 300 generations. start_time = time.time() winner = p.run(eval_genomes, 5000) stats.save() print(stats.best_genomes(5)) # Display the winning genome. print('\nBest genome:\n{!s}'.format(winner)) # Show output of the most fit genome against training data. print('\nOutput:') winner_net = neat.nn.FeedForwardNetwork.create(winner, config) for xi, xo in zip(xor_inputs, xor_outputs): output = winner_net.activate(xi) print("input , expected output {!r}, got {!r}".format(xo, output)) # test on testset fitness_test = 0 for xi_test, xo_test in zip(test_inputs, test_outputs): output_test = winner_net.activate(xi_test) if abs(output_test[0] - xo_test[0]) < 0.1: fitness_test += 1 else: fitness_test += 0 test_evaluation = fitness_test / float(len(test_outputs)) print("\nTest evaluation: {!r}".format(test_evaluation)) print("--- %s seconds ---" % (time.time() - start_time)) node_names = {0: 'Output'} visualize.draw_net(config, winner, True, node_names=node_names) visualize.plot_stats(stats, ylog=False, view=True) visualize.plot_species(stats, view=True) p = neat.Checkpointer.restore_checkpoint('neat-checkpoint-4') p.run(eval_genomes, 10)
def run(): # get config local_dir = os.path.dirname(__file__) config_path = os.path.join(local_dir, 'config-feedforward-icegame') config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_path) # set population and set reporting options pop = neat.Population(config) stats = neat.StatisticsReporter() pop.add_reporter(stats) pop.add_reporter(neat.StdOutReporter(True)) # Checkpoint every x gen or y minutes pop.add_reporter( neat.Checkpointer(500, 900, "checkpoints/" + fn_results + "-checkpoint")) #winner = pop.run(eval_genomes, NUM_GEN) # non-parallel pe = neat.ParallelEvaluator(NUM_WORKERS, eval_genome) # parallel winner = pop.run(pe.evaluate, NUM_GEN) # save network with open("results/winner-pickle-" + fn_results, 'wb') as f: pickle.dump(winner, f) #print(winner) visualize.plot_stats(stats, ylog=True, view=True, filename="results/" + fn_results + "-fitness.svg") visualize.plot_species(stats, view=True, filename="results/" + fn_results + "-speciation.svg") if DRAW_NETS: visualize.draw_net(config, winner, view=True, filename="results/winner-" + fn_results + ".net") visualize.draw_net(config, winner, view=True, filename="results/winner-" + fn_results + "-enabled.net", show_disabled=False) visualize.draw_net(config, winner, view=True, filename="results/winner-" + fn_results + "-pruned.net", show_disabled=False, prune_unused=True)
def run(config_file): # Load configuration. config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_file) # Create the population, which is the top-level object for a NEAT run. p = neat.Population(config) # Add a stdout reporter to show progress in the terminal. p.add_reporter(neat.StdOutReporter(True)) stats = neat.StatisticsReporter() p.add_reporter(stats) p.add_reporter(neat.Checkpointer(5)) # Run for up to 300 generations. winner = p.run(eval_genomes, 300) # Display the winning genome. print('\nBest genome:\n{!s}'.format(winner)) # Show output of the most fit genome against training data. print('\nOutput:') #Show the winning Snake winner_net = neat.nn.FeedForwardNetwork.create(winner, config) champ = Snake(winner_net) champ.play() ''' winner_net = neat.nn.FeedForwardNetwork.create(winner, config) for xi, xo in zip(xor_inputs, xor_outputs): output = winner_net.activate(xi) print("input {!r}, expected output {!r}, got {!r}".format(xi, xo, output)) ''' node_names = { -1: 'A', -2: 'B', -3: 'C', -4: 'D', -5: 'E', -6: 'F', -7: 'G', -8: 'H', -9: 'I', -10: 'J', -11: 'K', -12: 'L', 0: 'DOWN', 1: 'UP', 2: 'LEFT', 3: 'RIGHT' } visualize.draw_net(config, winner, True, node_names=node_names) visualize.plot_stats(stats, ylog=False, view=True) visualize.plot_species(stats, view=True)
def run(): # Load the config file, which is assumed to live in # the same directory as this script. local_dir = os.path.dirname(__file__) config_path = os.path.join(local_dir, 'config-ctrnn') config = neatfast.Config(neatfast.DefaultGenome, neatfast.DefaultReproduction, neatfast.DefaultSpeciesSet, neatfast.DefaultStagnation, config_path) pop = neatfast.Population(config) stats = neatfast.StatisticsReporter() pop.add_reporter(stats) pop.add_reporter(neatfast.StdOutReporter(True)) if 0: winner = pop.run(eval_genomes) else: pe = neatfast.ParallelEvaluator(4, eval_genome) winner = pop.run(pe.evaluate) # Save the winner. with open('winner-ctrnn', 'wb') as f: pickle.dump(winner, f) print(winner) visualize.plot_stats(stats, ylog=True, view=True, filename="ctrnn-fitness.svg") visualize.plot_species(stats, view=True, filename="ctrnn-speciation.svg") node_names = {-1: 'x', -2: 'dx', -3: 'theta', -4: 'dtheta', 0: 'control'} visualize.draw_net(config, winner, True, node_names=node_names) visualize.draw_net(config, winner, view=True, node_names=node_names, filename="winner-ctrnn.gv") visualize.draw_net(config, winner, view=True, node_names=node_names, filename="winner-ctrnn-enabled.gv", show_disabled=False) visualize.draw_net(config, winner, view=True, node_names=node_names, filename="winner-ctrnn-enabled-pruned.gv", show_disabled=False, prune_unused=True)
def run(): local_dir = os.path.dirname(__file__) config_path = os.path.join(local_dir, 'config-feedforward') config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_path) pop = neat.Population(config) stats = neat.StatisticsReporter() pop.add_reporter(stats) pop.add_reporter(neat.StdOutReporter(True)) # pe = neat.ParallelEvaluator(4, eval_genome) # winner = pop.run(pe.evaluate) winner = pop.run(eval_genomes, 50) # Save the winner. with open("my_network.data", 'wb') as fd: pickle.dump((winner, config, stats), fd) # with open("my_network.data", 'rb') as fd: # winner, config, stats = pickle.load(fd) print(winner) visualize.plot_stats(stats, ylog=True, view=True, filename="feedforward-fitness.svg") visualize.plot_species(stats, view=True, filename="feedforward-speciation.svg") node_names = {-1: 'x', -2: 'dx', -3: 'theta', -4: 'dtheta', 0: 'control'} visualize.draw_net(config, winner, True, node_names=node_names) visualize.draw_net(config, winner, view=True, node_names=node_names, filename="winner-feedforward.gv") visualize.draw_net(config, winner, view=True, node_names=node_names, filename="winner-feedforward-enabled.gv", show_disabled=False) visualize.draw_net(config, winner, view=True, node_names=node_names, filename="winner-feedforward-enabled-pruned.gv", show_disabled=False, prune_unused=True)
def run(config_path): config = neat.config.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_path) p = neat.Population(config) p.add_reporter(neat.StdOutReporter(True)) stats = neat.statistics.StatisticsReporter() p.add_reporter(stats) winner = p.run(main, 100) visualize.plot_stats(stats) visualize.plot_score(score_arr)
def run(): config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, CONFIG) pop = neat.Population(config) stats = neat.StatisticsReporter() pop.add_reporter(stats) pop.add_reporter(neat.StdOutReporter(True)) pop.add_reporter(neat.Checkpointer(5)) pop.run(eval_genomes, 10) visualize.plot_stats(stats, ylog=False, view=True) visualize.plot_species(stats, view=True)
def run(config_file): # Load configuration. config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_file) # Create the population, which is the top-level object for a NEAT run. p = neat.Population(config) # Add a stdout reporter to show progress in the terminal. p.add_reporter(neat.StdOutReporter(True)) stats = neat.StatisticsReporter() p.add_reporter(stats) p.add_reporter(neat.Checkpointer(1000 - 1)) # Run for up to 300 generations. winner = p.run(eval_genomes, 5000) # Display the winning genome. print('\nBest genome:\n{!s}'.format(winner)) # Show output of the most fit genome against training data. print('\nOutput:') winner_net = neat.nn.FeedForwardNetwork.create(winner, config) for xi, xo in zip(fizzbuzz_inputs, fizzbuzz_outputs): output = winner_net.activate(xi) print("input {!r}, expected output {!r}, got {!r}".format( xi, xo, output)) outputList = [ fizz_buzz(i, winner_net.activate(binary_encode(i, bitLength))) for i in range(2**bitLength) ] print(outputList) node_names = { -1: 'A', -2: 'B', -3: 'C', -4: 'D', -5: 'E', -6: 'F', -7: 'G', 0: 'Number', 1: 'fizz', 2: 'buzz', 3: 'fizzbuzz' } visualize.draw_net(config, winner, True, node_names=node_names) visualize.plot_stats(stats, ylog=False, view=True)
def run(config_file, generations, binary_file, drawfile, progressfile, statsfile): #Configuring the agent and the evaluation function from eval import eval_one_to_one_3x3 eval_func = eval_one_to_one_3x3 #Preprocessing for inputs: none in_func = reorder_inputs from solve import convert_to_action out_func = convert_to_action #Preprocessing for output - convert float to boolean # Load configuration. config = neat.Config(GuidedMapGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_file) # Create the population, which is the top-level object for a NEAT run. p = neat.Population(config) # Add a stdout reporter to show progress in the terminal. p.add_reporter(neat.StdOutReporter(True)) stats = Reporters.StatReporterv2() p.add_reporter(stats) p.add_reporter(Reporters.ProgressTracker(progressfile)) #p.add_reporter(Reporters.NetRetriever()) #p.add_reporter(neat.Checkpointer(5)) # Run for up to 300 generations. winner = p.run(make_eval_fun(eval_func, in_func, out_func), generations) # Display the winning genome. print('\nBest genome:\n{!s}'.format(winner)) # Show output of the most fit genome against training data. print('\nOutput:') winner_net = create(winner, config, MAP_SIZE) winner_agent = Agent(winner_net, in_func, out_func) print("Score in task: {}".format(eval_func(winner_agent))) print("Input function: Reorder_inputs") print("Output function: convert_to_action") render_network.draw_net(winner_net, filename=drawfile) #Log the maximum fitness over generations from visualize import plot_stats plot_stats(stats, False, view=False, filename=statsfile) #Uncomment the following if you want to save the network in a binary file fp = open(binary_file, 'wb') pickle.dump(winner_net, fp) fp.close()
def __init__(self): # Setup the ROS sensor subscriptions self.sensor_data = {} rospy.init_node('neat', anonymous=True) self.mobility_pub = rospy.Publisher('mobility_type', Bool) imu_sub = rospy.Subscriber('/mobile_base/sensors/imu_data', Imu, self.callback, ('imu')) cam_sub = rospy.Subscriber('/cam1/raw_image', Image, self.callback, ('camera')) lidar_sub = rospy.Subscriber('/scan', LaserScan, self.callback, ('lidar')) #self.sensor_data['imu'] = 1 #self.sensor_data['lidar'] = 2 print('Waiting for sensor data to come in...') while 'imu' not in self.sensor_data and 'lidar' not in self.sensor_data: pass print('Ready') # Setup NEAT local_dir = os.path.dirname(__file__) config_path = os.path.join(local_dir, 'config-ann') config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_path) population = neat.Population(config) population.add_reporter(neat.StdOutReporter(True)) stats = neat.StatisticsReporter() population.add_reporter(stats) population.add_reporter(neat.Checkpointer(5)) # Saves every 5 generations as checkpoints to fall back on # Pass the eval_genomes function to the population object # 'eval_genomes' will be called on each individual in the population to determine their # fitness each generation # 300 is the number of generations to run. This should be configured manually and tweaked for best results most_fit_genome = population.run(self.eval_genomes, 300) most_fit_network = neat.nn.FeedForwardNetwork.create(most_fit_genome, config) # Should probably do a test run with the winning genome's network here to see how well it learned # Write the genome to a file maybe to save it for later # That way when we are not in a learning period, we can just load up the genome, # create the ANN from it, and use it to modify the mobility mechanism # Outputting some graphs with the network, and some graphs on fitness and speciation visualize.draw_net(config, most_fit_genome, True) visualize.plot_stats(stats, ylog=False, view=True) visualize.plot_species(stats, view=True)
def evolutionary_driver(n=5): # Load configuration. config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, 'config') # Create the population, which is the top-level object for a NEAT run. p = neat.Population(config) # Add a stdout reporter to show progress in the terminal. p.add_reporter(neat.StdOutReporter(True)) stats = neat.StatisticsReporter() p.add_reporter(stats) # Run until we achive n. winner = p.run(eval_genomes, n=n) visualize.plot_stats(stats, ylog=False, view=True) visualize.plot_species(stats, view=True) # winner_nn = neat.nn.RecurrentNetwork.create(winner, config) # # test_suite = testing.testSuite[0] # test_suite_to_coverage = [] # # for test_case in test_suite: # input = ( # int(test_case[1][0]), # int(test_case[1][1]), # int(test_case[1][2]), # (int(test_case[1][0]) * int(test_case[1][0])), # (int(test_case[1][1]) * int(test_case[1][1])), # (int(test_case[1][2]) * int(test_case[1][2])), # (int(test_case[1][0]) * int(test_case[1][1])), # (int(test_case[1][1]) * int(test_case[1][2])), # (int(test_case[1][2]) * int(test_case[1][0])), # ) # output_from_nn = winner_nn.activate(input) # output = TriangleApp.TriangleTester(int(output_from_nn[0]), int(output_from_nn[1]), int(output_from_nn[2])) # # output_from_nn = ['TriangleTester', (int(output_from_nn[0]), int(output_from_nn[1]), int(output_from_nn[2])), # output] # test_suite_to_coverage.append(output_from_nn) # # print(test_suite_to_coverage) # result = Coverage.report(test_suite_to_coverage) # print(result) # dump winning genome pickle.dump(winner, open('winner.pkl', 'wb'))
def run(config_file): # Load configuration. config = neat.Config(multiarm.BanditGenome, multiarm.BanditReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_file) # Create the population, which is the top-level object for a NEAT run. p = neat.Population(config) # Add bandit here # bandit = bandit3.RandomMutator(rates=[0.2, 0.1, 0.8, 0.5, 0.2, 0.9]) # bandit = bandit4.PrMutator(rates=[0.2, 0.1, 0.8, 0.5, 0.2, 0.9], single=True) # bandit = bandit4.EpsMutator(plays=[1]) bandit = bandit4.TSMutator() p.reproduction.bandit_type(bandit) # Add a stdout reporter to show progress in the terminal. p.add_reporter(neat.StdOutReporter(True)) stats = neat.StatisticsReporter() p.add_reporter(stats) br = custom_reporter.BanditPrintReporter() p.add_reporter(br) # p.add_reporter(neat.Checkpointer(5)) # Run for up to 200 generations. winner = p.run(eval_genomes, 100) # Display the winning genome. print('\nBest genome:\n{!s}'.format(winner)) # Show output of the most fit genome against training data. # print('\nOutput:') # winner_net = neat.nn.FeedForwardNetwork.create(winner, config) # for xi, xo in zip(xor_inputs, xor_outputs): # output = winner_net.activate(xi) # print("input {!r}, expected output {!r}, got {!r}".format(xi, xo, output)) # for _ in range(10): # x,y = (random(), random()) # output = winner_net.activate((x,y)) # print("input {!r}, expected output {!r}, got {!r}".format((x,y), (true_xor(x,y),), output)) # node_names = {-1:'A', -2: 'B', 0:'A XOR B'} # visualize.draw_net(config, winner, True, node_names=node_names) visualize.draw_net(config, winner, view=True) visualize.draw_net(config, stats.best_genome(), view=True, filename="best_genome") visualize.plot_stats(stats, ylog=False, view=True) visualize.plot_species(stats, view=True)
def run(): # Determine path to configuration file. local_dir = os.path.dirname(__file__) config_path = os.path.join(local_dir, 'config-gru') config = neat.Config(neat.gru.GRUGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_path) pop = neat.Population(config) stats = neat.StatisticsReporter() pop.add_reporter(stats) pop.add_reporter(neat.StdOutReporter(True)) if 1: pe = neat.ParallelEvaluator(4, eval_genome) winner = pop.run(pe.evaluate) else: winner = pop.run(eval_genomes) # Log statistics. stats.save() # Show output of the most fit genome against a random input. print('\nBest genome:\n{!s}'.format(winner)) print('\nOutput:') winner_net = nw.create(winner, config) num_correct = 0 for n in range(num_tests): print('\nRun {0} output:'.format(n)) seq = [random.choice((0.0, 1.0)) for _ in range(N)] winner_net.reset() for s in seq: inputs = [s, 0.0] winner_net.activate(inputs) print('\tseq {0}'.format(inputs)) correct = True for s in seq: output = winner_net.activate([0, 1]) print("\texpected {0:1.5f} got {1:1.5f}".format(s, output[0])) correct = correct and round(output[0]) == s print("OK" if correct else "FAIL") num_correct += 1 if correct else 0 print("{0} of {1} correct {2:.2f}%".format(num_correct, num_tests, num_correct / num_tests)) node_names = {-1: 'input', -2: 'gate', 0: 'output'} visualize.draw_net(config, winner, True, node_names=node_names) visualize.plot_stats(stats, ylog=False, view=True)
def run_scenario(): # Create configuration object config = Config(genome.DefaultGenome, reproduction.DefaultReproduction, species.DefaultSpeciesSet, stagnation.DefaultStagnation, "../config files/config_traverse") # Create a population of genomes using the configuration pop = Population(config) # Set maximum number of episodes episodes = 50 # Add reporters to keep track of the performance of the genomes pop.add_reporter(StdOutReporter(True)) stats = StatisticsReporter() pop.add_reporter(stats) pop.add_reporter( Checkpointer(5, 5, "../checkpoints/walking2/walking-checkpoint-")) # Run NEAT and retrieve the highest performing genomes winner = pop.run(fitness_function, episodes) # Save the highest performing genome save_genome(winner, "moving-genome") # Display the fitness of the highest performing genome print("highest fitness value: {!r}".format(winner.fitness)) # Display the genome's network structure and fitness and species graphs node_names = { -9: 'Right 1', -1: 'Left 1', -8: 'Right 2', -2: 'Left 2', -7: 'Right 3', -3: 'Left 3', -6: 'Right 4', -4: 'Left 4', -5: 'Centre', 0: 'Turn right', 1: 'Turn left', 2: 'Move Forward' } visualize.draw_net(config, winner, True, node_names=node_names) visualize.plot_stats(stats, ylog=False, view=True) visualize.plot_species(stats, view=True) # Close the game once complete game.close()
def run(): # Determine path to configuration file. local_dir = os.path.dirname(__file__) config_path = os.path.join(local_dir, 'config') config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_path) # Demonstration of saving a configuration back to a text file. # config.save('test_save_config.txt') pop = neat.Population(config) stats = neat.StatisticsReporter() pop.add_reporter(stats) pop.add_reporter(neat.StdOutReporter(True)) winner = pop.run(eval_genomes, NUM_OF_GENERATIONS) # Log statistics. stats.save() # Show output of the most fit genome against a random input. print('\nBest genome:\n{!s}'.format(winner)) # print('\nOutput:') # #winner_net = neat.nn.RecurrentNetwork.create(winner, config) # num_correct = 0 # for n in range(num_tests): # print('\nRun {0} output:'.format(n)) # seq = [random.choice((0.0, 1.0)) for _ in range(N)] # winner_net.reset() # for s in seq: # inputs = [s, 0.0] # winner_net.activate(inputs) # print('\tseq {0}'.format(inputs)) # correct = True # for s in seq: # output = winner_net.activate([0, 1]) # print("\texpected {0:1.5f} got {1:1.5f}".format(s, output[0])) # correct = correct and round(output[0]) == s # print("OK" if correct else "FAIL") # num_correct += 1 if correct else 0 # print("{0} of {1} correct {2:.2f}%".format(num_correct, num_tests, num_correct/num_tests)) # node_names = {-1: 'input', -2: 'gate', 0: 'output'} # visualize.draw_net(config, winner, True, node_names=node_names) visualize.plot_stats(stats, ylog=False, view=False) visualize.plot_species(stats, view=False)
def main(): # Load the config file, which is assumed to live in # the same directory as this script. local_dir = os.path.dirname(__file__) config_path = os.path.join(local_dir, 'config-feedforward') config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_path) pop = neat.Population(config) stats = neat.StatisticsReporter() pop.add_reporter(stats) pop.add_reporter(neat.StdOutReporter(True)) pe = neat.ParallelEvaluator(4, eval_genome) winner = pop.run(pe.evaluate, 10000) # Save the winner. with open('winner-feedforward', 'wb') as f: pickle.dump(winner, f) print(winner) visualize.plot_stats(stats, ylog=True, view=True, filename="feedforward-fitness.svg") visualize.plot_species(stats, view=True, filename="feedforward-speciation.svg") node_names = { -1: 'x', -2: 'y', -3: 'l', -4: 'f', -5: 'r', -6: 'dir_x', -7: 'dir_y', 0: 'forward', 1: 'left', 2: 'right' } visualize.draw_net(config, winner, view=True, node_names=node_names, filename="winner-feedforward.gv")
def run(config_file): # Load configuration. config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_file) # Create the population, which is the top-level object for a NEAT run. #p = neat.Population(config) p = neat.Checkpointer.restore_checkpoint('neat-checkpoint-44') # Add a stdout reporter to show progress in the terminal. p.add_reporter(neat.StdOutReporter(True)) stats = neat.StatisticsReporter() p.add_reporter(stats) p.add_reporter(neat.Checkpointer(5)) # Run for up to 300 generations. winner = p.run(eval_genomes, 50) # Display the winning genome. print('\nBest genome:\n{!s}'.format(winner)) # Show output of the most fit genome against training data. print('\nOutput:') winner_net = neat.nn.FeedForwardNetwork.create(winner, config) output = play_game(winner_net, 50) print("Winner Net results:", output) node_names = { -1: 'Prob', -2: 'Blind', -3: 'Pot', -4: 'Tocall', -5: 'River', -6: 'Turn', -7: 'Flop', -8: 'Open', -9: 'OppoRaise', -10: 'OppoCall', -11: 'Oppocheck', 0: 'Fold', 1: 'Call', 2: 'Raise' } visualize.draw_net(config, winner, True, node_names=node_names) visualize.plot_stats(stats, ylog=False, view=True) visualize.plot_species(stats, view=True) #p = neat.Checkpointer.restore_checkpoint('neat-checkpoint-4') #p.run(eval_genomes, 10) stats.save()
def plot_graphs(config, stats, display=False, winner=None): print("Plotting graphs") visualize.plot_stats(stats, ylog=False, view=display, filename=params.testid + "-fitness.svg") visualize.plot_species(stats, view=display, filename=params.testid + "-species.svg") if winner is not None: visualize.draw_net(config, winner, view=display, node_names=None, filename=params.testid + "-net.svg")
def generate_stat_plots(stats, winner): if GENERATE_PLOTS: print("Plotting stats...") visualize.draw_net(config, winner, view=False, node_names=None, filename=PLOT_FILENAME_PREFIX + "net") visualize.plot_stats(stats, ylog=False, view=False, filename=PLOT_FILENAME_PREFIX + "fitness.svg") visualize.plot_species(stats, view=False, filename=PLOT_FILENAME_PREFIX + "species.svg")
def run(): # Determine path to configuration file. local_dir = os.path.dirname(__file__) config_path = os.path.join(local_dir, 'config') config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_path) pop = neat.Population(config) stats = neat.StatisticsReporter() pop.add_reporter(stats) pop.add_reporter(neat.StdOutReporter(True)) pe = neat.ParallelEvaluator(multiprocessing.cpu_count(), eval_genome) winner = pop.run(pe.evaluate, 1000) # Log statistics. stats.save() # Show output of the most fit genome against a random input. print('\nBest genome:\n{!s}'.format(winner)) print('\nOutput:') winner_net = neat.nn.RecurrentNetwork.create(winner, config) num_correct = 0 for n in range(num_tests): print('\nRun {0} output:'.format(n)) num_inputs = random.randint(1, max_inputs) num_ignore = random.randint(0, max_ignore) seq = [random.choice((0.0, 1.0)) for _ in range(num_inputs)] winner_net.reset() outputs = test_network(winner_net, seq, num_ignore) correct = True for i, o in zip(seq, outputs): print("\texpected {0:1.5f} got {1:1.5f}".format(i, o[0])) correct = correct and round(o[0]) == i print("OK" if correct else "FAIL") num_correct += 1 if correct else 0 print("{0} of {1} correct {2:.2f}%".format(num_correct, num_tests, 100.0 * num_correct / num_tests)) node_names = {-1: 'input', -2: 'record', -3: 'play', 0: 'output'} visualize.draw_net(config, winner, True, node_names=node_names) visualize.plot_stats(stats, ylog=False, view=True) visualize.plot_species(stats, view=True)
def run(config_file): config = neat.Config( neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_file ) # crete population, which is the top-level object for a NEAT run pop = neat.Population(config) # add a stdout reporter to show progress in terminal pop.add_reporter(neat.StdOutReporter(True)) stats = neat.StatisticsReporter() pop.add_reporter(stats) pop.add_reporter(neat.Checkpointer(5)) # run for up to 500 generations winner = pop.run(eval_genomes, 10000) # display the winning genome print(f"\nBest genome:\n{winner}") win_net = neat.nn.FeedForwardNetwork.create(winner, config) holdings = 1 cash = 0 for day in tsla: close = day["close"] macd = day["macd"] signal = day["signal"] diff = day["diff"] buy, hold, sell = win_net.activate((holdings, macd, signal, diff)) if buy > hold and buy > sell: if holdings == 0: cash -= close holdings += 1 print(f"bought at {close}, total: {cash + (holdings * close)}") if sell > hold and sell > buy: if holdings == 1: cash += close holdings -= 1 print(f"sold at {close}, total: {cash + (holdings * close)}") visualize.draw_net(config, winner, True) visualize.plot_stats(stats, ylog=False, view=True) visualize.plot_species(stats, view=True)
def bot(config_path): global game_state config = neat.config.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_path) # Create the population, which is the top-level object for a NEAT run. p = neat.Population(config) # Add a stdout reporter to show progress in the terminal. p.add_reporter(neat.StdOutReporter(True)) stats = neat.StatisticsReporter() p.add_reporter(stats) # p.add_reporter(neat.Checkpointer(5)) # Run for up to 50 generations. game_state = "Playing" winner = p.run(playing, generations) # show final stats print('\nBest genome:\n{!s}'.format(winner)) import os os.environ[ "PATH"] += os.pathsep + r'C:\Program Files (x86)\Graphviz2.38\bin' node_names = {1: "velx", 2: "vely", 3: "x", 4: "y", 5: "grounded"} visualize.draw_net(config, winner, view=False) # visualize.draw_net(config, winner, node_names=node_names, view=False) visualize.plot_stats(stats, ylog=False, view=False) visualize.plot_species(stats, view=False) with open("saved_net", 'wb') as pickle_file: pickle.dump(winner, pickle_file) # with open("saved_net", 'rb') as pickle_file: # saved_net = pickle.load(pickle_file) # # net = neat.nn.feed_forward.create(saved_net, config) # playing(net=net) # # neat.Checkpointer.save_checkpoint(config, p, winner, generation=5) # # neat.checkpoint. # p = neat.Checkpointer.restore_checkpoint('saved_net') # p.run(bot, 10) game_state = "Menu"
def eval_parallel(genomes, config): global gen_counter print("Testing generation number {}...".format(gen_counter)) evaluator = neat.parallel.ParallelEvaluator( 12, eval_single, 2 * 60) # quit after 2 min if stuck evaluator.evaluate(genomes, config) with open('stats.obj', 'wb') as stats_file: pickle.dump(stats, stats_file) visualize.plot_stats(stats, ylog=False, view=False) if gen_counter > 2: stats.save() gen_counter += 1
def run(config_file): config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_file) p = neat.Population(config) p.add_reporter(neat.StdOutReporter(False)) stats = neat.StatisticsReporter() p.add_reporter(stats) p.add_reporter(neat.Checkpointer(5)) winner = p.run(eval_genomes, GENERATIONS) print "Best Genome {!s}".format(winner) # winner_net = neat.nn.FeedForwardNetwork.create(winner, config) raw_input('Press ENTER to run the simulation') fitness(SnakeEnv2(grid=np.array(GRID)), winner, config, render=True) visualize.plot_stats(stats, ylog=False, view=True) visualize.plot_species(stats, view=True)
def run(): config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, CONFIG) pop = neat.Population(config) # recode history stats = neat.StatisticsReporter() pop.add_reporter(stats) pop.add_reporter(neat.StdOutReporter(True)) pop.add_reporter(neat.Checkpointer(5)) pop.run(eval_genomes, 10) # train 10 generations # visualize training visualize.plot_stats(stats, ylog=False, view=True) visualize.plot_species(stats, view=True)