def breed_layers_modules(first_model,
second_model,
first_model_state=None,
second_model_state=None,
cut_point=None):
second_model = copy.deepcopy(second_model)
if cut_point is None:
cut_point = random.randint(0, len(first_model) - 1)
for i in range(cut_point):
second_model[i] = first_model[i]
save_weights = global_vars.get(
'inherit_weights_crossover') and global_vars.get(
'inherit_weights_normal')
if check_legal_model(second_model):
if save_weights:
finalized_new_model = finalize_model(second_model)
finalized_new_model_state = finalized_new_model.state_dict()
if None not in [first_model_state, second_model_state]:
for i in range(cut_point):
add_layer_to_state(finalized_new_model_state,
second_model[i], i, first_model_state)
for i in range(cut_point + 1, global_vars.get('num_layers')):
add_layer_to_state(finalized_new_model_state,
second_model[i - cut_point], i,
second_model_state)
else:
finalized_new_model_state = None
return second_model, finalized_new_model_state, cut_point
else:
global_vars.set('failed_breedings',
global_vars.get('failed_breedings') + 1)
return None, None, None
def mutate_models(individual, mutation_rate):
model = individual['model']
if random.random() < mutation_rate:
while True:
rand_layer = random.randint(0, len(model) - 1)
model[rand_layer] = random_layer()
if check_legal_model(model):
break
def mutate_layers_deap(individual):
while True:
rand_layer = random.randint(0, len(individual['model']) - 1)
prev_layer = individual['model'][rand_layer]
individual['model'][rand_layer] = random_layer()
if check_legal_model(individual['model']):
break
else:
individual[rand_layer] = prev_layer
return individual,
def breed_layers(mutation_rate,
first_individual,
second_individual,
first_model_state=None,
second_model_state=None,
cut_point=None,
bb_population=None):
first_model = first_individual['model']
second_model = second_individual['model']
if bb_population is not None:
if random.random() < global_vars.get('puzzle_usage_rate'):
cut_point = choose_cutpoint_by_bb(bb_population, first_model,
second_model)
second_model = copy.deepcopy(second_model)
if cut_point is None:
cut_point = random.randint(0, len(first_model) - 1)
if global_vars.get('cut_point_modulo'):
while (cut_point + 1) % global_vars.get('cut_point_modulo') != 0:
cut_point = random.randint(0, len(first_model) - 1)
for i in range(cut_point):
second_model[i] = first_model[i]
save_weights = global_vars.get(
'inherit_weights_crossover') and global_vars.get(
'inherit_weights_normal')
this_module = sys.modules[__name__]
if type(global_vars.get('mutation_method')) == list:
mutation_method = random.choice(global_vars.get('mutation_method'))
else:
mutation_method = global_vars.get('mutation_method')
getattr(this_module, mutation_method)(second_individual, mutation_rate)
new_model = new_model_from_structure_pytorch(second_model, applyFix=True)
if save_weights:
finalized_new_model = finalize_model(new_model)
finalized_new_model_state = finalized_new_model.state_dict()
if None not in [first_model_state, second_model_state]:
for i in range(cut_point):
add_layer_to_state(
finalized_new_model_state, second_model[i], i,
first_model_state,
first_individual['weight_inheritance_alpha'])
for i in range(cut_point + 1, global_vars.get('num_layers')):
add_layer_to_state(
finalized_new_model_state, second_model[i - cut_point], i,
second_model_state,
second_individual['weight_inheritance_alpha'])
else:
finalized_new_model_state = None
if check_legal_model(new_model):
return new_model, finalized_new_model_state, cut_point
else:
global_vars.set('failed_breedings',
global_vars.get('failed_breedings') + 1)
return None, None, None
def mutate_layer(model, layer_index):
old_layer = model[layer_index]
model[layer_index] = random_layer()
if not check_legal_model(model):
model[layer_index] = old_layer
def eaDual(self,
population,
modules,
toolbox,
cxpb,
mutpb,
ngen,
stats=None,
halloffame=None,
verbose=__debug__):
logbook = tools.Logbook()
logbook.header = ['gen', 'nevals'] + (stats.fields if stats else [])
# Evaluate the individuals with an invalid fitness
invalid_ind = [ind for ind in population if not ind.fitness.valid]
fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
for ind, fit in zip(invalid_ind, fitnesses):
ind.fitness.values = fit
if halloffame is not None:
halloffame.update(population)
record = stats.compile(population) if stats else {}
logbook.record(gen=0, nevals=len(invalid_ind), **record)
if verbose:
print(logbook.stream)
# Begin the generational process
for gen in range(1, ngen + 1):
self.current_generation += 1
# Select the next generation individuals
offspring = toolbox.select(population, len(population))
# Change the toolbox methods for model mating
self.toolbox.register("mate", breed_layers_modules_deap,
self.toolbox)
self.toolbox.register("mutate", mutate_layers_deap_modules)
# Vary the pool of individuals
offspring = varAnd(offspring, toolbox, cxpb, mutpb)
# Check model validity, killing invalid ones
for pop_idx, pop in enumerate(offspring):
if not check_legal_model(pop['model']):
offspring[pop_idx]['model'] = random_model(
global_vars.get('num_layers'))
offspring[pop_idx]['model_state'] = None
offspring[pop_idx]['age'] = 0
del offspring[pop_idx].fitness.values
# Evaluate the individuals with an invalid fitness
invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
valid_ind = [ind for ind in offspring if ind.fitness.valid]
fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
for ind, fit in zip(invalid_ind, fitnesses):
ind.fitness.values = fit
for ind in valid_ind:
ind['age'] += 1
# Update the hall of fame with the generated individuals
if halloffame is not None:
halloffame.update(offspring)
# Replace the current population by the offspring
population[:] = offspring
if global_vars.get('evolve_modules'):
# Evaluate all modules
module_fitnesses = toolbox.map(toolbox.evaluate_module,
modules)
for ind, fit in zip(modules, module_fitnesses):
ind.fitness.values = fit
# Select the next generation modules
module_offspring = toolbox.select(modules, len(modules))
# Change the toolbox methods for module mating
self.toolbox.register("mate", breed_modules_deap)
self.toolbox.register("mutate", mutate_modules_deap)
# Vary the pool of modules
module_offspring = varAnd(module_offspring, toolbox, cxpb,
mutpb)
modules[:] = module_offspring
# Update models with new modules, killing if necessary
for pop_idx, pop in enumerate(population):
for idx in range(len(pop['model'])):
pop['model'][idx] = global_vars.get('modules')[
pop['model'][idx].module_idx]
if not check_legal_model(pop['model']):
population[pop_idx]['model'] = random_model(
global_vars.get('num_layers'))
population[pop_idx]['model_state'] = None
population[pop_idx]['age'] = 0
del population[pop_idx].fitness.values
fitness = toolbox.evaluate(population[pop_idx])
population[pop_idx].fitness.values = fitness
# Append the current generation statistics to the logbook
record = stats.compile(population) if stats else {}
logbook.record(gen=gen, nevals=len(invalid_ind), **record)
if verbose:
print(logbook.stream)
pop_stats = self.calculate_stats(population)
for stat, val in pop_stats.items():
global_vars.get('sacred_ex').log_scalar(
f'avg_{stat}', val, self.current_generation)
self.write_to_csv({k: str(v)
for k, v in pop_stats.items()},
self.current_generation)
self.print_to_evolution_file(population, self.current_generation)
return population, logbook