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