def run(config_file, candle_inputs, candle_outputs):
config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,
neat.DefaultSpeciesSet, neat.DefaultStagnation,
config_file)
global inputs, outputs
inputs = candle_inputs
outputs = candle_outputs
p = neat.Population(config)
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))
print('\nOutput:')
winner_net = neat.nn.FeedForwardNetwork.create(winner, config)
for xi, xo in zip(candle_inputs, candle_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.run(eval_genomes, 10)
def evaluation():
CHECKPOINT = 1759
p = neat.Checkpointer.restore_checkpoint('neat-checkpoint-%i' % CHECKPOINT)
winner = p.run(eval_genomes, 1) # find the winner in restored population
# show winner net
# node_names = {-1: 'In0', -2: 'In1', -3: 'In3', -4: 'In4', 0: 'act1', 1: 'act2'}
# visualize.draw_net(p.config, winner, True, node_names=node_names)
node_names = {
-1: 'A',
-2: 'B',
-3: 'C',
-4: 'D',
0: 'a',
1: 'b',
2: 'c',
3: 'd'
}
visualize.draw_net(p.config, winner, True, node_names=node_names)
stats = neat.StatisticsReporter()
visualize.plot_stats(stats, ylog=False, view=True)
visualize.plot_species(stats, view=True)
net = neat.nn.FeedForwardNetwork.create(winner, p.config)
# net = neat.nn.RecurrentNetwork.create(winner, p.config)
while True:
s = env.reset()
done = False
while not done:
env.render()
# a = np.argmax(net.activate(s))
a = net.activate(s)
s, r, done, _ = env.step(a)
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)
print("Train Starting in 3 sec !")
time.sleep(3)
# Run for up to 50 generations.
winner = p.run(eval_genomes, 50)
pickle.dump(winner, open('best-genomes/winner.pkl', 'wb'))
# Visualize winner
node_names = {-1: 'Distance', -2: 'Gap', -3: 'Speed', 0: 'Duck', 1: 'Jump'}
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_experiment(config_file):
config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,
neat.DefaultSpeciesSet, neat.DefaultStagnation,
config_file)
p = neat.Population(config)
p.add_reporter(neat.StdOutReporter(show_species_detail=True))
stats = neat.StatisticsReporter()
p.add_reporter(stats)
p.add_reporter(
neat.Checkpointer(generation_interval=5,
filename_prefix=os.path.join(
local_dir, 'out/neat-checkpoint-')))
best_genome = p.run(fitness_function=eval_genomes, n=300)
best_net = neat.nn.FeedForwardNetwork.create(best_genome, config)
best_genome_fitness = eval_fitness(best_net)
if best_genome_fitness > config.fitness_threshold:
print('\n\nSuccess: The XOR problem solver found!!!')
else:
print('\n\nFailure: Failed to find XOR problem solver!!!')
node_names = {-1: 'A', -2: 'B', 0: 'A XOR B'}
visualize.draw_net(config,
best_genome,
True,
node_names=node_names,
directory=out_dir)
visualize.plot_stats(stats,
ylog=False,
view=True,
filename=os.path.join(out_dir, 'avg_fitness.svg'))
visualize.plot_species(stats,
view=True,
filename=os.path.join(out_dir, 'speciation.svg'))
def run():
# Load the file, witch is assumed to live in the same directory as this script
local_dir = os.path.dirname(__file__)
config_path = os.path.join(local_dir, 'conf_ff.txt')
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))
winner = pop.run(eval_genomes, 300)
node_names = {
-1: 'cPos',
-2: 'cVel',
-3: 'pAng',
-4: 'pAngVel',
0: 'esq ou dir'
}
visualize.draw_net(config, winner, False, node_names=node_names)
visualize.plot_stats(stats, ylog=False, view=True)
visualize.plot_species(stats, view=True)
with open('winner_ff.p', 'wb') as f:
pickle.dump(winner, f)
def main(gen, save_ckpt, load_ckpt, save_path):
config_file = 'config-feedforward.txt'
config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,
neat.DefaultSpeciesSet, neat.DefaultStagnation,
config_file)
# Create population
if load_ckpt is None:
p = neat.Population(config)
else:
p = neat.Checkpointer.restore_checkpoint(load_ckpt)
save_ckpt = load_ckpt.split('_G')[0]
# 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(generation_interval=10,
filename_prefix=f"{save_ckpt}_G"))
# Evolve
winner = p.run(eval_genomes, gen)
print('\nBest genome:\n{}'.format(winner))
print('\nTime Elapsed:', time() - START)
visualize.draw_net(config, winner, False)
visualize.plot_stats(stats, ylog=False, view=False)
visualize.plot_species(stats, view=False)
# Save Genome
pickle.dump(winner, open(save_path, "wb"))
def run():
t0 = time.time()
# Get the path to 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, 'xor2_config')
# Use a pool of four workers to evaluate fitness in parallel.
pe = parallel.ParallelEvaluator(4, fitness)
pop = population.Population(config_path)
pop.run(pe.evaluate, 400)
print("total evolution time {0:.3f} sec".format((time.time() - t0)))
print("time per generation {0:.3f} sec".format(
((time.time() - t0) / pop.generation)))
print('Number of evaluations: {0:d}'.format(pop.total_evaluations))
# Verify network output against training data.
print('\nBest network output:')
winner = pop.statistics.best_genome()
net = nn.create_feed_forward_phenotype(winner)
for i, inputs in enumerate(xor_inputs):
output = net.serial_activate(inputs) # serial activation
print("{0:1.5f} \t {1:1.5f}".format(xor_outputs[i], output[0]))
# Visualize the winner network and plot statistics.
visualize.plot_stats(pop.statistics)
visualize.plot_species(pop.statistics)
visualize.draw_net(winner, view=True)
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(True))
stats = neat.StatisticsReporter()
p.add_reporter(stats)
pe = neat.ParallelEvaluator(4, eval_genome)
winner = p.run(pe.evaluate, 300)
print('\nBest genome:\n{!s}'.format(winner))
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)
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, 'configs/neat_config.cfg')
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(6, eval_genome)
winner = pop.run(pe.evaluate)
# Save the winner.
with open('models/winner-feedforward.model', 'wb') as f:
pickle.dump(winner, f)
visualize.plot_stats(stats,
ylog=True,
view=True,
filename="models/feedforward-fitness.svg")
visualize.plot_species(stats,
view=True,
filename="models/feedforward-speciation.svg")
visualize.draw_net(config, winner, True)
def run(config_file):
config = neat.config.Config(neat.DefaultGenome, neat.DefaultReproduction,
neat.DefaultSpeciesSet, neat.DefaultStagnation,
config_file)
# Create the population
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 x generations. The Generations parameter tells how many
# NEAT calls the eval_genomes fitness function in order to evaluate the population
winner = p.run(eval_genomes, generations)
if (showGraph == "n"):
#Visualization of the winner NN
node_names = {-1: 'Pos', -2: 'Vel', -3: 'Angle', -4: 'VelTip'}
visualize.draw_net(config, winner, True, node_names=node_names)
visualize.plot_stats(stats, ylog=False, view=True)
visualize.plot_species(stats, view=True)
# show final stats
print('\nBest genome:\n{!s}'.format(winner))
#test winner
winner_net = neat.nn.FeedForwardNetwork.create(winner, config)
score = test_model(winner_net) #Tests model 100 times and prints result
return score
def main(config_file):
# Get initial time.
start_time = time()
# Load configuration for NEAT-Python.
config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,
neat.DefaultSpeciesSet, neat.DefaultStagnation,
config_file)
# Create population, core of NEAT algorithm.
pop = neat.Population(config)
# Create stdout reporter to print progress, currently not implemented.
pop.add_reporter(neat.StdOutReporter(False))
stats = neat.StatisticsReporter()
pop.add_reporter(stats)
# Run for unlimited generations max.
para_eval = neat.ParallelEvaluator(4, play_game)
winner = pop.run(para_eval.evaluate, 1000)
# Display winning genome.
print "\nBest Genome: " + str(winner)
print "Running Time (in secs.): " + str(time() - start_time)
visualize.draw_net(config, winner, True)
visualize.plot_stats(stats, ylog=False, view=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))
global stats
stats = neat.StatisticsReporter()
p.add_reporter(stats)
winner = p.run(game_loop, 50)
print('\nBest genome:\n{!s}'.format(winner))
# winner_net = neat.nn.FeedForwardNetwork.create(winner, config)
visualize.draw_net(config, winner, True)
visualize.plot_stats(stats, ylog=False, view=True)
visualize.plot_species(stats, view=True)
with open('winner-river', 'wb') as f:
pickle.dump(winner, f)
with open('my_winner-river', 'wb') as f:
pickle.dump(best_yet[1], f)
print('Minha Seleção:')
print(best_yet)
print(best_yet[0])
print(best_yet[1])
def run(config_file):
# Load configuration file
config = neat.config.Config(neat.DefaultGenome, neat.DefaultReproduction,
neat.DefaultSpeciesSet, neat.DefaultStagnation,
config_file)
p = neat.Population(config)
# Report genome statistics
stats = neat.StatisticsReporter()
p.add_reporter(stats)
# Determine optimal neural network
winner = p.run(eval_genomes, 100) # Evolve 100 generations
# Plot/print the most successful neural network
node_names = {
-1: 'obst_dist',
-2: 'obst_height',
-3: 'obst_width',
-4: 'obst_y',
-5: 'game_speed',
-6: 'dino.y',
-7: 'is_cactus',
0: 'Jump',
1: 'Duck'
}
visualize.draw_net(config, winner, True, node_names=node_names)
print('\nBest genome:\n{!s}'.format(winner))
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 50 generations.
winner = p.run(trainingFunction, 50)
# Display the winning genome.
print('\nBest genome:\n{!s}'.format(winner))
visualize.draw_net(config, winner, True)
visualize.plot_stats(stats, ylog=False, view=True)
visualize.plot_species(stats, view=True)
winner_net = neat.nn.FeedForwardNetwork.create(winner, config)
with open ('backupFile','wb') as backupFile :
pickle.dump( winner_net, backupFile )
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(True))
stats = neat.StatisticsReporter()
p.add_reporter(stats)
p.add_reporter(neat.Checkpointer(300))
# 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.
winner_net = neat.nn.FeedForwardNetwork.create(winner, config)
# Use the winner_net to run through a course in slow-motion
run_course(winner_net, final=True)
visualize.draw_net(config, winner, True)
visualize.plot_stats(stats, ylog=False, view=True)
visualize.plot_species(stats, view=True)
def run(config_path):
"""
Sets up NEAT and displays statistics
Creates visualizations after last generation
"""
global p
config = neat.config.Config(neat.DefaultGenome, neat.DefaultReproduction,
neat.DefaultSpeciesSet, neat.DefaultStagnation,
config_path)
p = neat.Population(config)
stats = neat.StatisticsReporter()
p.add_reporter(neat.StdOutReporter(True))
p.add_reporter(stats)
winner = p.run(main, 50)
print('\nBest genome:\n{!s}'.format(winner))
node_names = {
-1: 'Player y-value',
-2: 'Player distance from enemy',
0: 'Jump'
}
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):
# 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 evaluation():
pop_test = neat.Checkpointer.restore_checkpoint(
'neat-checkpoint-{}'.format(CHECKPOINT))
# find the winner in restored population
winner = pop_test.run(eval_genomes, 1)
# show winner net
node_names = {
-1: 'In0',
-2: 'In1',
-3: 'In3',
-4: 'In4',
0: 'act1',
1: 'act2'
}
visualize.draw_net(pop_test.config, winner, True, node_names=node_names)
net = neat.nn.RecurrentNetwork.create(winner, pop_test.config)
while True:
s = ENV.reset()
while True:
ENV.render()
a = np.argmax(net.activate(s))
s, r, done, _ = ENV.step(a)
if done: break
def eval_parallel(genomes, config):
global current_level
global gen_counter
current_level = levels[gen_counter % len(levels)]
print("Testing generation number {} on level {}...".format(gen_counter, current_level))
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 len(stats.best_genomes(1)) == 0:
print("There is no best genome")
else:
visualize.draw_net(config, stats.best_genome())
if gen_counter > 1:
stats.save()
with open('{}.csv'.format(current_level.replace('/', '-')), 'a') as f:
print('{}, {}, {}, {}'.format(gen_counter, stats.get_fitness_stat(max)[-1], stats.get_fitness_mean()[-1], stats.get_fitness_stdev()[-1]), file=f)
with open('gen_counter.txt', 'w') as f:
f.write(str(gen_counter))
gen_counter += 1
def run(config_file):
"""
runs the NEAT algorithm to train a neural network to play flappy bird.
:param config_file: location of config file
:return: None
"""
config = neat.config.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 50 generations.
print("pre run (with coupled eval_genomes")
winner = p.run(eval_genomes, 150)
# show final stats
print('\nBest genome:\n{!s}'.format(winner))
#4
node_names = {-1:'Bird Y', -2: 'Top Pipe Y', -3:"Bottom Pipe Y", 0:'Jump'}
visualize.draw_net(config, winner, True, 'test', node_names=node_names)
print ('left draw_net')
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(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:')
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-4')
p.run(eval_genomes, 10)
def run(config_file, it, cores):
config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,
neat.DefaultSpeciesSet, neat.DefaultStagnation,
config_file)
# Create the population
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 x generations
pe = neat.ParallelEvaluator(cores, eval_genome)
winner = p.run(pe.evaluate, it)
# Display and save the winning genome
print('\nBest genome:\n{!s}'.format(winner))
with open('winner/winner-parallel.pkl', 'wb') as output:
pickle.dump(winner, output, 1)
visualize.draw_net(config, winner, view=True, filename="draw_net")
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)
p = neat.Population(config)
p.add_reporter(neat.StdOutReporter(True))
stats = neat.StatisticsReporter()
p.add_reporter(stats)
p.add_reporter(
neat.Checkpointer(
5,
filename_prefix=
'checkpoints\\reproduce_image\\feedforward-checkpoint-'))
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)
visualize.draw_net(config, winner, True)
visualize.plot_stats(stats, ylog=False, view=True)
visualize.plot_species(stats, view=True)
def run(generations):
'''
Runs DHN
generations -- number of generations to evolve for
'''
pop = population.Population(config)
# Run the population under a simple evaluation scheme
winner = pop.run(evaluate_xor, generations)
cppn = FeedForwardNetwork.create(winner, config)
substrate = decode(cppn, input_dimensions, num_outputs, sheet_dimensions)
print("WINNER: Genome {0}\n".format(winner.key))
print("Winner Fitness is {0}".format(winner.fitness))
for node in winner.nodes:
print("\t{0}: {1}".format(winner.nodes[node].key,
winner.nodes[node].activation))
for connection in winner.connections:
print("\t{0},{1},{2}".format(connection,
winner.connections[connection].weight,
winner.connections[connection].enabled))
sum_square_error = 0.0
for inputs, expected in zip(xor_inputs, expected_outputs):
print("Expected Output: {0}".format(expected))
actual_output = substrate.activate(inputs)[0]
print("Actual Output: {0}".format(actual_output))
sum_square_error += ((actual_output - expected)**2.0) / 4.0
print("Loss: {0}".format(sum_square_error))
draw_net(cppn, filename="dhn_cppn_winner")
draw_net(substrate, filename="dhn_substrate_winner")
for node in substrate.node_evals:
print("Node: \t{0}:".format(node))
for connection in substrate.values:
print("Value:\t{0}".format(connection))
def run(config_file):
# Load configuration.
config = neat.Config(maps.MapGenome, 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(100))
# 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 = maps.MapNetwork.create(winner, config, MAP_SIZE)
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'}
#The following visualization is not accurate
visualize.draw_net(config, winner, True, node_names=node_names)
visualize.plot_stats(stats, ylog=False, view=True)
visualize.plot_species(stats, view=True)
pickle.dump(winner_net, open("mapsw.bin", "wb"))
def run(config_path):
"""
runs the NEAT algorithm to train a neural network to play flappy bird.
:param config_file: location of config file
:return: None
"""
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)
# run for up to 50 generations
winner = p.run(eval_genomes, 50)
# visualize neural network of winning agent
visualize.draw_net(config, winner, True) #node_names=node_names)
# show final stats
print('\nBest genome:\n{!s}'.format(winner))
def run(config_file):
config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,
neat.DefaultSpeciesSet, neat.DefaultStagnation,
config_file)
population = neat.Population(config)
population.add_reporter(neat.StdOutReporter(True))
stats = neat.StatisticsReporter()
population.add_reporter(stats)
population.add_reporter(neat.Checkpointer(5))
parallelEval = neat.ParallelEvaluator(cpu_count, eval_genomes)
print('Evaluating on {} CPUs'.format(cpu_count))
winner = population.run(parallelEval.evaluate, 1000)
print('\n Best Genome : \n {}'.format(winner))
print('\n\n Output : ')
winner_net = neat.nn.FeedForwardNetwork.create(winner, config)
visualize.draw_net(config, winner, True)
visualize.plot_stats(stats, ylog=False, view=True)
visualize.plot_species(stats, view=True)
environment(winner_net)
def eval_genomes(genomes, config):
global env
global MAX_STEPS
global count
global reward_list
max_episode_fitness = -500
for genome_id, genome in genomes:
genome.fitness = 0
net = neat.nn.FeedForwardNetwork.create(genome, config)
observation = env.reset()
episode_reward = 0
for _ in range(5):
while True:
action = net.activate(observation)
#print("observation",observation)
#print("action",action)
action = np.clip(action, -1, 1)
#env.render()
observation, reward, done, info = env.step(action)
episode_reward += reward
#if (-4.8 > observation[0]) or (observation[0] > 4.8) or (0.017453292519943 < observation[3] < -0.017453292519943) or (episode_reward >= MAX_STEPS):
if done:
#print(episode_reward)
env.reset()
break
#print(episode_reward)
genome.fitness = episode_reward / 5
if max_episode_fitness <= episode_reward / 5:
max_episode_fitness = episode_reward / 5
winner = genome
#print(max_episode_fitness)
reward_list.append(max_episode_fitness / 5)
if count % 10 == 0:
winner_net = neat.nn.FeedForwardNetwork.create(genome, config)
#env = wrappers.Monitor(env, '/home/bc/Documents/EA/experiment/Bipedalwalker/neat/movies', force=True)
#observation = env.reset()
#for i in range(500):
#action = winner_net.activate(observation)
#env.render()
#action = np.clip(action,-1,1)
#observation,reward,done,info = env.step(action)
#episode_reward += reward
#if (-4.8 > observation[0]) or (observation[0] > 4.8) or (0.017453292519943 < observation[3] < -0.017453292519943) or (episode_reward >= MAX_STEPS):
#if done:
#observation = env.reset()
#break
for n, g in enumerate([winner]):
name = '2winner-{0}'.format(n)
with open(name + '.pickle', 'wb') as f:
pickle.dump(g, f)
#visualize.draw_net(config, g, view=False, filename=str(count)+name + "-net.gv")
visualize.draw_net(config,
g,
view=False,
filename=str(count) + "net-enabled.gv",
show_disabled=False)
count += 1
def run(self, 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 MAX_GENERATIONS generations.
p_evaluator = ParallelEvaluatorSims(Const.N_SIMS, run_sim)
winner = p.run(p_evaluator.evaluate, Const.MAX_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 = 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)
visualize.plot_stats(stats, ylog=False, view=True)
visualize.plot_species(stats, view=True)
def run(config_file):
global p, stats, winner
# 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-27')
# 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(1))
# Run for up to 300 generations.
winner = p.run(evalGenomes, 20)
# Display the winning genome.
print('\nBest genome:\n{!s}'.format(winner))
node_names = {0: 'RIGHT', 1: 'UP', 2: 'LEFT', 3: 'DOWN', 4: 'NONE'}
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_scenario():
# Create configuration object
config = Config(genome.DefaultGenome, reproduction.DefaultReproduction, species.DefaultSpeciesSet, stagnation.DefaultStagnation, "../config files/config_walking_V2")
# Set maximum number of episodes
episodes = 50
# Create a population of genomes from the set configuration
pop = Population(config)
# Add reporters to keep track of performance of the genomes
pop.add_reporter(StdOutReporter(True))
stats = StatisticsReporter()
pop.add_reporter(stats)
pop.add_reporter(Checkpointer(5, 5, "../checkpoints/walking2/walking-V2.2-checkpoint-"))
# Run NEAT and retrieve the highest performing genome
winner = pop.run(fitness_function, episodes)
# Save the highest performing genome
save_genome(winner, "moving-genome-PT2.2")
# 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 game once complete
game.close()
def evaluation():
p = neat.Checkpointer.restore_checkpoint('neat-checkpoint-%i' % CHECKPOINT)
winner = p.run(eval_genomes, 1) # find the winner in restored population
# show winner net
node_names = {-1: 'In0', -2: 'In1', -3: 'In3', -4: 'In4', 0: 'act1', 1: 'act2'}
visualize.draw_net(p.config, winner, True, node_names=node_names)
net = neat.nn.FeedForwardNetwork.create(winner, p.config)
while True:
s = env.reset()
while True:
env.render()
a = np.argmax(net.activate(s))
s, r, done, _ = env.step(a)
if done: break
