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)
checkpointer = neat.Checkpointer(generation_interval=50)
p.add_reporter(checkpointer)
# Run for up to 300 generations.
if debug:
pe = neat.ParallelEvaluator(2, eval_genome)
winner = p.run(pe.evaluate, 1)
else:
pe = neat.ParallelEvaluator(30, eval_genome)
winner = p.run(pe.evaluate, 1000)
# Display the winning genome.
print('\nBest genome:\n{!s}'.format(winner))
# write the most fit nn
checkpointer.save_checkpoint(config, p, winner,
checkpointer.current_generation)
winner_net = neat.nn.FeedForwardNetwork.create(winner, config)
pickle_winner_net(winner_net)
def run(config_file):
'''Run neat using config_file
Args:
config_file (os.path): Path to 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.
pop = neat.Population(config)
# Add a stdout reporter to show progress in the terminal.
pop.add_reporter(neat.StdOutReporter(True))
stats = neat.StatisticsReporter()
pop.add_reporter(stats)
if RUN_MULTITHREADED:
# Run for up to 300 generations.
pop_eval = neat.ParallelEvaluator(THREADS, eval_genome)
winner = pop.run(pop_eval.evaluate, GENERATIONS)
else:
# Run for up to 300 generations.
winner = pop.run(eval_genomes, 300)
# Display the winning genome.
print('\nBest genome:\n{!s}'.format(winner))
# Save the winner.
with open('winner-feedforward', 'wb') as winner_file:
pickle.dump(winner, winner_file)
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):
# 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(4, eval_genome)
winner = p.run(pe.evaluate, 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)
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 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.
# We restore the population that was the fittest
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(15))
parallel_evaluator = neat.ParallelEvaluator(8, eval_genomes)
# Run for up to 200 generations.
winner = p.run(parallel_evaluator.evaluate)
# 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)
# We save the winner network in a pickle container
with open('winner.pkl', 'wb') as output:
pickle.dump(winner, output, 1)
def train(self, config_file):
local_dir = os.path.dirname(__file__)
config_path = os.path.join(local_dir, config_file)
# Load Config
config = neat.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(50))
# Run for up to 300 generations
pe = neat.ParallelEvaluator(24, self.play)
winner = p.run(pe.evaluate, 1000)
#save winnning genome
with open("winner.pkl", "wb") as output:
pickle.dump(winner, output, 1)
# Display the winning genome.
print('\nBest genome:\n{!s}'.format(winner))
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_name)
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))
pop.add_reporter(neat.Checkpointer(5))
pe = neat.ParallelEvaluator(8, eval_genome)
winner = pop.run(pe.evaluate, 200)
# winner = pop.run(eval_genomes, 300)
# Save the winner.
with open('winner-feedforward', 'wb') as f:
pickle.dump(winner, f)
print(winner)
net = neat.nn.FeedForwardNetwork.create(winner, config)
visualize_winner(net)
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_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)
# TODO restart from checkpoint
# neat.Checkpointer.restore_checkpoint(filename)
# Add a stdout reporter to show progress in the terminal.
p.add_reporter(neat.StdOutReporter(False))
stats = neat.StatisticsReporter()
p.add_reporter(stats)
p.add_reporter(
neat.Checkpointer(generation_interval=100, time_interval_seconds=None))
p.add_reporter(opponent_tracker)
# Run for up to 300 generations.
winner = None
if debug:
winner = p.run(eval_genomes, 300)
else:
pe = neat.ParallelEvaluator(4, eval_genome)
winner = p.run(pe.evaluate)
def run(generation = 0, num_iterations = None):
# Carrega o config
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)
check_point = neat.Checkpointer(generation_interval=5)
pop = None
if(generation == 0):
# Inicia nova população
pop = neat.Population(config)
else:
# Restaura população de um checkpoint
filename = 'neat-checkpoint-' + str(generation)
pop = check_point.restore_checkpoint(filename)
pop.add_reporter(neat.StdOutReporter(True))
pop.add_reporter(check_point)
pe = neat.ParallelEvaluator(None, eval_genome)
winner = pop.run(pe.evaluate, num_iterations)
# Save the winner.
with open('winner', 'wb') as f:
winner_tuple = (winner, config, main_actions)
pickle.dump(winner_tuple, f)
print("Winner salvo")
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-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)
# 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: 'M1', -2: 'M2', -3: 'M3', 0: 'x1', 1: 'x2'}
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(self):
if self.generation > 0:
with gzip.open('checkpoints/neat-checkpoint-{0}'.format(
self.generation)) as f:
self.generation, self.config, population, species_set, rndstate = pickle.load(
f)
self.generation += 1
random.setstate(rndstate)
self.population = neat.Population(
self.config, (population, species_set, self.generation))
else:
self.config = neat.Config(neat.DefaultGenome,
neat.DefaultReproduction,
neat.DefaultSpeciesSet,
neat.DefaultStagnation, 'config')
self.population = neat.Population(self.config)
stats = neat.StatisticsReporter()
self.population.add_reporter(neat.StdOutReporter(True))
self.population.add_reporter(stats)
self.population.add_reporter(
neat.Checkpointer(generation_interval=200,
filename_prefix='checkpoints/neat-checkpoint-'))
self.evaluator_thread = neat.ParallelEvaluator(self.threads,
eval_genome, 4000)
winner = self.population.run(self.evaluator_thread.evaluate,
200) # 200 generations
with open('checkpoints/winner', 'wb') as output:
pickle.dump(winner, output, 1)
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(False))
# stats = neat.StatisticsReporter()
# p.add_reporter(stats)
# winner = p.run(eval_genomes, 300)
pe = neat.ParallelEvaluator(8, eval_genome)
winner = p.run(pe.evaluate, 300)
# Show output of the most fit genome against training data.
winning_net = neat.nn.FeedForwardNetwork.create(winner, config)
winning_player = ANNPlayer(winning_net, "ANN")
results = play_games(100, [winning_player] + OTHER_PLAYERS)
print("Winner sample game results:")
print(results[winning_player.name])
print(sum([1 for x in results[winning_player.name] if x == 1]))
def evolve(config, evalfun, seed, task_name, ngen, checkpoint):
'''
NEAT evolution with parallel evaluator
'''
# Set random seed (including None)
random.seed(seed)
# Make directories for saving results
os.makedirs('models', exist_ok=True)
os.makedirs('visuals', exist_ok=True)
# Create an ordinary population or a population for NoveltySearch
pop = _NoveltyPopulation(config) if config.is_novelty() else Population(
config)
# Add a stdout reporter to show progress in the terminal.
pop.add_reporter(_StdOutReporter(show_species_detail=False))
stats = neat.StatisticsReporter()
pop.add_reporter(stats)
# Add a reporter (which can also checkpoint the best)
pop.add_reporter(_SaveReporter(task_name, checkpoint))
# Create a parallel fitness evaluator
pe = neat.ParallelEvaluator(mp.cpu_count(), evalfun)
# Run for number of generations specified in config file
winner = pop.run(pe.evaluate) if ngen is None else pop.run(
pe.evaluate, ngen)
# Save winner
config.save_genome(winner)
def evolve(config, num_cores):
pop = load_checkpoint(config)
pop.add_reporter(
neat.Checkpointer(1, 600, CHECKPOINTS_DIR + "neat-checkpoint-"))
pop.add_reporter(neat.StdOutReporter(True))
stats = neat.StatisticsReporter()
pop.add_reporter(stats)
pe = neat.ParallelEvaluator(num_cores, evaluate)
while True:
winner = pop.run(pe.evaluate, 1)
visualize.plot_stats(stats,
ylog=False,
view=False,
filename=SESSION_DIR + 'avg_fitness.svg')
visualize.plot_species(stats,
view=False,
filename=SESSION_DIR + 'speciation.svg')
# Save the best Genome from the last 5 gens.
with open(
SESSION_DIR +
'Best-{}.pkl'.format(len(stats.most_fit_genomes)),
'wb') as output:
pickle.dump(winner, output, 1)
if stats.get_fitness_mean()[-1] >= END_DISTANCE:
break
def run():
# Load configuration.
config = neat.Config(neat.SharedGenome, neat.DefaultReproduction,
neat.DefaultSpeciesSet, neat.DefaultStagnation,
'config-feedforward')
# 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, filename_prefix='shared_'))
pe = neat.ParallelEvaluator(multiprocessing.cpu_count(), eval_genome)
# Run until a solution is found.
winner = p.run(pe.evaluate, 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)
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():
pop = Checkpointer.restore_checkpoint('neat-checkpoint-3')
winner = Checkpointer.
stats = neat.StatisticsReporter()
pe = neat.ParallelEvaluator(1, eval_genome)
winner = pop.run(pe.evaluate)
print(winner)
#print(pop.statistics.best_genome())
net = neat.nn.FeedForwardNetwork.create(genome, config)
driver = main(TestNeatDriver(logdata=False, net=net))
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_file, restore_file=None):
# 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 = None
if restore_file is None:
p = neat.Population(config)
else:
p = neat.Checkpointer.restore_checkpoint(restore_file)
p.add_reporter(neat.Checkpointer(generation_interval=10, time_interval_seconds=None))
p.add_reporter(trackers.AssistanceRequestTracker(p.generation))
p.add_reporter(trackers.ReportBestTracker(p.generation))
# Run for up to 300 generations.
winner = None
if debug:
winner = p.run(eval_genomes, 300)
else:
pe = neat.ParallelEvaluator(4, eval_genome)
winner = p.run(pe.evaluate)
print('\nBest genome:\n{!s}'.format(winner))
print("Saving as winner-genome-{}.pkl".format(winner.fitness))
with open('winner-genome-{}.pkl'.format(winner.fitness), 'wb') as output:
pickle.dump(winner, output, 1)
visualize.plot_stats(stats, ylog=False, view=True)
visualize.plot_species(stats, view=True)
def run():
# Load configuration.
config = neat.Config(neat.SharedGenome, neat.DefaultReproduction,
neat.DefaultSpeciesSet, neat.DefaultStagnation,
'config-feedforward')
# 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(False))
pe = neat.ParallelEvaluator(multiprocessing.cpu_count(), eval_genome)
# Run until a solution is found.
winner = p.run(pe.evaluate, 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))
def run():
# Load the config file, which is assumed to live in
# the same directory as this script.
pop = Checkpointer().restore_checkpoint("neat-checkpoint-27")
# local_dir = os.path.dirname(__file__)
# config_path = os.path.join(local_dir, 'config-ctrnn')
# config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,
# neat.DefaultSpeciesSet, neat.DefaultStagnation,
# config_path)
# pop = neat.Population(config)
stats = neat.StatisticsReporter()
check = Checkpointer(2, time_interval_seconds=None)
pop.add_reporter(stats)
pop.add_reporter(check)
pop.add_reporter(neat.StdOutReporter(True))
pe = neat.ParallelEvaluator(1, eval_genome)
winner = pop.run(pe.evaluate, 500)
# Save the winner.
with open('winner-feedforward', 'wb') as f:
pickle.dump(winner, f)
print(winner)
def run():
run_parallel = False
# 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-cartpole')
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))
max_generations = 300
if run_parallel:
pe = neat.ParallelEvaluator(8, eval_genome)
winner = pop.run(pe.evaluate, max_generations)
else:
winner = pop.run(eval_genomes, max_generations)
# Save the winner.
with open('winner-feedforward', 'wb') as f:
pickle.dump(winner, f)
print(winner)
visualize.plot_stats(stats,
ylog=True,
view=False,
filename="feedforward-fitness.svg")
def evolve(config, num_cores):
pop = load_checkpoint(config)
pop.add_reporter(
neat.Checkpointer(1, 600, CHECKPOINTS_DIR + "neat-checkpoint-"))
pop.add_reporter(neat.StdOutReporter(True))
stats = neat.StatisticsReporter()
pop.add_reporter(stats)
pe = neat.ParallelEvaluator(num_cores, evaluate)
for gen in range(500):
winner = pop.run(pe.evaluate, 1)
winner_distance = play_best(winner, config)
with open(SESSION_DIR + 'stats.csv', mode='a') as stats_file:
stats_writer = csv.writer(stats_file,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_MINIMAL)
stats_writer.writerow([gen, winner_distance])
with open(
SESSION_DIR +
'Best-{}.pkl'.format(len(stats.most_fit_genomes)),
'wb') as output:
pickle.dump(winner, output, 1)
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')
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))
# runs evaluation functions in parallel subprocesses in order to evaluate multiple genomes at once.
pe = neat.ParallelEvaluator(multiprocessing.cpu_count(), eval_genome)
winner = pop.run(pe.evaluate)
# Save the winner.
with open('winner-NEAT-pickle', 'wb') as f:
pickle.dump(winner, f)
print(winner)
visualize.plot_stats(stats,
ylog=True,
view=True,
filename="winner-NEAT-fitness")
visualize.plot_species(stats, view=True, filename="winner-NEAT-speciation")
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(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(2, eval_genomes)
winner = p.run(pe.evaluate, 2000)
winner_net = neat.nn.FeedForwardNetwork.create(winner, config)
accuracy = 0.0
for xi, yo in zip(X_test, y_test):
output = winner_net.activate(xi)
if (np.argmax(yo) == np.argmax(output)):
accuracy += 1
print("\nAccuracy: ", accuracy / len(y))
file1 = open("results-05d.txt", "w")
file1.write("Accuracy test: ")
file1.write(str(accuracy / len(y)))
file1.write('\nBest genome:\n{!s}'.format(winner))
file1.close()
with open('winner-5d', 'wb') as f:
pickle.dump(winner, f)
def run(config_file): # Load configuration. 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) corecount = 1 if (CORES == 0): corecount = multiprocessing.cpu_count() else: corecount = CORES pe = neat.ParallelEvaluator(corecount, eval_genome) # Run for up to x generations. winner = p.run(pe.evaluate, GENERATIONS) #save winning version pickle.dump( winner , open( './models/model.pkl' , 'wb' ) )
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 = 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))
if True:
winner = pop.run(eval_genomes, 2000)
else:
pe = neat.ParallelEvaluator(4, eval_genome)
winner = pop.run(pe.evaluate, 2000)
# Save the winner.
with open('winner-ctrnn', 'wb') as f:
pickle.dump(winner, f)
print(winner)
def run(config_file):
""" Main function that runs the neat platform
- Loads the config file
- Initializes the population according to the parameters of the config file
- Add a Reporter to collect statistics of the runs
- Add a Checkpointer to save (using picke):
generation, config, population, species_set, rndstate
"""
# 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.
custom_stats = custom_report.StdOutReporter()
p.add_reporter(custom_stats)
# save a checkpointer each generation
p.add_reporter(neat.Checkpointer(1))
# Run using parallelizing with thenumber of processors for NUM_GENERATIONS
pe = neat.ParallelEvaluator(multiprocessing.cpu_count(), eval_genome)
winner = p.run(pe.evaluate, NUM_GENERATIONS)
# save the results of the Statistics collected by the Reporter into a csv
custom_stats.save_table('stats_table')