def main(): # Run 'breeding' pop = toolbox.population(n=300) hof = tools.HallOfFame(1) orig_stdout = sys.stdout f = open('ga_history.txt', 'w') sys.stdout = f print('stats') stats = tools.Statistics(lambda ind: ind.fitness.values) stats.register("avg", numpy.mean) stats.register("std", numpy.std) stats.register("min", numpy.min) stats.register("max", numpy.max) algorithms.eaSimple(pop, toolbox, 0.5, 0.2, 40, stats, halloffame=hof) expr = gp.genFull(pset, min_=1, max_=3) tree = gp.PrimitiveTree(expr) print('Tree') print(str(tree)) # print 'Eligible moves: ', self.eligible_moves() #print('Pits: ', self.pits) #print('Board: ', self.board.textify_board()) # print(pop, hof, stats) f.close() sys.stdout = orig_stdout # function = gp.compile(hof, pset) # print(function) print("done") # print(pop, hof, stats) return pop, hof, stats
def pruebaIndividuo(): pset = configuraIndividuo() # Realiza una incialización completa con profundida entre 1 y 3 expr = gp.genFull(pset, min_=1, max_=3) # Obtiene el arbol correspondiente tree = gp.PrimitiveTree(expr) # Se visualiza como una lista de operaciones print(tree)
def txt_to_individual(file_path, pset): file = open(file_path, 'r') string = file.read() file.close() string.replace('div', 'pdiv') string.replace('sqrt', 'psqrt') string.replace('log', 'plog') expr = gp.genFull(pset, min_=1, max_=3) tree = gp.PrimitiveTree(expr) individual = tree.from_string(string, pset) return individual
def pruebaIndividuo(): pset = configuraIndividuo() # Realiza una incialización completa con profundida entre 1 y 3 # Performs a full initialisation with depth between 1 and 3 expr = gp.genFull(pset, min_=1, max_=3) # Obtiene el arbol correspondiente # Extracts the corresponding tree tree = gp.PrimitiveTree(expr) # Se visualiza como una lista de operaciones # Displayed as a list of operations print(tree)
def test_pickle_tree_input(self): pset = gp.PrimitiveSetTyped("MAIN", [int], int, "IN") pset.addPrimitive(operator.add, [int, int], int) expr = gp.genFull(pset, min_=1, max_=1) ind = creator.IndTree(expr) ind.fitness.values = (1.0,) ind_s = pickle.dumps(ind, pickle.HIGHEST_PROTOCOL) ind_l = pickle.loads(ind_s) msg = "Unpickled individual %s != pickled individual %s" % (str(ind), str(ind_l)) self.assertEqual(ind, ind_l, msg) msg = "Unpickled fitness %s != pickled fitness %s" % (str(ind.fitness), str(ind_l.fitness)) self.assertEqual(ind.fitness, ind_l.fitness, msg)
def test_pickle_tree_input(self): pset = gp.PrimitiveSetTyped("MAIN", [int], int, "IN") pset.addPrimitive(operator.add, [int, int], int) expr = gp.genFull(pset, min_=1, max_=1) ind = creator.IndTree(expr) ind.fitness.values = (1.0,) ind_s = pickle.dumps(ind, pickle.HIGHEST_PROTOCOL) ind_l = pickle.loads(ind_s) msg = "Unpickled individual %s != pickled individual %s" % (str(ind), str(ind_l)) self.assertEqual(ind, ind_l, msg) msg = "Unpickled fitness %s != pickled fitness %s" % (str(ind.fitness), str(ind_l.fitness)) self.assertEqual(ind.fitness, ind_l.fitness, msg)
from deap import base, creator, gp import operator pset = gp.PrimitiveSet("main", 3) pset.addPrimitive(max, 2) pset.addPrimitive(operator.add, 2) pset.addPrimitive(operator.mul, 2) pset.addTerminal(3) pset.addPrimitive(operator.neg, 1) pset.renameArguments(ARG0="x") pset.renameArguments(ARG1="y") pset.renameArguments(ARG2="z") expr = gp.genFull(pset, min_=1, max_=3) tree = gp.PrimitiveTree(expr) print(tree)
def generate_offspring(toolbox, population, nchildren): offspring = [] toolbox.max_raw_error = max([ind.fam.raw_error for ind in population]) toolbox.debug_pp_str = "" toolbox.offspring_families_set = set() for index, _inds in toolbox.current_families_dict.items(): toolbox.offspring_families_set.add(index) do_default_cx = True if population[0].fam.raw_error <= toolbox.near_solution_threshold: if not toolbox.in_near_solution_area: toolbox.in_near_solution_area = True for index, _inds in toolbox.current_families_dict.items(): if toolbox.families_list[ index].raw_error <= toolbox.max_raw_error_for_family_db: toolbox.near_solution_families_set.add(index) toolbox.parents_keep_fraction[ toolbox.parachute_level] = 1.0 # 3.0 / 4.0 toolbox.pop_size[ toolbox.parachute_level] = toolbox.near_solution_pop_size toolbox.max_individual_size = toolbox.near_solution_max_individual_size if not toolbox.params["use_one_random_seed"]: random.seed(toolbox.params["seed2"]) toolbox.cx_count = dict() toolbox.cx_child_count = dict() if False: toolbox.pp_str_to_family_index_dict = dict() toolbox.family_list = [] toolbox.new_families_list = [] new_dict = dict() for new_index, (_old_index, inds) in enumerate( toolbox.current_families_dict.items()): fam = inds[0].fam toolbox.family_list.append(fam) toolbox.new_families_list.append(fam) fam.family_index = new_index new_dict[new_index] = inds toolbox.current_families_dict = new_dict # toolbox.pcrossover = 0.3 if False: do_default_cx = False n = len(toolbox.current_families_dict) toolbox.f.write(f"Start {n}x{n} search\n") offspring = search_for_solution( toolbox, population, round(nchildren * toolbox.pcrossover)) toolbox.f.write( f" {n}x{n} search found {len(offspring)} improvements\n") expr_mut = lambda pset, type_: gp.genFull(pset=pset, min_=toolbox.mut_min_height, max_=toolbox.mut_max_height, type_=type_) retry_count = 0 prepare_combinations_families_with_cx_count_zero(toolbox, population) while len(offspring) < nchildren: op_choice = random.random() if op_choice < toolbox.pcrossover and do_default_cx: # Apply crossover parent1, parent2 = select_parents(toolbox, population) if toolbox.parachute_level == 0: child, pp_str = cxOnePoint(toolbox, parent1, parent2) else: child, pp_str = crossover_with_local_search( toolbox, parent1, parent2) else: # Apply mutation parent = best_of_n(population, toolbox.best_of_n_mut) if toolbox.parachute_level == 0: child, pp_str = mutUniform(toolbox, parent, expr=expr_mut, pset=toolbox.pset) else: if toolbox.use_family_representatives_for_mutation: family = random.choice(toolbox.families_list) mutation = family.representative raise RuntimeError( f"DEBUG 228 : option use_family_representatives_for_mutation may not be used" ) # can be removed when debugging is done else: mutation = gp.genFull(pset=toolbox.pset, min_=toolbox.mut_min_height, max_=toolbox.mut_max_height) mutation = gp.PrimitiveTree(mutation) mutation.fam = None if toolbox.use_crossover_for_mutations: child, pp_str = crossover_with_local_search( toolbox, parent, mutation) else: child, pp_str = replace_subtree_at_best_location( toolbox, parent, mutation) if child is None: if retry_count < toolbox.child_creation_retries: retry_count += 1 continue else: break retry_count = 0 assert child.fam is not None toolbox.ind_str_set.add(pp_str) toolbox.offspring_families_set.add(child.fam.family_index) offspring.append(child) return offspring
else: print(f'fail') print(result) return result, toolbox.register("evaluate", eval) toolbox.register("select", tools.selAutomaticEpsilonLexicase) toolbox.register("mate", gp.cxOnePoint) toolbox.register("expr_mut", gp.genFull, min_=0, max_=2) toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset) pop = toolbox.population(n=10) hof = tools.HallOfFame(1) # test out mod on x_train p = gp.genFull(pset, min_=1, max_=2) tree = PrimitiveTree(p) print(tree) funct = gp.compile(tree, pset) t = funct print(f't is {t}') print(f'd.data[0] is {d.data[0]}') print(f'mod_x = {d.data[0][funct]}') mod_x = get_mod_x(d.data, funct) pop, log = algorithms.eaSimple(pop, toolbox, cxpb=0.5, mutpb=0.1, ngen=4, halloffame=hof, verbose=True)