def train_model(layers,
inputs,
prices,
pop_size=150,
data_rotation=0,
w_mutation_rate = 0.05,
b_mutation_rate = 0.0,
mutation_scale = 0.3,
mutation_decay = 1.,
reporter=None):
# network parameters
network_params = {
'network': 'feedforward',
'input': inputs.shape[1],
'hidden': layers,
'output': 2
}
# build initial population
pop = Population(network_params,
pop_size,
mutation_scale,
w_mutation_rate,
b_mutation_rate,
mutation_decay,
socket_reporter=reporter)
g = 1 ###########
sample_size = 500 # request.json["sampleSize"]
while True:
if not g % data_rotation: ###########
ohlc, ta = data.get_rand_segment(sample_size) ##########
inputs, prices = data.get_training_segment() ##########
pop.evolve()
gen_best = pop.run((inputs, prices), fitness_callback=calc_overperformance)
g += 1
def train_model(layers,
inputs,
prices,
pop_size=150,
data_rotation=0,
w_mutation_rate=0.05,
b_mutation_rate=0.0,
mutation_scale=0.3,
mutation_decay=1.,
reporter=None):
# network parameters
network_params = {
'network': 'feedforward',
'input': inputs.shape[1],
'hidden': layers,
'output': 2
}
# build initial population
pop = Population(network_params,
pop_size,
mutation_scale,
w_mutation_rate,
b_mutation_rate,
mutation_decay,
socket_reporter=reporter)
g = 0
while True:
if g % data_rotation:
# need to rotate data here
pass
pop.evolve()
gen_best = pop.run((inputs, prices), fitness_callback=calculate_profit)
g += 1
def train(
population: Population,
game_config: Config,
games: list,
iterations: int,
unused_cpu: int = 0,
save_interval: int = 10,
):
"""Train the population on the requested number of iterations. Manual adaptation of main's train()."""
population.log("\n===> TRAINING <===\n")
multi_env = get_multi_env(pop=population, game_config=game_config)
msg = f"Repetitive evaluating on games: {games} for {iterations} iterations"
population.log(msg, print_result=False)
# Iterate and evaluate over the games
saved = True
for iteration in range(iterations):
# Set and randomize the games
multi_env.set_games(games, noise=True)
# Prepare the generation's reporters for the generation
population.reporters.start_generation(gen=population.generation,
logger=population.log)
# Fetch the dictionary of genomes
genomes = list(iteritems(population.population))
# Initialize the evaluation-pool
pool = mp.Pool(mp.cpu_count() - unused_cpu)
manager = mp.Manager()
return_dict = manager.dict()
for genome in genomes:
pool.apply_async(func=multi_env.eval_genome,
args=(genome, return_dict))
pool.close() # Close the pool
pool.join() # Postpone continuation until everything is finished
# Calculate the fitness from the given return_dict
fitness = calc_pop_fitness(
fitness_cfg=population.config.evaluation,
game_cfg=game_config.game,
game_obs=return_dict,
gen=population.generation,
)
for i, genome in genomes:
genome.fitness = fitness[i]
# Gather and report statistics
best = None
for g in itervalues(population.population):
if best is None or g.fitness > best.fitness: best = g
population.reporters.post_evaluate(population=population.population,
species=population.species,
best_genome=best,
logger=population.log)
# Update the population's best_genome
genomes = sorted(population.population.items(),
key=lambda x: x[1].fitness,
reverse=True)
population.best_fitness[population.generation] = genomes[0][1].fitness
population.best_genome_hist[population.generation] = genomes[0]
population.best_genome = best
# Let population evolve
population.evolve()
# Update the genomes such all have one hidden node
for g in population.population.values():
n_hidden, _ = g.size()
while n_hidden < 1:
g.mutate_add_connection(population.config.genome)
n_hidden, _ = g.size()
# End generation
population.reporters.end_generation(population=population.population,
name=str(population),
species_set=population.species,
logger=population.log)
# Save the population
if (iteration + 1) % save_interval == 0:
population.save()
saved = True
else:
saved = False
# Make sure that last iterations saves
if not saved: population.save()
# genetic parameters
pop_size = 4
w_mutation_rate = 0.05
b_mutation_rate = 0.0
mutation_scale = 0.3
mutation_decay = 0.995
generations = 500
# network parameters
network_params = {
'network': 'recurrent',
'timesteps': 4,
'input': inputs_train.shape[1],
'hidden': [16, 16, 16],
'output': 2
}
# build initial population
pop = Population(network_params, pop_size, mutation_scale, w_mutation_rate,
b_mutation_rate, mutation_decay)
# run for set number of generations
for g in range(generations):
pop.evolve(g)
gen_best = pop.run(inputs_train,
price_train,
fitness_callback=calculate_profit)
gen_best.save()
pop.test(inputs_test, price_test, fitness_callback=calculate_profit)
def single_evaluation(multi_env, parallel: bool, pop: Population,
unused_cpu: int):
"""
Perform a single evaluation-iteration.
:param multi_env: Environment used to execute the game-simulation in
:param parallel: Boolean indicating if training happens in parallel or not
:param pop: Population used to evaluate on
:param unused_cpu: Number of CPU-cores not used during evaluation
"""
# Prepare the generation's reporters for the generation
pop.reporters.start_generation(gen=pop.generation, logger=pop.log)
# Fetch the dictionary of genomes
genomes = list(iteritems(pop.population))
if parallel:
pbar = tqdm(total=len(genomes), desc="parallel training")
# Initialize the evaluation-pool
pool = mp.Pool(mp.cpu_count() - unused_cpu)
manager = mp.Manager()
return_dict = manager.dict()
def cb(*_):
"""Update progressbar after finishing a single genome's evaluation."""
pbar.update()
for genome in genomes:
pool.apply_async(func=multi_env.eval_genome,
args=(genome, return_dict),
callback=cb)
pool.close() # Close the pool
pool.join() # Postpone continuation until everything is finished
pbar.close() # Close the progressbar
else:
return_dict = dict()
for genome in tqdm(genomes, desc="sequential training"):
multi_env.eval_genome(genome, return_dict)
# Calculate the fitness from the given return_dict
try:
fitness = calc_pop_fitness(
fitness_config=pop.config.evaluation,
game_observations=return_dict,
game_params=multi_env.get_game_params(),
generation=pop.generation,
)
for i, genome in genomes:
genome.fitness = fitness[i]
except Exception: # TODO: Fix! Sometimes KeyError in fitness (path problem)
pop.log(
f"Exception at fitness calculation: \n{traceback.format_exc()}",
print_result=False)
warnings.warn(
f"Exception at fitness calculation: \n{traceback.format_exc()}")
# Set fitness to zero for genomes that have no fitness set yet
for i, genome in genomes:
if not genome.fitness: genome.fitness = 0.0
# Gather and report statistics
best = None
for g in itervalues(pop.population):
if best is None or g.fitness > best.fitness: best = g
pop.reporters.post_evaluate(population=pop.population,
species=pop.species,
best_genome=best,
logger=pop.log)
# Update the population's best_genome
genomes = sorted(pop.population.items(),
key=lambda x: x[1].fitness,
reverse=True)
pop.best_genome_hist[
pop.generation] = genomes[:pop.config.population.genome_elitism]
if pop.best_genome is None or best.fitness > pop.best_genome.fitness:
pop.best_genome = best
# Let population evolve
pop.evolve()
# End generation
pop.reporters.end_generation(population=pop.population,
name=str(pop),
species_set=pop.species,
logger=pop.log)
def evaluate_and_evolve(
self,
pop: Population,
n: int = 1,
parallel=True,
save_interval: int = 1,
):
"""
Evaluate the population on the same set of games.
:param pop: Population object
:param n: Number of generations
:param parallel: Parallel the code (disable parallelization for debugging purposes)
:param save_interval: Indicates how often a population gets saved
"""
multi_env = get_multi_env(pop=pop, game_config=self.game_config)
msg = f"Repetitive evaluating on games: {self.games} for {n} iterations"
pop.log(msg, print_result=False)
# Iterate and evaluate over the games
saved = True
for iteration in range(n):
# Set and randomize the games
multi_env.set_games(self.games, noise=True)
# Prepare the generation's reporters for the generation
pop.reporters.start_generation(gen=pop.generation, logger=pop.log)
# Fetch the dictionary of genomes
genomes = list(iteritems(pop.population))
if parallel:
# Initialize the evaluation-pool
pool = mp.Pool(mp.cpu_count() - self.unused_cpu)
manager = mp.Manager()
return_dict = manager.dict()
for genome in genomes:
pool.apply_async(func=multi_env.eval_genome,
args=(genome, return_dict))
pool.close() # Close the pool
pool.join(
) # Postpone continuation until everything is finished
else:
return_dict = dict()
for genome in tqdm(genomes, desc="sequential training"):
multi_env.eval_genome(genome, return_dict)
# Calculate the fitness from the given return_dict
fitness = calc_pop_fitness(
fitness_cfg=pop.config.evaluation,
game_cfg=self.game_config.game,
game_obs=return_dict,
gen=pop.generation,
)
for i, genome in genomes:
genome.fitness = fitness[i]
# Gather and report statistics
best = None
for g in itervalues(pop.population):
if best is None or g.fitness > best.fitness: best = g
pop.reporters.post_evaluate(population=pop.population,
species=pop.species,
best_genome=best,
logger=pop.log)
# Update the population's best_genome
genomes = sorted(pop.population.items(),
key=lambda x: x[1].fitness,
reverse=True)
pop.best_fitness[pop.generation] = genomes[0][1].fitness
pop.best_genome_hist[pop.generation] = genomes[0]
pop.best_genome = best
# Let population evolve
pop.evolve()
# End generation
pop.reporters.end_generation(population=pop.population,
name=str(pop),
species_set=pop.species,
logger=pop.log)
# Save the population
if (iteration + 1) % save_interval == 0:
pop.save()
saved = True
else:
saved = False
# Make sure that last iterations saves
if not saved: pop.save()
def main(topology_id: int,
batch_size: int = 1000,
train_batch: int = 3,
min_finished: float = MIN_FINISHED,
unused_cpu: int = 2,
save_pop: bool = False,
use_backup: bool = False):
"""Run a population infinitely long and store all its good genomes."""
# Get the CSV used to store the results in
csv_path, csv_name, added = get_csv_path(topology_id, use_backup=use_backup, batch_size=batch_size)
# Create the population
name = csv_name if save_pop else 'dummy'
cfg = get_config()
folder = get_folder(experiment_id=6)
pop = Population(
name=name,
config=cfg,
folder_name=folder,
use_backup=use_backup,
overwrite=True, # Every iteration, create a new population from scratch
)
# Replace the population's initial population with the requested topologies genomes
for g_id in pop.population.keys(): pop.population[g_id] = get_genome(topology_id, g_id=g_id, cfg=cfg)
pop.species.speciate(config=pop.config,
population=pop.population,
generation=pop.generation,
logger=pop.log)
# Set games and environment used for training and evaluation
pop.log(f"\n\n\n===> RUNNING EXPERIMENT 6 <===\n")
games_train, games_eval = get_game_ids(experiment_id=6)
train_env = get_multi_env(config=cfg)
eval_env = get_multi_env(config=cfg)
eval_env.set_games(games_eval, noise=False)
# Keep training and evolving the network until the complete CSV is filled
last_saved = pop.generation
try:
while added < batch_size:
t = time.localtime()
pop.log(f"\n\n===> Selective genome creation at {added / batch_size * 100}%, "
f"storing in csv '{csv_path.split('/')[-1]}' "
f"({t.tm_hour:02d}h-{t.tm_min:02d}m-{t.tm_sec:02d}s) <===")
# Train the population
pop.log("\n===> Training <===")
for _ in tqdm(range(train_batch), desc="Training"):
train_env.set_games(games_train, noise=True)
genomes = list(iteritems(pop.population))
# Initialize the evaluation-pool
pool = mp.Pool(mp.cpu_count() - unused_cpu)
manager = mp.Manager()
return_dict = manager.dict()
for genome in genomes:
pool.apply_async(func=train_env.eval_genome, args=(genome, return_dict))
pool.close() # Close the pool
pool.join() # Postpone continuation until everything is finished
# Calculate the fitness from the given return_dict
fitness = calc_pop_fitness(
fitness_cfg=pop.config.evaluation,
game_cfg=cfg.game,
game_obs=return_dict,
gen=pop.generation,
)
for i, genome in genomes:
genome.fitness = fitness[i]
# Update the population's best_genome
best = None
for g in itervalues(pop.population):
if best is None or g.fitness > best.fitness: best = g
genomes = sorted(pop.population.items(), key=lambda x: x[1].fitness, reverse=True)
pop.best_fitness[pop.generation] = genomes[0][1].fitness
pop.best_genome_hist[pop.generation] = genomes[0]
pop.best_genome = best
pop.log(f"Best training fitness: {best.fitness}")
# Let population evolve
pop.evolve()
# Constraint each of the population's new genomes to the given topology
for g in pop.population.values():
enforce_topology(g, topology_id=topology_id)
# Save the population after training
if pop.generation - last_saved >= 100:
pop.save()
last_saved = pop.generation
# Evaluate the current population as was done in experiment6
pop.log("\n===> EVALUATING <===")
genomes = list(iteritems(pop.population))
pool = mp.Pool(mp.cpu_count() - unused_cpu)
manager = mp.Manager()
return_dict = manager.dict()
for genome in genomes:
pool.apply_async(func=eval_env.eval_genome, args=(genome, return_dict))
pool.close() # Close the pool
pool.join() # Postpone continuation until everything is finished
# Calculate the fitness from the given return_dict
finished = calc_finished_ratio(
fitness_cfg=cfg.evaluation,
game_obs=return_dict,
)
best = None
for i, genome in genomes:
genome.fitness = finished[i]
if best is None or finished[i] > best.fitness: best = genome
# Give evaluation overview of population
pop.log(f"Best evaluation finish ratio: {round(best.fitness, 2)}")
best_str = str(best).replace("\n", "\n\t")
best_str += "\n\t" + str(best.nodes[2]).replace("\n", "\n\t")
pop.log(f"Best genome: \n\t{best_str}")
sids = list(iterkeys(pop.species.species))
sids.sort()
msg = f"\nPopulation '{name}' has {len(pop.species.species):d} species:" \
f"\n\t specie age size finished stag " \
f"\n\t======== ===== ====== ========== ======"
pop.log(msg) if pop.log else print(msg)
for sid in sids:
s = pop.species.species[sid]
a = pop.generation - s.created
n = len(s.members)
sf = [g.fitness for g in s.members.values() if g.fitness]
f = "--" if len(sf) == 0 else f"{max(sf):.2f}"
st = pop.generation - s.last_improved
msg = f"\t{sid:^8} {a:^5} {n:^6} {f:^10} {st:^6}"
pop.log(msg) if pop.log else print(msg)
# Write the result to CSV
with open(csv_path, 'a', newline='') as f:
writer = csv.writer(f)
for _, g in genomes:
# Only write the genomes that exceed the minimum 'finished ratio' threshold!
if g.fitness >= min_finished:
writer.writerow(get_genome_parameters(g, topology_id=topology_id))
added += 1
finally:
# Remove the dummy population if it exists
pop.save()
path = f"population{'_backup' if use_backup else ''}/storage/{pop.folder_name}/dummy/"
if os.path.exists(path):
shutil.rmtree(path)
