def get_toolbox(pset, max_height): """Gets toolbox. Args: pset: deap.gp.PrimitiveSet. max_height: Integer, the max value of the height of tree. Returns: deap.base.Toolbox. """ toolbox = base.Toolbox() toolbox.register('expr', gp.genHalfAndHalf, pset=pset, min_=1, max_=2) toolbox.register('individual', tools.initIterate, creator.Individual, toolbox.expr) toolbox.register('population', tools.initRepeat, list, toolbox.individual) toolbox.register('compile', gp.compile, pset=pset) toolbox.register('select', tools.selTournament, tournsize=3) 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) toolbox.decorate( 'mate', gp.staticLimit(key=operator.attrgetter('height'), max_value=max_height)) toolbox.decorate( 'mutate', gp.staticLimit(key=operator.attrgetter('height'), max_value=max_height)) return toolbox
def adapt_and_train(): if len(agents) > 1: toolbox.register("select", selSelfPlay) else: toolbox.register("select", tools.selTournament, tournsize=5) toolbox.decorate("select", invalidation_decorator) toolbox.register("evaluate", evaluate_agent, cons=len(agents)) for ind in pop: del ind.fitness.values for i in range(repetitions): print(i) toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset) toolbox.decorate("mutate", gp.staticLimit(operator.attrgetter("height"), 25)) algorithms.eaSimple(pop, toolbox, *uniform_ratios, gens, stats, verbose=True) toolbox.register("mutate", gp.mutInsert, pset=pset) toolbox.decorate("mutate", gp.staticLimit(operator.attrgetter("height"), 25)) algorithms.eaSimple(pop, toolbox, *insert_ratios, gens, stats, verbose=True) toolbox.register("mutate", gp.mutNodeReplacement, pset=pset) toolbox.decorate("mutate", gp.staticLimit(operator.attrgetter("height"), 25)) algorithms.eaSimple(pop, toolbox, *replacement_ratios, gens, stats, verbose=True) toolbox.register("mutate", gp.mutEphemeral, mode='one') toolbox.decorate("mutate", gp.staticLimit(operator.attrgetter("height"), 25)) algorithms.eaSimple(pop, toolbox, *optimize_ratios, gens, stats, verbose=True) toolbox.register("mutate", gp.mutShrink) toolbox.decorate("mutate", gp.staticLimit(operator.attrgetter("height"), 25)) algorithms.eaSimple(pop, toolbox, *shrink_ratios, gens, stats, verbose=True)
def init_toolbox(self): toolbox = self.toolbox pset = self.pset toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=5) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("compile", gp.compile, pset=pset) toolbox.register("evaluate", self.classify) toolbox.register("select", tools.selDoubleTournament, fitness_size=self.tournament_size, parsimony_size=self.parsimony_size, fitness_first=True) toolbox.register("mate", gp.cxOnePoint) toolbox.register("expr_mut", gp.genHalfAndHalf, min_=0, max_=2) toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset) toolbox.decorate( "mate", gp.staticLimit(operator.attrgetter('height'), self.max_height)) toolbox.decorate( "mutate", gp.staticLimit(operator.attrgetter('height'), self.max_height)) return self
def initializeTreeProperties(self): # Define new functions def protectedDiv(left, right): try: return left / right except ZeroDivisionError: return 1 numAttributes = len(self.dataEntry[0]) - 1 pset = gp.PrimitiveSet("MAIN", numAttributes) pset.addPrimitive(operator.add, 2) pset.addPrimitive(operator.sub, 2) pset.addPrimitive(operator.mul, 2) pset.addPrimitive(protectedDiv, 2) pset.addPrimitive(operator.neg, 1) pset.addPrimitive(math.cos, 1) pset.addPrimitive(math.sin, 1) [ pset.addEphemeralConstant( str(random.random()) + "eph" + str(i + 6), lambda: i) for i in range(-6, 6) ] creator.create("FitnessMax", base.Fitness, weights=(1.0, )) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMax) self.toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=3) self.toolbox.register("individual", tools.initIterate, creator.Individual, self.toolbox.expr) self.toolbox.register("population", tools.initRepeat, list, self.toolbox.individual) self.toolbox.register("compile", gp.compile, pset=pset) if self.isDiscrete: self.toolbox.register("evaluate", self.evalSymbRegDiscrete, self.dataEntry) else: self.toolbox.register("evaluate", self.evalSymbReg, self.dataEntry) self.toolbox.register("select", tools.selTournament, tournsize=20) self.toolbox.register("mate", gp.cxOnePoint) self.toolbox.register("expr_mut", gp.genFull, min_=0, max_=2) self.toolbox.register("mutate", gp.mutUniform, expr=self.toolbox.expr_mut, pset=pset) self.toolbox.decorate( "mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) self.toolbox.decorate( "mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17))
def main(n_corr, p): energy_coolng(n_corr, p) pop_size=500 #toolbox.register("select",selElitistAndTournament, k_elitist=int(0.1*pop_size), k_tournament=pop_size - int(0.1*pop_size), tournsize=3) toolbox.register("select",tools.selTournament, tournsize=3) toolbox.register("mate", gp.cxOnePoint) toolbox.register("expr_mut", gp.genFull, min_=0, max_=3) toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset) toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) pop = toolbox.population(n=pop_size) hof = tools.HallOfFame(3) stats_fit = tools.Statistics(lambda ind: ind.fitness.values) stats_size = tools.Statistics(len) mstats = tools.MultiStatistics(fitness=stats_fit, size=stats_size) mstats.register("avg", np.mean) mstats.register("std", np.std) mstats.register("min", np.min) mstats.register("max", np.max) cxpb = 0.7 mutpb = 0.3 ngen = 100 params = ['best_of_each_specie', 2, 'yes'] neat_cx = True neat_alg = True neat_pelit = 0.5 neat_h = 0.15 problem = "EnergyCooling" pop, log = eaneatGP.neat_GP(pop, toolbox, cxpb, mutpb, ngen, neat_alg, neat_cx, neat_h, neat_pelit, n_corr, p, params, problem, stats=mstats, halloffame=hof, verbose=True) #pop, log = algorithms.eaSimple(pop, toolbox, cxpb, mutpb, ngen, problem, p, n_corr,stats=mstats, halloffame=hof, verbose=True) return pop, log, hof
def create_toolbox(hyperparameters, pset): # Recuperation des informations sur les hyperparametres n_tournament = hyperparameters['n_tournament'] init_depth = hyperparameters['init_depth'] # Caracteristiques de l'individu et de la fitness creator.create("FitnessMin", base.Fitness, weights=(-1.0,)) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMin) # Creation de la toolbox toolbox = base.Toolbox() toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=init_depth) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("select", tools.selTournament, tournsize=n_tournament) 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) # A mettre a jour plus tard en fonction du pli toolbox.register("evaluate", eval_symbreg, pset=pset, trX=None, trY=None, teX=None, teY=None) # Controle du bloat toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) return toolbox
def create_toolbox(): pset = gp.PrimitiveSet("MAIN", 1) pset.addPrimitive(operator.add, 2) pset.addPrimitive(operator.sub, 2) pset.addPrimitive(operator.mul, 2) pset.addPrimitive(division_operator, 2) pset.addPrimitive(operator.neg, 1) pset.addPrimitive(math.cos, 1) pset.addPrimitive(math.sin, 1) pset.addEphemeralConstant("rand101", lambda: random.randint(-1, 1)) pset.renameArguments(ARG0='x') creator.create("FitnessMin", base.Fitness, weights=(-1.0, )) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMin) toolbox = base.Toolbox() toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=2) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("compile", gp.compile, pset=pset) toolbox.register("evaluate", eval_func, points=[x / 10. for x in range(-10, 10)]) toolbox.register("select", tools.selTournament, tournsize=3) 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) toolbox.decorate( "mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate( "mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) return toolbox
def standard_toolbox(primitives_set, max_height=8): toolbox = base.Toolbox() toolbox.register("expr", gp.genHalfAndHalf, pset=primitives_set, min_=2, max_=4) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("compile", gp.compile, pset=primitives_set) toolbox.register("select", tools.selTournament, tournsize=7) toolbox.register("mate", gp.cxOnePoint) toolbox.register("expr_mut", gp.genGrow, min_=0, max_=2) toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=primitives_set) toolbox.decorate( "mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=max_height)) toolbox.decorate( "mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=max_height)) return toolbox
def get_po_toolbox(predictors, response): creator.create("FitnessAge", base.Fitness, weights=(WEIGHT_FITNESS, WEIGHT_AGE_DENSITY)) creator.create("Individual", SemanticPrimitiveTree, fitness=creator.FitnessAge, age=int) toolbox = base.Toolbox() pset = symbreg.get_numpy_pset(len(predictors[0])) toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=MIN_DEPTH_INIT, max_=MAX_DEPTH_INIT) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", initialization.syntactically_distinct, individual=toolbox.individual, retries=100) toolbox.register("select", tools.selRandom) expression_dict = cachetools.LRUCache(maxsize=10000) toolbox.register("error_func", ERROR_FUNCTION, response=response) toolbox.register("evaluate_error", semantics.calc_eval_semantics, context=pset.context, predictors=predictors, eval_semantics=toolbox.error_func, expression_dict=expression_dict) toolbox.register("koza_node_selector", operators.internally_biased_node_selector, bias=INTERNAL_NODE_SELECTION_BIAS) toolbox.register("mate", operators.one_point_xover_biased, node_selector=toolbox.koza_node_selector) toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=MAX_HEIGHT)) toolbox.decorate("mate", gp.staticLimit(key=len, max_value=MAX_SIZE)) mstats = reports.configure_inf_protected_stats() multi_archive = get_archive(response) pop = toolbox.population(n=POP_SIZE) toolbox.register("run", afpo.pareto_optimization, population=pop, toolbox=toolbox, xover_prob=XOVER_PROB, mut_prob=MUT_PROB, ngen=NGEN, tournament_size=TOURN_SIZE, num_randoms=1, stats=mstats, archive=multi_archive, calc_pareto_front=False) toolbox.register("save", reports.save_log_to_csv) toolbox.decorate("save", reports.save_archive(multi_archive)) return toolbox
def configure_toolbox(pset, tournsize): """ Creates and configures a DEAP toolbox object """ # minimization problem, so weights are -1 creator.create("FitnessMin", base.Fitness, weights=(-1.0, )) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMin) toolbox = base.Toolbox() toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=0, max_=10) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("compile", gp.compile, pset=pset) # population function toolbox.register("population", tools.initRepeat, list, toolbox.individual) # evaluation function, pass toolbox and points args toolbox.register("evaluate", eval_symb_reg, toolbox=toolbox, points=get_training_dataset()) # tournament size toolbox.register("select", tools.selTournament, tournsize=tournsize) # mating strategy 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) # limit mating and mutation to a tree w/ max height of 50 toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=50)) toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=50)) return toolbox
def Init_GP_MOP(subj): nfeat = number_features pset = GP_Definitions(nfeat) maxDepthLimit = 10 creator.create("FitnessMax", base.Fitness, weights=(1.0,1.0)) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMax) toolbox = base.Toolbox() toolbox.register("expr", gp.genHalfAndHalf, pset=pset, type_=pset.ret, min_=1, max_=2) # IT MIGHT BE A BUG WITH THIS #toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=2) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("compile", gp.compile, pset=pset) #toolbox.register("evaluate", eval_Biv_Transfer_Freq) toolbox.register("evaluate",bi_objective_functions[type_function]) #toolbox.register("select", tools.selTournament, tournsize=3) toolbox.register("select", tools.selNSGA2) 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) toolbox.decorate('mutate',gp.staticLimit(key=operator.attrgetter('height'),max_value=maxDepthLimit)) toolbox.decorate('mate',gp.staticLimit(key=operator.attrgetter('height'),max_value=maxDepthLimit)) return toolbox
def setup_gp(language, eval_function, **kwargs): toolbox = base.Toolbox() # Magic code to make it parallel? # Must be run like this though: # ipython -m scoop eCov-GP.py #from scoop import futures #toolbox.register("map", futures.map) # CHANGE ME FOR CHANGING OPTIMIZATION CRITERIA # SPECIFICALLY, weights=(x,y,z,...) # if you want single objective, it must be a tuple, namely, weights=(1,) #creator.create("FitnessMin", base.Fitness, weights=(1,-1,-1,-1)) #### I want to simplify this to -1, -1 (just MI and TI) creator.create("FitnessMin", base.Fitness, weights=(-1, -1)) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMin) toolbox.register("expr", gp.genHalfAndHalf, pset=language, min_=1, max_=3) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("compile", gp.compile, pset=language) # Operators #toolbox.register("evaluate", evaluate.evaluate_individual, m=model, traveler_set=travelers, total_iterations=ITERATIONS, measure_every=MEASURE_EVERY, mitigations_per_measure=MITIGATIONS_PER_MEASURE, rollover=ROLLOVER) toolbox.register("evaluate", eval_function, **kwargs) toolbox.register( "elitism", tools.selBest, k=1) ##### can we add an index to access a specific objective? toolbox.register("select", tools.selTournament, tournsize=2) 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=language) ## Bloat rules toolbox.decorate( "mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=4)) toolbox.decorate( "mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=4)) toolbox.decorate("mate", gp.staticLimit(key=len, max_value=32)) toolbox.decorate("mutate", gp.staticLimit(key=len, max_value=32)) # Statistics Bookkeeeping stats_fit = tools.Statistics(lambda ind: ind.fitness.values) stats_size = tools.Statistics(len) mstats = tools.MultiStatistics(fitness=stats_fit, size=stats_size) mstats.register("avg", np.mean, axis=0) mstats.register("std", np.std, axis=0) mstats.register("min", np.min, axis=0) mstats.register("max", np.max, axis=0) logbook = tools.Logbook() return toolbox, mstats, logbook
def main(n_corr, p, problem): name_database="housing.txt" direccion="./data_corridas/%s/train_%d_%d.txt" test_train(n_corr,p, problem, name_database) toolbox.register("select", tools.selTournament, tournsize=7) toolbox.register("mate", neat_gp.cxSubtree) #toolbox.register("expr_mut", gp.genFull, min_=0, max_=3) toolbox.register("expr_mut", gp.genHalfAndHalf, min_=0, max_=7) toolbox.register("mutate", neat_gp.mutUniform, expr=toolbox.expr_mut, pset=pset) toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) stats_fit = tools.Statistics(lambda ind: ind.fitness.values) stats_size = tools.Statistics(len) mstats = tools.MultiStatistics(fitness=stats_fit, size=stats_size) mstats.register("avg", np.mean) mstats.register("std", np.std) mstats.register("min", np.min) mstats.register("max", np.max) pop_size = 100 # population size ngen = 100 # number of generations cxpb = 0.9 # crossover probability mutpb = 0.1 # mutation probability testing = True # True: if you want testing data --- False: if you don't version = 1 # version parameter (to be implemented) pop = toolbox.population(n=pop_size) # neat-GP params params = ['best_of_each_specie', 2, 'yes'] neat_cx = False # True: For neat-crossover -- False: Take the 'mate' toolbox crossover neat_alg = True # True: For neat-algorithm -- False: Standard algorithm neat_pelit = 0.5 # Percentage of elitism for neat neat_h = 0.15 # neat-GP threshold for speciation # LS params funcEval.LS_flag = True # True: If you want LS method LS_select = 8 # Heuristic to apply LS method funcEval.cont_evalp = 0 # Counter to the function evaluations # Saving matrix SaveMatrix = True GenMatrix = True num_salto = 1 cont_evalf = 100000 pop, log = neatGPLS.neat_GP_LS(pop, toolbox, cxpb, mutpb, ngen, neat_alg, neat_cx, neat_h, neat_pelit, funcEval.LS_flag, LS_select, cont_evalf, num_salto, SaveMatrix, GenMatrix, pset,n_corr, p, params, direccion,problem,testing, version, stats=mstats, halloffame=None, verbose=True) return pop, log
def _solve_domain(self, domain_factory: Callable[[], D]) -> None: self.domain = domain_factory() tournament_ratio = self.params_gphh.tournament_ratio pop_size = self.params_gphh.pop_size n_gen = self.params_gphh.n_gen min_tree_depth = self.params_gphh.min_tree_depth max_tree_depth = self.params_gphh.max_tree_depth crossover_rate = self.params_gphh.crossover_rate mutation_rate = self.params_gphh.mutation_rate creator.create("FitnessMin", Fitness, weights=(self.weight,)) creator.create("Individual", PrimitiveTree, fitness=creator.FitnessMin) self.toolbox = Toolbox() self.toolbox.register("expr", genHalfAndHalf, pset=self.pset, min_=min_tree_depth, max_=max_tree_depth) self.toolbox.register("individual", tools.initIterate, creator.Individual, self.toolbox.expr) self.toolbox.register("population", tools.initRepeat, list, self.toolbox.individual) self.toolbox.register("compile", gp.compile, pset=self.pset) if self.evaluation_method == EvaluationGPHH.SGS: self.toolbox.register("evaluate", self.evaluate_heuristic, domains=self.training_domains) # if self.evaluation_method == EvaluationGPHH.SGS_DEVIATION: # self.toolbox.register("evaluate", self.evaluate_heuristic_sgs_deviation, domains=self.training_domains) elif self.evaluation_method == EvaluationGPHH.PERMUTATION_DISTANCE: self.toolbox.register("evaluate", self.evaluate_heuristic_permutation, domains=self.training_domains) # self.toolbox.register("evaluate", self.evaluate_heuristic, domains=[self.training_domains[1]]) self.toolbox.register("select", tools.selTournament, tournsize=int(tournament_ratio * pop_size)) self.toolbox.register("mate", gp.cxOnePoint) self.toolbox.register("expr_mut", gp.genFull, min_=0, max_=max_tree_depth) self.toolbox.register("mutate", gp.mutUniform, expr=self.toolbox.expr_mut, pset=self.pset) self.toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) self.toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) stats_fit = tools.Statistics(lambda ind: ind.fitness.values) stats_size = tools.Statistics(len) mstats = tools.MultiStatistics(fitness=stats_fit, size=stats_size) mstats.register("avg", np.mean) mstats.register("std", np.std) mstats.register("min", np.min) mstats.register("max", np.max) pop = self.toolbox.population(n=pop_size) hof = tools.HallOfFame(1) self.hof = hof pop, log = algorithms.eaSimple(pop, self.toolbox, crossover_rate, mutation_rate, n_gen, stats=mstats, halloffame=hof, verbose=True) self.best_heuristic = hof[0] print('best_heuristic: ', self.best_heuristic) self.func_heuristic = self.toolbox.compile(expr=self.best_heuristic) self.policy = GPHHPolicy(self.domain, self.domain_model, self.func_heuristic, features=self.list_feature, params_gphh=self.params_gphh, recompute_cpm=True)
def init(): global snake global pset global stats global halloffame snake = SnakePlayer() pset = gp.PrimitiveSet("main", 0) pset.addPrimitive(snake.if_food_up, 2) pset.addPrimitive(snake.if_food_right, 2) pset.addPrimitive(snake.if_food_down, 2) pset.addPrimitive(snake.if_food_left, 2) pset.addPrimitive(snake.if_danger_up, 2) pset.addPrimitive(snake.if_danger_right, 2) pset.addPrimitive(snake.if_danger_down, 2) pset.addPrimitive(snake.if_danger_left, 2) pset.addPrimitive(snake.if_moving_down, 2) pset.addPrimitive(snake.if_moving_up, 2) pset.addPrimitive(snake.if_moving_right, 2) pset.addPrimitive(snake.if_moving_left, 2) pset.addPrimitive(snake.if_trapped, 2) pset.addTerminal(snake.change_direction_up) pset.addTerminal(snake.change_direction_right) pset.addTerminal(snake.change_direction_down) pset.addTerminal(snake.change_direction_left) creator.create("FitnessMax", base.Fitness, weights=(1.0, 1.0)) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMax) pool = multiprocessing.Pool() toolbox.register("map", pool.map) # Attribute generator toolbox.register("expr_init", gp.genGrow, pset=pset, min_=1, max_=3) # Structure initializers toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr_init) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("compile", gp.compile, pset=pset) toolbox.register("evaluate", evaluate) toolbox.register("select", tools.selDoubleTournament, fitness_size=3, parsimony_size=1.05, fitness_first=True) toolbox.register("mate", gp.cxOnePointLeafBiased, termpb=0.1) toolbox.register("expr_mut", gp.genFull, min_=1, max_=3) toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset) toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=8)) toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=8)) halloffame = tools.HallOfFame(1) mstats.register("avg", numpy.mean) mstats.register("std", numpy.std) mstats.register("min", numpy.min) mstats.register("max", numpy.max)
def get_toolbox(target_func, weights): # collect the atomic building blocks of the individuals pset = gp.PrimitiveSet("MAIN", 1) pset.addPrimitive(operator.add, 2) pset.addPrimitive(operator.sub, 2) pset.addPrimitive(operator.mul, 2) pset.addPrimitive(protectedDiv, 2) pset.addPrimitive(operator.neg, 1) pset.addPrimitive(protectedPow, 2) pset.addPrimitive(math.cos, 1) pset.addPrimitive(sinX, 1) pset.addEphemeralConstant("rand101", lambda: random.randint(-1, 1)) pset.addEphemeralConstant("rand10010", lambda: random.randint(-10, 10)) pset.addTerminal(math.pi) # define the general form of an individual creator.create("FitnessMulti", base.Fitness, weights=weights) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMulti, target_func=target_func) toolbox = base.Toolbox() toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=3) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("compile", gp.compile, pset=pset) eval_range = [x / 20. * math.pi for x in range(-20, 20)] + [x for x in range(-20, 20)] toolbox.register("evaluate", get_fitness, target_func=target_func, toolbox=toolbox, points=eval_range) # add filters for unwanted behaviour for filter_ in filters: toolbox.decorate('evaluate', tools.DeltaPenalty(filter_, [1000., 0.])) toolbox.register("select", tools.selSPEA2) 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) toolbox.decorate( "mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("mate", gp.staticLimit(key=len, max_value=20)) toolbox.decorate( "mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("mutate", gp.staticLimit(key=len, max_value=20)) return toolbox
def set_up_gp(self): """ Set up deap genetic programming """ # get set of primitives self.set_primitive_set() # Extract values min_expr_depth = self.kwargs.get("min_expr_depth", 1) max_expr_depth = self.kwargs.get("max_expr_depth", 2) creator.create("FitnessMin", base.Fitness, weights=tuple(-1 for _ in xrange(self.order))) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMin, pset=self.pset) self.toolbox = base.Toolbox() self.toolbox.register("expr", gp.genFull, pset=self.pset, min_=min_expr_depth, max_=max_expr_depth) self.toolbox.register("individual", tools.initIterate, creator.Individual, self.toolbox.expr) self.toolbox.register("population", tools.initRepeat, list, self.toolbox.individual) self.toolbox.register("compile", gp.compile, pset=self.pset) # select the fitness function self.toolbox.register("evaluate", self.eval_fitness) self.toolbox.register("select", tools.selBest) self.toolbox.register("mate", gp.cxOnePoint) self.toolbox.register("expr_mut", gp.genFull, min_=min_expr_depth, max_=max_expr_depth) self.toolbox.register("mutate", gp.mutUniform, expr=self.toolbox.expr_mut, pset=self.pset) # Set limits of expressions self.toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) self.toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) # Select "norm" of expression, needed for the fitness function if self.series_to_sum.free_symbols == {self.var}: # since there are no, free symbols, just numbers, use float norm self.norm = self.evalf_norm else: # otherwise use symbolic norm self.norm = self.symbolic_norm # Set statistics self.stats = tools.Statistics(lambda ind: numpy.count_nonzero(ind.fitness.values)) self.stats.register("min number of unmatched terms", numpy.min) self.stats.register("max number of unmatched terms", numpy.max) self.stats.register("std", numpy.std) self.stats.register("avg", numpy.mean) # Set hall of fame self.hof = tools.HallOfFame(10) # Initialize population self.MU = self.kwargs.get("MU", 100) self.pop = self.toolbox.population(n=self.MU) return self
def __init__(self, X, y, constants=[1,2], use_parsimony_pressure=False, parsimony_pressure_w1=0.1, parsimony_pressure_w2=0.9, tourn_size=3 , var_names=[], min_height=1, max_height=10, mut_min_height=0, mut_max_height=2): self.X = X self.y = y self.constants = constants self.parsimony_pressure_w1 = parsimony_pressure_w1 self.parsimony_pressure_w2 = parsimony_pressure_w2 n_args=len(X[0])+len(constants) pset = gp.PrimitiveSet("MAIN", n_args) self.pset = pset self.creator = creator toolbox = base.Toolbox() self.toolbox = toolbox ########## declaring types ############ pset.addPrimitive(operator.add, 2) pset.addPrimitive(operator.sub, 2) pset.addPrimitive(operator.mul, 2) pset.addPrimitive(protectedDiv, 2) pset.addPrimitive(operator.neg, 1) # pset.addPrimitive(math.cos, 1) # pset.addPrimitive(math.sin, 1) # pset.addEphemeralConstant("rand101", lambda: random.randint(-1,1), float) # pset.addTerminal(1) for i in range(len(var_names)): key = 'ARG'+str(i) val = var_names[i] pset.renameArguments(**{key:val}) creator.create("FitnessMin", base.Fitness, weights=(-1.0,)) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMin) ######## initializig vriables ########## toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=min_height, max_=max_height) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("compile", gp.compile, pset=pset) toolbox.register("evaluate", self.simpleFitness, constants=constants) toolbox.register("select", tools.selDoubleTournament, fitness_size =5 , parsimony_size=1.4, fitness_first=False) # toolbox.register("select", sizeOfMovementSelection, tournsize=3) if use_parsimony_pressure: toolbox.register("evaluate", self.parsimonyPressureFitness) toolbox.register("select", tools.selTournament, tournsize=tourn_size) toolbox.register("mate", gp.cxOnePoint) toolbox.register("expr_mut", gp.genFull, min_=mut_min_height, max_=mut_max_height) toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset) toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=max_height)) toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=max_height))
def set_gpoperator(toolbox, pset): toolbox.register("select", tools.selTournament, tournsize=6) #Tamanho do torneio toolbox.register("mate", gp.cxOnePoint) toolbox.register("expr_mut", gp.genHalfAndHalf, min_=0, max_=4) toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset) toolbox.decorate("mate", gp.staticLimit(operator.attrgetter('height'), 12)) # Profundidade da arvore toolbox.decorate("mutate", gp.staticLimit(operator.attrgetter('height'), 12)) # Profundidade da arvore
def main(n_corr, num_p): problem = "BreastCancer" name_database = "breast-cancer-wisconsin" pop_size = 100 energy_coolng(n_corr, num_p, problem, name_database) toolbox.register("select", tools.selTournament, tournsize=3) toolbox.register("mate", neat_gp.cxSubtree) toolbox.register("expr_mut", gp.genFull, min_=0, max_=3) toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset) toolbox.decorate( "mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate( "mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) pop = toolbox.population(n=pop_size) hof = tools.HallOfFame(3) stats_fit = tools.Statistics(lambda ind: ind.fitness.values) stats_size = tools.Statistics(len) mstats = tools.MultiStatistics(fitness=stats_fit, size=stats_size) mstats.register("avg", np.mean) mstats.register("std", np.std) mstats.register("min", np.min) mstats.register("max", np.max) cxpb = 0.7 mutpb = 0.3 ngen = 100 params = ['best_of_each_specie', 2, 'yes'] neat_cx = True neat_alg = True neat_pelit = 0.5 neat_h = 0.15 neat_beta = 0.5 pop, log = eaneatGP.neat_GP(pop, toolbox, cxpb, mutpb, ngen, neat_alg, neat_cx, neat_h, neat_pelit, n_corr, num_p, params, problem, neat_beta, stats=mstats, halloffame=hof, verbose=True) return pop, log, hof
def run(cxpb,mutpb,n,tour,termpb,popu,ngen): global run_i pset = gp.PrimitiveSetTyped("main", [array], float) pset.addPrimitive(SMA, [array, int, int], float) pset.addPrimitive(operator.add, [float, float], float) pset.addPrimitive(part, [array,int], float) pset.addPrimitive(shift, [array,int], float) pset.addEphemeralConstant("randI{i}".format(i=run_i), lambda: random.randint(0,n-1),int) pset.addEphemeralConstant("randF{i}".format(i=run_i), lambda: random.uniform(-1,1),float) pset.addPrimitive(operator.sub, [float, float], float) pset.addPrimitive(operator.mul, [float, float], float) pset.addPrimitive(protectedDiv, [float, float], float) pset.addPrimitive(IF2, [float,float,float, float], float) run_i+=1 creator.create("FitnessMax", base.Fitness, weights=(1.0,)) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMax,pset=pset) toolbox.register("expr", genGrow_edit, pset=pset, min_=1, max_=15) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("compile", gp.compile, pset=pset) toolbox.register("evaluate", fitness_predictor, arg=errors, n=n) toolbox.register("select", tools.selTournament, tournsize=tour) toolbox.register("mate", gp.cxOnePointLeafBiased,termpb=termpb) toolbox.register("expr_mut", genGrow_edit, min_=0, max_=5) toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset) toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) stats_fit = tools.Statistics(lambda ind: ind.fitness.values) stats_size = tools.Statistics(len) mstats = tools.MultiStatistics(fitness=stats_fit, size=stats_size) mstats.register("avg", numpy.mean) mstats.register("std", numpy.std) mstats.register("min", numpy.min) mstats.register("max", numpy.max) if parallel==1: from scoop import futures toolbox.register("map", futures.map) #PARALLELIZATION elif parallel==2: import multiprocessing pool = multiprocessing.Pool(6) toolbox.register("map", pool.map) #PARALLELIZATION pop = toolbox.population(n=popu) hof = tools.HallOfFame(1) pop, log = algorithms.eaSimple(pop, toolbox, cxpb, mutpb, ngen, stats=mstats, halloffame=hof, verbose=True) # return hof[0].fitness.values[0] return log
def build_toolbox(self): ''' Define functions to use in the GP toolbox ''' toolbox = base.Toolbox() creator.create("FitnessMax", base.Fitness, weights=(1.0, )) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMax, pset=self.pset) toolbox.register("initializer", gp.genHalfAndHalf, pset=self.pset, min_=5, max_=20) toolbox.register("tree", tools.initIterate, creator.Individual, toolbox.initializer) toolbox.register("population", tools.initRepeat, list, toolbox.tree) # Fitness function similar to Wu & Banzhaf, 2011. # Fi = TPRi x (1 - FPRi)^2 toolbox.register("evaluate", self.fitness) # One-CrossoverPoint toolbox.register("mate", gp.cxOnePoint) # Uniform Mutation toolbox.register("mutate", gp.mutNodeReplacement, pset=self.pset) # DoubleTournament Selection uses the size of the individuals # in order to discriminate good solutions. toolbox.register( "select", # selection function tools.selDoubleTournament, fitness_size= 7, # of individuals participating in each fitness tournament parsimony_size= 1.8, #The parsimony size of 1.8 means that there is a 90\% chance of selecting the smaller tree on the second round of tournament selection fitness_first=True) # Control code-bloat: max depth of a tree toolbox.decorate( "mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=20)) toolbox.decorate( "mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=20)) return toolbox
def configuracionAlgoritmo(toolbox,pset): toolbox.register("select", tools.selNSGA2) 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) toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.register("evaluate", Evaluacion.fitness, toolbox)
def toolboxDirectSetup(benignEquation, malwareEquation, mutationSubTreeHeightMin, mutationSubTreeHeightMax, maxTreeHeight, testPointsStart, testPointsStop, testPointsStep, insertionStart, insertionStop): toolbox = toolboxSetup(benignEquation, malwareEquation, testPointsStart, testPointsStop, testPointsStep, insertionStart, insertionStop) # Define creation of indiviuals for the population toolbox.register("individual", tools.initIterate, creator.DirectIndividual, lambda: toolbox.benignEquationPrimitiveTree()) toolbox.register("population", tools.initRepeat, list, toolbox.individual) # Define mutation properties toolbox.register("mate", gp.cxOnePoint) toolbox.register("expr_mut", gp.genFull, min_=mutationSubTreeHeightMin, max_=mutationSubTreeHeightMax) toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset) toolbox.decorate( "mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=maxTreeHeight)) toolbox.decorate( "mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=maxTreeHeight)) def compiledIndividualEvalSymbReg(individual, targetFunction, points): # Transform the tree expression in a callable function compiledIndivdual = toolbox.compile(expr=individual) return toolbox.generalEvalSymbReg(compiledIndivdual, targetFunction, points) toolbox.register("evalSymbReg", compiledIndividualEvalSymbReg, points=toolbox.testPoints()) def pieceWiseFunction(x, benignEquation, malwareEquation, insertionStart, insertionStop): if insertionStart <= x <= insertionStop: return toolbox.malwareEquation(x) else: return toolbox.benignEquation(x) toolbox.register("pieceWiseFunction", pieceWiseFunction, benignEquation=toolbox.benignEquation, malwareEquation=toolbox.malwareEquation, insertionStart=insertionStart, insertionStop=insertionStop) return toolbox
def init_toolbox(pset): toolbox = base.Toolbox() toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=2) 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) toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=_MAX_HEIGHT)) toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=_MAX_HEIGHT)) return toolbox
def DefineEvolutionToolbox(primitive_set, training_instances, feature_size, window_size): """TODO: Parameterize this function so it receives the evolution parameters from file/struct""" import math #>Evolution parameters: #TODO: create enum for categorical parameters # kInitialization = 'genHalfAndHalf' # kSelection = 'selTournament' kTreeMinDepth = 2 kTreeMaxDepth = 7 kTournamentSize = 7 max_len = (2**kTreeMaxDepth - 1) * math.log(feature_size, 2) + 1 min_len = (2**kTreeMinDepth - 1) * math.log(feature_size, 2) + 1 creator.create("Fitness", base.Fitness, weights=(-1.0, )) creator.create("Individual", gp.PrimitiveTree, fitness=creator.Fitness) tbox = base.Toolbox() tbox.register("generate_expr", gp.genHalfAndHalf, pset=primitive_set, min_=kTreeMinDepth, max_=kTreeMaxDepth) tbox.register("generate_ind_tree", tools.initIterate, creator.Individual, tbox.generate_expr) tbox.register("generate_population", tools.initRepeat, list, tbox.generate_ind_tree) tbox.register("compile", gp.compile, pset=primitive_set) tbox.register("evaluate", FitnessEvaluation, training_instances, feature_size, window_size, tbox) # tbox.register("evaluate", FitnessEvaluationMod, training_instances, feature_size, # window_size, tbox, min_len, max_len ) tbox.register("select", tools.selTournament, tournsize=kTournamentSize) tbox.register("mate", gp.cxOnePoint) tbox.register("expr_mut", gp.genFull, min_=1, max_=3, type_=float) tbox.register("mutate", gp.mutUniform, expr=tbox.expr_mut, pset=primitive_set) #enforce size constraint over generated individuals tbox.decorate( "mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=kTreeMaxDepth)) tbox.decorate( "mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=kTreeMaxDepth)) return tbox
def configuracionAlgoritmo(toolbox, pset): toolbox.register("select", tools.selTournament, tournsize=3) 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) toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) # Se define cómo se evaluará cada individuo # En este caso, se hará uso de la función de evaluación que se ha definido en el modulo contiguo toolbox.register("evaluate", Evaluacion.evalEcuacion, toolbox)
def main(datafile): training, test = prep_data(datafile) random.seed(10) # Initialise evolutionary computations toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=2) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("compile", gp.compile, pset=pset) toolbox.register("evaluate", evalClassif, features=training) toolbox.register("select", tools.selTournament, tournsize=3) 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) toolbox.decorate( "mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=10)) toolbox.decorate( "mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=10)) # Initialise the statistic measurement to be shown throughout evolutionary process stats_fit = tools.Statistics(lambda ind: ind.fitness.values) stats_size = tools.Statistics(len) mstats = tools.MultiStatistics(fitness=stats_fit, size=stats_size) mstats.register("avg", np.mean) mstats.register("std", np.std) mstats.register("min", np.min) mstats.register("max", np.max) # create population and hall of fame pop = toolbox.population(n=300) hof = tools.HallOfFame(1) # execute algorithm and print out results pop, log = algorithms.eaSimple(pop, toolbox, 0.8, 0.05, 100, stats=mstats, halloffame=hof, verbose=True) print("\n\ntraining: " + str(hof.keys[0]) + "/" + str(len(training)) + "-->" + str(hof.items[0])) print("\n" "test: " + str(evalClassif(hof.items[0], test)) + "/" + str(len(test))) return pop, mstats, hof
def __init__(self, task_config, backend_opts, train_opts): self.task_config = task_config self.backend_opts = backend_opts self.train_opts = train_opts self.raster_func = None self._pset = gp.PrimitiveSet("MAIN", self.train_opts.band_count) self.chip_dir = None # Set up toolbox with evolution configuration. # TODO: Is this the best place to configure this? Can we auto-detect? self._pset = gp.PrimitiveSet("MAIN", self.train_opts.band_count) # TODO: Make these configurable (?) self._pset.addPrimitive(operator.add, 2) self._pset.addPrimitive(operator.sub, 2) self._pset.addPrimitive(operator.mul, 2) self._pset.addPrimitive(protectedDiv, 2) self._pset.addPrimitive(operator.neg, 1) self._pset.addPrimitive(math.cos, 1) self._pset.addPrimitive(math.sin, 1) self._pset.addPrimitive(protectedLog10, 1) self._pset.addPrimitive(protectedSqrt, 1) self._pset.addPrimitive(math.floor, 1) self._pset.addPrimitive(math.ceil, 1) self._pset.addPrimitive(round, 1) # Multiprocessing self._toolbox = base.Toolbox() self._toolbox.register("map", pool.map) # TODO: Make these configurable. self._toolbox.register("expr", gp.genHalfAndHalf, pset=self._pset, min_=1, max_=2) self._toolbox.register("individual", tools.initIterate, creator.Individual, self._toolbox.expr) self._toolbox.register("population", tools.initRepeat, list, self._toolbox.individual) self._toolbox.register("compile", gp.compile, pset=self._pset) self._toolbox.register("select", tools.selTournament, tournsize=3) self._toolbox.register("mate", gp.cxOnePoint) self._toolbox.register("expr_mut", gp.genFull, min_=0, max_=2) self._toolbox.register("mutate", self.mut_random_operator) self._toolbox.decorate( "mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=5) ) self._toolbox.decorate( "mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=5) )
def resigter_function(): toolbox=base.Toolbox() toolbox.register("expr", gp.genFull, pset=pset, min_=3, max_=15) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("compile", gp.compile, pset=pset) toolbox.register("evaluate", evaluate_soln, input_set_train, cost_train) toolbox.register("select", tools.selTournament, tournsize=(math.floor(len(input_set_train) / 2))) toolbox.register("mate", gp.cxOnePoint) toolbox.register("expr_mut", gp.genFull, min_=0, max_=4) toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=prim_set) toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17))
def create_toolbox(self): toolbox = base.Toolbox() creator.create('FitnessMulti', base.Fitness, weights=(1.0, -1.0)) # Individuals are represented as trees, the typical GP representation creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMulti, pset=self.pset, previous_scores=None, # We will store the fitness for each gen generation_created=0, # And then generation when an individual was created, behaviour=None, # For novelty search ) # Between 1 layer and 3 high toolbox.register("expr", customdeap.genHalfAndHalf, pset=self.pset, min_=0, max_=3) # Individuals should be made based on the expr method above toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) # Mutation toolbox.register("expr_mut", customdeap.genHalfAndHalf, min_=0, max_=3) toolbox.register("mutate", customdeap.mutate_choice, pset=self.pset, expr=toolbox.expr_mut, toolbox=toolbox) toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=self.max_depth)) # The population is just a list of individuals toolbox.register("population", tools.initRepeat, list, toolbox.individual) # Compile is used to turn a tree into runnable python code toolbox.register("compile", self.compile, pset=self.pset) return toolbox
def reg_mating(self): """ Controls how e cross species """ self.toolbox.register("mate", gp.cxOnePoint) self.toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) return
def main(n_corr, num_p, problem): #problem="wastewater" direccion = "./data_corridas/wastewater/wastewater_train_%d.txt" ww(n_corr) toolbox.register("select", tools.selTournament, tournsize=7) toolbox.register("mate", neat_gp.cxSubtree) #toolbox.register("expr_mut", gp.genFull, min_=0, max_=3) toolbox.register("expr_mut", gp.genHalfAndHalf, min_=0, max_=6) toolbox.register("mutate", neat_gp.mutUniform, expr=toolbox.expr_mut, pset=pset) toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) pop = toolbox.population(n=100) hof = tools.HallOfFame(3) stats_fit = tools.Statistics(lambda ind: ind.fitness.values) stats_size = tools.Statistics(len) stats_fit_test=tools.Statistics(lambda i: i.fitness_test.values) mstats = tools.MultiStatistics(fitness=stats_fit,size=stats_size, fitness_test=stats_fit_test) mstats.register("avg", numpy.mean) mstats.register("std", numpy.std) mstats.register("min", numpy.min) mstats.register("max", numpy.max) params = ['best_of_each_specie', 2, 'yes'] cxpb=0.7#.9 mutpb=0.3#.1 ngen=50000 neat_cx = True neat_alg = True neat_pelit = 0.5 neat_h = 0.15 funcEval.LS_flag = False LS_select = 3 funcEval.cont_evalp = 0 num_salto = 500 cont_evalf = 100000 SaveMatrix = True GenMatrix=True testing = True version = 1 pop, log = neatGPLS.neat_GP_LS(pop, toolbox, cxpb, mutpb, ngen, neat_alg, neat_cx, neat_h, neat_pelit,funcEval.LS_flag, LS_select, cont_evalf, num_salto, SaveMatrix, GenMatrix, pset, n_corr, num_p, params, direccion, problem, testing, version, stats=mstats, halloffame=hof,verbose=True) return pop, log, hof
def setup_GP_toolbox(): '''Setup primitives, combinations, genetics for 4-variable expression''' # Register functions used to build the expression tree pset = gp.PrimitiveSet('MAIN', 4) pset.addPrimitive(operator.add, 2) pset.addPrimitive(operator.sub, 2) pset.addPrimitive(operator.mul, 2) pset.addPrimitive(protectedDiv, 2) pset.addPrimitive(abs, 1) pset.addPrimitive(math.sin, 1) pset.addPrimitive(math.tanh, 1) pset.addPrimitive(protectedLog, 1) # Not really specified in the book, guess (-10, 10) pset.addEphemeralConstant( "rand101", lambda: 10 * (-1)**random.randrange(0, 2) * random.random()) pset.renameArguments(ARG0='a1', ARG1='a2', ARG2='a3', ARG3='a4') creator.create("FitnessMin", base.Fitness, weights=(-1.0, )) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMin) toolbox = base.Toolbox() toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=2) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", tools.initRepeat, list, toolbox.individual) # Let the compule use the set of primitives toolbox.register("compile", gp.compile, pset=pset) # For these setting on actual mechanisom used to perform genetic operations # we'd need to look through the source code 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) # Limit complexity of the expression tree toolbox.decorate( "mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate( "mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.register("select", tools.selTournament, tournsize=7) # See Ch 5.2.1 for tournament size return toolbox
def getToolBox(config, pset): creator.create("FitnessMin", base.Fitness, weights=(-1.0, )) creator.create("FitnessTest", base.Fitness, weights=(-1.0, )) creator.create("Individual", neat_gp.PrimitiveTree, fitness=creator.FitnessMin, fitness_test=creator.FitnessTest) toolbox = base.Toolbox() neat_cx = config["neat_cx"] # Attribute generator if neat_cx: toolbox.register("expr", neat_gp.genFull, pset=pset, min_=0, max_=3) else: toolbox.register("expr", neat_gp.genHalfAndHalf, pset=pset, min_=0, max_=7) # Structure initializers toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", init_conf.initRepeat, list, toolbox.individual) toolbox.register("compile", gp.compile, pset=pset) # Operator registering toolbox.register("select", tools.selTournament, tournsize=config["tournament_size"]) toolbox.register("mate", neat_gp.cxSubtree) if neat_cx: toolbox.register("expr_mut", neat_gp.genFull, min_=0, max_=3) else: toolbox.register("expr_mut", neat_gp.genHalfAndHalf, min_=0, max_=7) toolbox.register("mutate", neat_gp.mutUniform, expr=toolbox.expr_mut, pset=pset) toolbox.decorate( "mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate( "mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) return toolbox
def reg_mutation(self): """ Controls how equations mutate """ self.toolbox.register("expr_mut", gp.genFull, min_=0, max_=2) self.toolbox.register("mutate", gp.mutUniform, expr=self.toolbox.expr_mut, pset=self.pset) self.toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) return
def snakeEnvolution(Tsize=10, inds=2000, crossRate=0.5, mutateRate=0.2): toolbox.register("evaluate", evalArtificialSnake) toolbox.register("select", tools.selTournament, tournsize=Tsize) toolbox.register("mate", gp.cxOnePoint) toolbox.register("expr_mut", gp.genFull, min_=0, max_=3) toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset) toolbox.decorate('mutate', staticLimit(operator.attrgetter('height'), 17)) toolbox.decorate('mate', staticLimit(operator.attrgetter('height'), 17)) pop = toolbox.population(n=inds) NGEN, CXPB, MUTPB = 50, crossRate, mutateRate fitnesses = list(map(toolbox.evaluate, pop)) for ind, fit in zip(pop, fitnesses): ind.fitness.values = fit for g in range(NGEN): offspring = toolbox.select(pop, len(pop)) offspring = list(map(toolbox.clone, offspring)) for child1, child2 in zip(offspring[::2], offspring[1::2]): if random.random() < CXPB: toolbox.mate(child1, child2) del child1.fitness.values del child2.fitness.values for mutant in offspring: if random.random() < MUTPB: toolbox.mutate(mutant) del mutant.fitness.values invalid_ind = [ind for ind in offspring if not ind.fitness.valid] fitnesses = map(toolbox.evaluate, invalid_ind) for ind, fit in zip(invalid_ind, fitnesses): ind.fitness.values = fit # The population is entirely replaced by the offspring pop[:] = offspring # Gather all the fitnesses in one list and print the stats fits = [ind.fitness.values[0] for ind in pop] expr = tools.selBest(pop, 100) return expr[0]
def main(n_corr, p): problem = "Housing" direccion="./data_corridas/Housing/train_%d_%d.txt" energy_coolng(n_corr,p) pop_size = 100 toolbox.register("select", tools.selTournament, tournsize=7) toolbox.register("mate", neat_gp.cxSubtree) toolbox.register("expr_mut", gp.genFull, min_=0, max_=3) toolbox.register("mutate", neat_gp.mutUniform, expr=toolbox.expr_mut, pset=pset) toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) pop = toolbox.population(n=pop_size) hof = tools.HallOfFame(3) stats_fit = tools.Statistics(lambda ind: ind.fitness.values) stats_size = tools.Statistics(len) mstats = tools.MultiStatistics(fitness=stats_fit, size=stats_size) mstats.register("avg", np.mean) mstats.register("std", np.std) mstats.register("min", np.min) mstats.register("max", np.max) cxpb = 0.7#0.9 mutpb = 0.3#0.1 ngen = 50000 params = ['best_of_each_specie', 2, 'yes'] neat_cx = False neat_alg = True neat_pelit = 0.5 neat_h = 0.15 funcEval.LS_flag = True LS_select = 9 funcEval.cont_evalp = 0 num_salto = 500 cont_evalf = 100000 SaveMatrix = True GenMatrix = False pop, log = neatGPLS.neat_GP_LS(pop, toolbox, cxpb, mutpb, ngen, neat_alg, neat_cx, neat_h, neat_pelit, funcEval.LS_flag, LS_select, cont_evalf, num_salto, SaveMatrix, GenMatrix, pset,n_corr, p, params, direccion,problem,stats=mstats, halloffame=hof, verbose=True) return pop, log, hof
def getToolBox(config): toolbox = base.Toolbox() # Attribute generator toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=0, max_=6) # Structure initializers toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", init_conf.initRepeat, list, toolbox.individual) toolbox.register("compile", gp.compile, pset=pset) # Operator registering toolbox.register("select", tools.selTournament, tournsize=7) toolbox.register("mate", neat_gp.cxSubtree) toolbox.register("expr_mut", gp.genHalfAndHalf, min_=0, max_=6) toolbox.register("mutate", neat_gp.mutUniform, expr=toolbox.expr_mut, pset=pset) #toolbox.register("evaluate", evalSymbReg, points=data_[0]) #toolbox.register("evaluate_test", evalSymbReg, points=data_[1]) toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) return toolbox
def initToolbox(): """ Creates and configures a DEAP toolbox object """ # Working with a minimization problem, so set weight to -1.0 creator.create("FitnessMin", base.Fitness, weights=(-1.0,)) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMin) # Create toolbox toolbox = base.Toolbox() # Create function set pset = initFunctSet() # Add function set to toolbox toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=2) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) # Population function toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("compile", gp.compile, pset=pset) # Evaluation function here (arguments past evalSymReg are param to pass to evalSymReg) # NOTE: points refers to the training set to use toolbox.register("evaluate", evalSymbReg, points=[(i-30)/10.0 for i in range(60)], toolbox=toolbox) # Sets up tournament size toolbox.register("select", tools.selTournament, tournsize=3) # Mating strategy 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) # Limit mating and mutation tree heights to 17 toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) return toolbox
def get_gp_lgx_toolbox(predictors, response): creator.create("FitnessMax", base.Fitness, weights=(WEIGHT_FITNESS,)) creator.create("Individual", SemanticPrimitiveTree, fitness=creator.FitnessMax, age=int) toolbox = base.Toolbox() pset = symbreg.get_numpy_pset(len(predictors[0])) toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=MIN_DEPTH_INIT, max_=MAX_DEPTH_INIT) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", initialization.syntactically_distinct, individual=toolbox.individual, retries=100) toolbox.register("select", tools.selTournament, tournsize=TOURN_SIZE) lib = library.SemanticLibrary() lib.generate_trees(pset, LIBRARY_DEPTH, predictors) toolbox.register("lib_selector", lib.get_closest, distance_measure=distances.cumulative_absolute_difference, k=LIBRARY_SEARCH_NEIGHBORS, check_constant=True) toolbox.register("mate", locally_geometric.homologous_lgx, library_selector=toolbox.lib_selector, internal_bias=INTERNAL_NODE_SELECTION_BIAS, max_height=MAX_HEIGHT, distance_measure=distances.cumulative_absolute_difference, distance_threshold=0.0) toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=MAX_HEIGHT)) toolbox.decorate("mate", gp.staticLimit(key=len, max_value=MAX_SIZE)) expression_dict = cachetools.LRUCache(maxsize=10000) toolbox.register("error_func", ERROR_FUNCTION, response=response) toolbox.register("evaluate_error", semantics.calc_eval_semantics, context=pset.context, predictors=predictors, eval_semantics=toolbox.error_func, expression_dict=expression_dict) toolbox.register("assign_fitness", afpo.assign_pure_fitness) mstats = reports.configure_inf_protected_stats() multi_archive = get_archive(response) pop = toolbox.population(n=POP_SIZE) toolbox.register("run", ea_simple_semantics.ea_simple, population=pop, toolbox=toolbox, cxpb=XOVER_PROB, mutpb=MUT_PROB, ngen=NGEN, elite_size=0, stats=mstats, verbose=False, archive=multi_archive) toolbox.register("save", reports.save_log_to_csv) toolbox.decorate("save", reports.save_archive(multi_archive)) return toolbox
def main(n_corr, num_p): problem = "EnergyCooling" name_database="energy_efficiency_Cooling" pop_size = 500 energy_coolng(n_corr, num_p, problem, name_database) toolbox.register("select",tools.selTournament, tournsize=3) toolbox.register("mate", neat_gp.cxSubtree) toolbox.register("expr_mut", gp.genFull, min_=0, max_=3) toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset) toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) pop = toolbox.population(n=pop_size) hof = tools.HallOfFame(3) stats_fit = tools.Statistics(lambda ind: ind.fitness.values) stats_size = tools.Statistics(len) mstats = tools.MultiStatistics(fitness=stats_fit, size=stats_size) mstats.register("avg", np.mean) mstats.register("std", np.std) mstats.register("min", np.min) mstats.register("max", np.max) cxpb = 0.7 mutpb = 0.3 ngen = 100 params = ['best_of_each_specie', 2, 'yes'] neat_cx = False neat_alg = False neat_pelit = 0.5 neat_h = 0.15 pop, log = eaneatGP.neat_GP(pop, toolbox, cxpb, mutpb, ngen, neat_alg, neat_cx, neat_h, neat_pelit, n_corr, num_p, params, problem, stats=mstats, halloffame=hof, verbose=True) return pop, log, hof
def run_gp(ins, outs, rseed, problem_name): def protectedDiv(left, right): with numpy.errstate(divide="ignore", invalid="ignore"): x = numpy.divide(left, right) if isinstance(x, numpy.ndarray): x[numpy.isinf(x)] = 1 x[numpy.isnan(x)] = 1 elif numpy.isinf(x) or numpy.isnan(x): x = 1 return x pset = gp.PrimitiveSet("MAIN", len(ins[0])) pset.addPrimitive(numpy.add, 2, name="vadd") pset.addPrimitive(numpy.subtract, 2, name="vsub") pset.addPrimitive(numpy.multiply, 2, name="vmul") pset.addPrimitive(protectedDiv, 2) pset.addPrimitive(numpy.negative, 1, name="vneg") pset.addPrimitive(numpy.cos, 1, name="vcos") pset.addPrimitive(numpy.sin, 1, name="vsin") cname = problem_name + "_" + str(rseed) pset.addEphemeralConstant(cname, lambda: random.randint(-1, 1)) creator.create("FitnessMin", base.Fitness, weights=(-1.0, -1.0)) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMin) toolbox = base.Toolbox() toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=3) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("compile", gp.compile, pset=pset) samples = [col.reshape(len(outs), 1) for col in ins.T] for s in samples: print(s.shape) values = outs.reshape(len(outs), 1) def evalSymbReg(individual): func = toolbox.compile(expr=individual) yhat = func(*samples) diff = numpy.mean((yhat - values) ** 2) return (diff, len(individual)) toolbox.register("evaluate", evalSymbReg) toolbox.register("select", tools.selNSGA2) toolbox.register("mate", gp.cxOnePointLeafBiased, termpb=0.1) toolbox.register("expr_mut", gp.genFull, min_=0, max_=2) toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset) toolbox.register("migrate", tools.migRing, k=2, selection=tools.selBest, replacement=tools.selWorst) toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) random.seed(rseed) NBR_DEMES = 8 MU = 200 NGEN = num_gen MIN_ERR = 1.0e-10 CXPB = 1.0 MUTPB = 0.5 MIG_RATE = 5 demes = [toolbox.population(n=MU) for _ in range(NBR_DEMES)] hof = tools.HallOfFame(1) stats_fit = tools.Statistics(lambda ind: ind.fitness.values) stats_size = tools.Statistics(len) stats = tools.MultiStatistics(fitness=stats_fit, size=stats_size) stats.register("min", numpy.min) stats.register("avg", numpy.mean) stats.register("max", numpy.max) stats.register("std", numpy.std) logbook = tools.Logbook() logbook.header = "gen", "deme", "evals", "fitness", "size" logbook.chapters["fitness"].header = "min", "avg", "max", "std" logbook.chapters["size"].header = "min", "avg", "max", "std" for idx, deme in enumerate(demes): for ind in deme: ind.fitness.values = toolbox.evaluate(ind) logbook.record(gen=0, deme=idx, evals=len(deme), **stats.compile(deme)) hof.update(deme) print(logbook.stream) print() gen = 1 min_reached = 5 while gen <= NGEN and min_reached > 0: for idx, deme in enumerate(demes): parents = toolbox.select(deme, len(deme)) offspring1 = algorithms.varAnd(parents, toolbox, cxpb=CXPB, mutpb=MUTPB) offspring2 = algorithms.varAnd(parents, toolbox, cxpb=CXPB, mutpb=MUTPB) offspring = offspring1 + offspring2 invalid_ind = [ind for ind in offspring if not ind.fitness.valid] for ind in invalid_ind: ind.fitness.values = toolbox.evaluate(ind) deme[:] = toolbox.select(deme + offspring, len(deme)) logbook.record(gen=gen, deme=idx, evals=len(invalid_ind), **stats.compile(deme)) hof.update(deme) print(logbook.stream) print() for row in logbook.chapters["fitness"][-NBR_DEMES:]: if row["min"] < MIN_ERR: min_reached -= 1 break if gen % MIG_RATE == 0: toolbox.migrate(demes) gen += 1 score = hof[0].fitness.values[0] F = toolbox.compile(expr=hof[0]) yhat = F(*samples) r2 = r2_score(values, yhat) return score, r2, gen
on training data ''' semantic = [] # Transform the tree expression in a callable function func = toolbox.compile(expr=individual) for i in xrange(len(trainingInputs)): t = func(*trainingInputs[i]) semantic.append(t) return tuple(semantic) toolbox.register("evaluate", evalSymbReg) toolbox.register("select", tools.selTournament, tournsize=TOURSIZE) toolbox.register("mate", gp.cxOnePoint) toolbox.decorate("mate", gp.staticLimit(operator.attrgetter('height'),80)) toolbox.register("expr_mut", gp.genFull, min_=0, max_=2) toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset) toolbox.decorate("mutate", gp.staticLimit(operator.attrgetter('height'),80)) toolbox.register("getSemantic", getSemantic) def les(problem): global trainingInputs, trainingOutputs, testingInputs, testingOutputs # 1. semantic khac nhau # 2. khong co 2 hang ve trai = nhau, ve phai khac nhau # 3. semantic cua 1 tree khong the chi la 1 gia tri duy nhat print 'initializing population by solving equations system...'
toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=2) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("compile", gp.compile, pset=pset) def evalSymbReg(individual, points): score = abs(target - toolbox.compile(expr=individual)) return score, toolbox.register("evaluate", evalSymbReg, points=[x/10. for x in range(-10,10)]) toolbox.register("select", tools.selTournament, tournsize=3) 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) toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) def main(): random.seed(318) pop = toolbox.population(n=300) hof = tools.HallOfFame(1) stats_fit = tools.Statistics(lambda ind: ind.fitness.values) stats_size = tools.Statistics(len) mstats = tools.MultiStatistics(fitness=stats_fit, size=stats_size) mstats.register("avg", numpy.mean) mstats.register("std", numpy.std) mstats.register("min", numpy.min) mstats.register("max", numpy.max)
def get_toolbox_base(predictors, response, toolbox, param_mut_prob): metadata_dict = dict() latitude_longitude = np.load('../data/SweData/metadata/latlon.npy') elevation = np.load('../data/SweData/metadata/elevation.npy') aspect = np.load('../data/SweData/metadata/aspect.npy') metadata_dict["LatLon"] = latitude_longitude metadata_dict["Elevation"] = np.repeat(elevation, 3) metadata_dict["Aspect"] = np.repeat(aspect, 3) metadata_dict["Response"] = response predictors_dict = [None, None, None] predictors_indices = np.arange(predictors.shape[1]) predictors_dict[0] = predictors[:, predictors_indices % 3 == 0] predictors_dict[1] = predictors[:, predictors_indices % 3 == 1] predictors_dict[2] = predictors[:, predictors_indices % 3 == 2] metadata_dict["Predictors"] = predictors_dict toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("select", tools.selRandom) # Crossover toolbox.register("mate", gp.cxOnePoint) toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("mate", gp.staticLimit(key=len, max_value=300)) # Mutation toolbox.register("expr_mutation", gp.genFull, min_=0, max_=2) toolbox.register("subtree_mutate", gp.mutUniform, expr=toolbox.expr_mutation, pset=toolbox.pset) toolbox.decorate("subtree_mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("subtree_mutate", gp.staticLimit(key=len, max_value=300)) toolbox.register("parameter_mutation", mutation.one_point_parameter_mutation, toolbox=toolbox, metadata=metadata_dict, two_point_scale=0.005, radius_scale=0.25, iterations=20) toolbox.register("mutate", mutation.multi_mutation, mutations=[toolbox.subtree_mutate, toolbox.parameter_mutation], probs=[0.05, param_mut_prob]) # Fast evaluation configuration numpy_response = np.array(response) numpy_predictors = np.array(predictors) expression_dict = cachetools.LRUCache(maxsize=2000) toolbox.register("error_func", fast_evaluate.anti_correlation, response=numpy_response) toolbox.register("evaluate_error", fast_numpy_evaluate_metadata, context=toolbox.pset.context, predictors=numpy_predictors, metadata=metadata_dict, error_function=toolbox.error_func, expression_dict=expression_dict, arg_prefix="ARG") toolbox.register("evaluate", afpo.evaluate_age_fitness_size, error_func=toolbox.evaluate_error) random_data_points = np.random.choice(len(predictors), 1000, replace=False) subset_predictors = numpy_predictors[random_data_points, :] toolbox.register("calc_semantics", calculate_semantics, context=toolbox.pset.context, predictors=subset_predictors, metadata=metadata_dict) toolbox.register("simplify_front", simplify.simplify_all, toolbox=toolbox, size_threshold=0, semantics_threshold=10e-5, precompute_semantics=True) pop = toolbox.population(n=1000) mstats = reports.configure_inf_protected_stats() pareto_archive = archive.ParetoFrontSavingArchive(frequency=1, criteria_chooser=archive.pick_fitness_size_from_fitness_age_size, simplifier=toolbox.simplify_front) toolbox.register("run", afpo.afpo, population=pop, toolbox=toolbox, xover_prob=0.75, mut_prob=0.20, ngen=1000, tournament_size=2, num_randoms=1, stats=mstats, mut_archive=None, hall_of_fame=pareto_archive) toolbox.register("save", reports.save_log_to_csv) toolbox.decorate("save", reports.save_archive(pareto_archive)) return toolbox
def main(): # param_file - set of general parameters for the GP run # texture_to_find - which of the 4 textures are we treating as positive if len(sys.argv) != 4: print "Usage: python " + sys.argv[0] + " param_file" + " texture_to_find" + " seed" sys.exit() #initialize values from input parameter file param_config = ConfigParser.ConfigParser() param_config.read(sys.argv[1]) #load textures in t1n = str(param_config.get("textureFiles","texture1")) t2n = str(param_config.get("textureFiles","texture2")) t3n = str(param_config.get("textureFiles","texture3")) t4n = str(param_config.get("textureFiles","texture4")) t1 = imread(t1n) t2 = imread(t2n) t3 = imread(t3n) t4 = imread(t4n) # Retrieve these values from the pickles print "Intializing pre-calculated filter data" #Load Pre Calculated Testing Points q1 = pickle.load(open("training_points/q1.pkl","rb")) q2 = pickle.load(open("training_points/q2.pkl","rb")) q3 = pickle.load(open("training_points/q3.pkl","rb")) q4 = pickle.load(open("training_points/q4.pkl","rb")) texToFind = int(sys.argv[2]) # Pre Calculated AVG3 scores q1_avg3 = pickle.load(open( "filter_values/q1_avg3.pkl", "rb" )) q2_avg3 = pickle.load(open( "filter_values/q2_avg3.pkl", "rb" )) q3_avg3 = pickle.load(open( "filter_values/q3_avg3.pkl", "rb" )) q4_avg3 = pickle.load(open( "filter_values/q4_avg3.pkl", "rb" )) # Pre Calculated STD3 scores q1_std3 = pickle.load(open( "filter_values/q1_std3.pkl", "rb" )) q2_std3 = pickle.load(open( "filter_values/q2_std3.pkl", "rb" )) q3_std3 = pickle.load(open( "filter_values/q3_std3.pkl", "rb" )) q4_std3 = pickle.load(open( "filter_values/q4_std3.pkl", "rb" )) # Pre Calculated MIN3 scores q1_min3 = pickle.load(open( "filter_values/q1_min3.pkl", "rb" )) q2_min3 = pickle.load(open( "filter_values/q2_min3.pkl", "rb" )) q3_min3 = pickle.load(open( "filter_values/q3_std3.pkl", "rb" )) q4_min3 = pickle.load(open( "filter_values/q4_std3.pkl", "rb" )) # Pre Calculated MAX3 scores q1_max3 = pickle.load(open( "filter_values/q1_max3.pkl", "rb" )) q2_max3 = pickle.load(open( "filter_values/q2_max3.pkl", "rb" )) q3_max3 = pickle.load(open( "filter_values/q3_max3.pkl", "rb" )) q4_max3 = pickle.load(open( "filter_values/q4_max3.pkl", "rb" )) #Pre Calculate AVG5 scores q1_avg5 = pickle.load(open( "filter_values/q1_avg5.pkl", "rb" )) q2_avg5 = pickle.load(open( "filter_values/q2_avg5.pkl", "rb" )) q3_avg5 = pickle.load(open( "filter_values/q3_avg5.pkl", "rb" )) q4_avg5 = pickle.load(open( "filter_values/q4_avg5.pkl", "rb" )) #Pre Calculate STD5 scores q1_std5 = pickle.load(open( "filter_values/q1_std5.pkl", "rb" )) q2_std5 = pickle.load(open( "filter_values/q2_std5.pkl", "rb" )) q3_std5 = pickle.load(open( "filter_values/q3_std5.pkl", "rb" )) q4_std5 = pickle.load(open( "filter_values/q4_std5.pkl", "rb" )) #Pre Calculate MIN5 scores q1_min5 = pickle.load(open( "filter_values/q1_min5.pkl", "rb" )) q2_min5 = pickle.load(open( "filter_values/q2_min5.pkl", "rb" )) q3_min5 = pickle.load(open( "filter_values/q3_min5.pkl", "rb" )) q4_min5 = pickle.load(open( "filter_values/q4_min5.pkl", "rb" )) #Pre Calculate MAX5 scores q1_max5 = pickle.load(open( "filter_values/q1_max5.pkl", "rb" )) q2_max5 = pickle.load(open( "filter_values/q2_max5.pkl", "rb" )) q3_max5 = pickle.load(open( "filter_values/q3_max5.pkl", "rb" )) q4_max5 = pickle.load(open( "filter_values/q4_max5.pkl", "rb" )) #Pre Calculate AVG7 scores q1_avg7 = pickle.load(open( "filter_values/q1_avg7.pkl", "rb" )) q2_avg7 = pickle.load(open( "filter_values/q2_avg7.pkl", "rb" )) q3_avg7 = pickle.load(open( "filter_values/q3_avg7.pkl", "rb" )) q4_avg7 = pickle.load(open( "filter_values/q4_avg7.pkl", "rb" )) #Pre Calculate STD7 scores q1_std7 = pickle.load(open( "filter_values/q1_std7.pkl", "rb" )) q2_std7 = pickle.load(open( "filter_values/q2_std7.pkl", "rb" )) q3_std7 = pickle.load(open( "filter_values/q3_std7.pkl", "rb" )) q4_std7 = pickle.load(open( "filter_values/q4_std7.pkl", "rb" )) #Pre Calculate MIN7 scores q1_min7 = pickle.load(open( "filter_values/q1_min7.pkl", "rb" )) q2_min7 = pickle.load(open( "filter_values/q2_min7.pkl", "rb" )) q3_min7 = pickle.load(open( "filter_values/q3_min7.pkl", "rb" )) q4_min7 = pickle.load(open( "filter_values/q4_min7.pkl", "rb" )) #Pre Calculate MAX7 scores q1_max7 = pickle.load(open( "filter_values/q1_max7.pkl", "rb" )) q2_max7 = pickle.load(open( "filter_values/q2_max7.pkl", "rb" )) q3_max7 = pickle.load(open( "filter_values/q3_max7.pkl", "rb" )) q4_max7 = pickle.load(open( "filter_values/q4_max7.pkl", "rb" )) #Pre Calculate AVG9 scores q1_avg9 = pickle.load(open( "filter_values/q1_avg9.pkl", "rb" )) q2_avg9 = pickle.load(open( "filter_values/q2_avg9.pkl", "rb" )) q3_avg9 = pickle.load(open( "filter_values/q3_avg9.pkl", "rb" )) q4_avg9 = pickle.load(open( "filter_values/q4_avg9.pkl", "rb" )) #Pre Calculate STD9 scores q1_std9 = pickle.load(open( "filter_values/q1_std9.pkl", "rb" )) q2_std9 = pickle.load(open( "filter_values/q2_std9.pkl", "rb" )) q3_std9 = pickle.load(open( "filter_values/q3_std9.pkl", "rb" )) q4_std9 = pickle.load(open( "filter_values/q4_std9.pkl", "rb" )) #Pre Calculate MIN9 scores q1_min9 = pickle.load(open( "filter_values/q1_min9.pkl", "rb" )) q2_min9 = pickle.load(open( "filter_values/q2_min9.pkl", "rb" )) q3_min9 = pickle.load(open( "filter_values/q3_min9.pkl", "rb" )) q4_min9 = pickle.load(open( "filter_values/q4_min9.pkl", "rb" )) #Pre Calculate MAX9 scores q1_max9 = pickle.load(open( "filter_values/q1_max9.pkl", "rb" )) q2_max9 = pickle.load(open( "filter_values/q2_max9.pkl", "rb" )) q3_max9 = pickle.load(open( "filter_values/q3_max9.pkl", "rb" )) q4_max9 = pickle.load(open( "filter_values/q4_max9.pkl", "rb" )) #Pre Calculate AVG11 scores q1_avg11 = pickle.load(open( "filter_values/q1_avg11.pkl", "rb" )) q2_avg11 = pickle.load(open( "filter_values/q2_avg11.pkl", "rb" )) q3_avg11 = pickle.load(open( "filter_values/q3_avg11.pkl", "rb" )) q4_avg11 = pickle.load(open( "filter_values/q4_avg11.pkl", "rb" )) #Pre Calculate STD11 scores q1_std11 = pickle.load(open( "filter_values/q1_std11.pkl", "rb" )) q2_std11 = pickle.load(open( "filter_values/q2_std11.pkl", "rb" )) q3_std11 = pickle.load(open( "filter_values/q3_std11.pkl", "rb" )) q4_std11 = pickle.load(open( "filter_values/q4_std11.pkl", "rb" )) #Pre Calculate MIN11 scores q1_min11 = pickle.load(open( "filter_values/q1_min11.pkl", "rb" )) q2_min11 = pickle.load(open( "filter_values/q2_min11.pkl", "rb" )) q3_min11 = pickle.load(open( "filter_values/q3_min11.pkl", "rb" )) q4_min11 = pickle.load(open( "filter_values/q4_min11.pkl", "rb" )) #Pre Calculate MAX11 scores q1_max11 = pickle.load(open( "filter_values/q1_max11.pkl", "rb" )) q2_max11 = pickle.load(open( "filter_values/q2_max11.pkl", "rb" )) q3_max11 = pickle.load(open( "filter_values/q3_max11.pkl", "rb" )) q4_max11 = pickle.load(open( "filter_values/q4_max11.pkl", "rb" )) print "Begining GP Evolution" #GP parameters numberGens = int(param_config.get("GeneticProgramParams","numberGens")) popSize = int(param_config.get("GeneticProgramParams","popSize")) probCross = float(param_config.get("GeneticProgramParams","probCross")) probMutate = float(param_config.get("GeneticProgramParams","probMutate")) tSize = int(param_config.get("GeneticProgramParams","tournamentSize")) #Seed from input file and set it here seed = int(sys.argv[3]) random.seed(seed) # GP Function Definition # Protected division, will just retun 1 if divsion by 0 def protectedDiv(left, right): try: return left / right except ZeroDivisionError: return 1 #MAX according to Poli 1996 def maxFValue(left,right): if left >= right: return left else: return right #MIN according to Poli 1996 def minFValue(left,right): if left <= right: return left else: return right pset = gp.PrimitiveSet("MAIN", 20) pset.addPrimitive(operator.add, 2) pset.addPrimitive(operator.sub, 2) pset.addPrimitive(operator.mul, 2) pset.addPrimitive(protectedDiv, 2) pset.addPrimitive(maxFValue, 2) pset.addPrimitive(minFValue, 2) pset.addPrimitive(operator.neg, 1) pset.addEphemeralConstant("randFloat", lambda: random.uniform(-1, 1)) #GP Terminal Set # 3 x 3 grids pset.renameArguments(ARG0='avg3') pset.renameArguments(ARG1='std3') pset.renameArguments(ARG2='min3') pset.renameArguments(ARG3='max3') #5 x 5 grids pset.renameArguments(ARG4='avg5') pset.renameArguments(ARG5='std5') pset.renameArguments(ARG6='min5') pset.renameArguments(ARG7='max5') #7 x 7 grids pset.renameArguments(ARG8='avg7') pset.renameArguments(ARG9='std7') pset.renameArguments(ARG10='min7') pset.renameArguments(ARG11='max7') #9 x 9 grids pset.renameArguments(ARG12='avg9') pset.renameArguments(ARG13='std9') pset.renameArguments(ARG14='min9') pset.renameArguments(ARG15='max9') #11 x 11 grids pset.renameArguments(ARG16='avg11') pset.renameArguments(ARG17='std11') pset.renameArguments(ARG18='min11') pset.renameArguments(ARG19='max11') #Other Initializations required for the GP to run. tree depth etc. creator.create("FitnessMin", base.Fitness, weights=(-1.0,)) #tell it to minimize fitness function score creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMin) toolbox = base.Toolbox() toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=2) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("compile", gp.compile, pset=pset) #Fitness Function #this will go through all the test points in all of the 4 textures #and return a score based on that def evalTexture(individual): func = toolbox.compile(expr=individual) fitness_score = 0.0 tp_count = 0.0 tn_count = 0.0 fp_count = 0.0 fn_count = 0.0 q1_scores = list() q2_scores = list() q3_scores = list() q4_scores = list() #01- avg3 05- avg5 09- avg7 13- avg9 17- avg11 #02- std3 06- std5 10- std7 14- std9 18- std11 #03- min3 07- min5 11- min7 15- min9 19- min11 #04- max3 08- max5 12- max7 16- max9 20- max11 for q in range(len(q1)): q1_scores.append(func(q1_avg3[q], q1_std3[q], q1_min3[q], q1_max3[q], q1_avg5[q], q1_std5[q], q1_min5[q], q1_max5[q], q1_avg7[q], q1_std7[q], q1_min7[q], q1_max7[q], q1_avg9[q], q1_std9[q], q1_min9[q], q1_max9[q], q1_avg11[q], q1_std11[q], q1_min11[q], q1_max11[q])) for q in range(len(q2)): q2_scores.append(func(q2_avg3[q], q2_std3[q], q2_min3[q], q2_max3[q], q2_avg5[q], q2_std5[q], q2_min5[q], q2_max5[q], q2_avg7[q], q2_std7[q], q2_min7[q], q2_max7[q], q2_avg9[q], q2_std9[q], q2_min9[q], q2_max9[q], q2_avg11[q], q2_std11[q], q2_min11[q], q2_max11[q])) for q in range(len(q3)): q3_scores.append(func(q3_avg3[q], q3_std3[q], q3_min3[q], q3_max3[q], q3_avg5[q], q3_std5[q], q3_min5[q], q3_max5[q], q3_avg7[q], q3_std7[q], q3_min7[q], q3_max7[q], q3_avg9[q], q3_std9[q], q3_min9[q], q3_max9[q], q3_avg11[q], q3_std11[q], q3_min11[q], q3_max11[q])) for q in range(len(q4)): q4_scores.append(func(q4_avg3[q], q4_std3[q], q4_min3[q], q4_max3[q], q4_avg5[q], q4_std5[q], q4_min5[q], q4_max5[q], q4_avg7[q], q4_std7[q], q4_min7[q], q4_max7[q], q4_avg9[q], q4_std9[q], q4_min9[q], q4_max9[q], q4_avg11[q], q4_std11[q], q4_min11[q], q4_max11[q])) if texToFind == 1: for score in q1_scores: if score >= 0: tp_count += 1 else: fn_count += 1 for score in q2_scores: if score < 0: tn_count += 1 else: fp_count += 1 for score in q2_scores: if score < 0: tn_count += 1 else: fp_count += 1 for score in q3_scores: if score < 0: tn_count += 1 else: fp_count += 1 if texToFind == 2: for score in q2_scores: if score >= 0: tp_count += 1 else: fn_count += 1 for score in q1_scores: if score < 0: tn_count += 1 else: fp_count += 1 for score in q3_scores: if score < 0: tn_count += 1 else: fp_count += 1 for score in q4_scores: if score < 0: tn_count += 1 else: fp_count += 1 if texToFind == 3: for score in q3_scores: if score >= 0: tp_count += 1 else: fn_count += 1 for score in q1_scores: if score < 0: tn_count += 1 else: fp_count += 1 for score in q2_scores: if score < 0: tn_count += 1 else: fp_count += 1 for score in q4_scores: if score < 0: tn_count += 1 else: fp_count += 1 if texToFind == 4: for score in q4_scores: if score >= 0: tp_count += 1 else: fn_count += 1 for score in q1_scores: if score < 0: tn_count += 1 else: fp_count += 1 for score in q2_scores: if score < 0: tn_count += 1 else: fp_count += 1 for score in q3_scores: if score < 0: tn_count += 1 else: fp_count += 1 #print "TP:" + str(tp_count) + " TN:" + str(tn_count) + " FN:" + str(fn_count) + " FP:" + str(fp_count) #fitness_score = fp_count + (fn_count * math.exp(10 * ((fn_count/(256 * 256)) - 0.6))) fitness_score = fp_count + fn_count return fitness_score, #Register GP toolbox object, maintains basic parameters of run toolbox.register("evaluate", evalTexture) toolbox.register("select", tools.selTournament, tournsize=tSize) 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) toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) #Set final parameter before run pop = toolbox.population(n=popSize) hof = tools.HallOfFame(1) #to keep best solution found each run, useful for analysis #use built-in tools to do the stats work stats_fit = tools.Statistics(lambda ind: ind.fitness.values) stats_size = tools.Statistics(len) mstats = tools.MultiStatistics(fitness=stats_fit, size=stats_size) mstats.register("avg", np.mean) mstats.register("std", np.std) mstats.register("min", np.min) mstats.register("max", np.max) #Conduct 1 Run print "Evolving 1 Run" pop, log = algorithms.eaSimple(pop, toolbox, probCross, probMutate, numberGens, stats=mstats, halloffame=hof, verbose=False) #Just print out hof for now print str(hof[0]) #hof object is best GP individual found by the system. write that out with some other data #write these out as text files bhof = open("gp_found/best_seen.txt","a") bhof.write("texture: "+ str(texToFind) + " seed: " + str(seed) + " fitness: "+ str(hof[0].fitness) + "\n\n" + str(hof[0])+"\n\n") #Write out HOF as Pickle so that it can be used during the image rendering process pickle.dump(hof[0],open("gp_found/tex_"+str(texToFind)+"_seed_"+str(seed)+".pkl" ,"wb"),-1) #write out logbooks of run, those contain detailed information about run if len(str(seed)) == 1: f = open("logs/tex_"+str(texToFind)+"_seed_0" + str(seed) + ".txt","w") f.write(str(log)) f.close() else: f = open("logs/tex_"+str(texToFind)+"_seed_" + str(seed) + ".txt","w") f.write(str(log)) f.close() print "Writing out testing data" #Write out the testing results testing/tex1 #1 true positive #2 true negative #3 false postive #4 false negative #01- avg3 05- avg5 09- avg7 13- avg9 17- avg11 #02- std3 06- std5 10- std7 14- std9 18- std11 #03- min3 07- min5 11- min7 15- min9 19- min11 #04- max3 08- max5 12- max7 16- max9 20- max11 ffunc = toolbox.compile(expr=hof[0]) t1_test = np.zeros(256 * 256).reshape(256,256) t2_test = np.zeros(256 * 256).reshape(256,256) t3_test = np.zeros(256 * 256).reshape(256,256) t4_test = np.zeros(256 * 256).reshape(256,256) if texToFind == 1: print "Testing Texture 1 (Want this one)" for x in range(255): for y in range(255): if ffunc(f_avg(3,x,y,t1), f_std(3,x,y,t1), f_min(3,x,y,t1), f_max(3,x,y,t1), f_avg(5,x,y,t1), f_std(5,x,y,t1), f_min(5,x,y,t1), f_max(5,x,y,t1), f_avg(7,x,y,t1), f_std(7,x,y,t1), f_min(7,x,y,t1), f_max(7,x,y,t1), f_avg(9,x,y,t1), f_std(9,x,y,t1), f_min(9,x,y,t1), f_max(9,x,y,t1), f_avg(11,x,y,t1), f_std(11,x,y,t1), f_min(11,x,y,t1), f_max(11,x,y,t1)) >= 0: t1_test[x][y] = 1 else: t1_test[x][y] = 3 print "Testing Texture 2" for x in range(255): for y in range(255): if ffunc(f_avg(3,x,y,t2), f_std(3,x,y,t2), f_min(3,x,y,t2), f_max(3,x,y,t2), f_avg(5,x,y,t2), f_std(5,x,y,t2), f_min(5,x,y,t2), f_max(5,x,y,t2), f_avg(7,x,y,t2), f_std(7,x,y,t2), f_min(7,x,y,t2), f_max(7,x,y,t2), f_avg(9,x,y,t2), f_std(9,x,y,t2), f_min(9,x,y,t2), f_max(9,x,y,t2), f_avg(11,x,y,t2), f_std(11,x,y,t2), f_min(11,x,y,t2), f_max(11,x,y,t2)) < 0: t2_test[x][y] = 2 else: t2_test[x][y] = 4 print "Testing Texture 3" for x in range(255): for y in range(255): if ffunc(f_avg(3,x,y,t3), f_std(3,x,y,t3), f_min(3,x,y,t3), f_max(3,x,y,t3), f_avg(5,x,y,t3), f_std(5,x,y,t3), f_min(5,x,y,t3), f_max(5,x,y,t3), f_avg(7,x,y,t3), f_std(7,x,y,t3), f_min(7,x,y,t3), f_max(7,x,y,t3), f_avg(9,x,y,t3), f_std(9,x,y,t3), f_min(9,x,y,t3), f_max(9,x,y,t3), f_avg(11,x,y,t3), f_std(11,x,y,t3), f_min(11,x,y,t3), f_max(11,x,y,t3)) < 0: t3_test[x][y] = 2 else: t3_test[x][y] = 4 print "Texting Texture 4" for x in range(255): for y in range(255): if ffunc(f_avg(3,x,y,t4), f_std(3,x,y,t4), f_min(3,x,y,t4), f_max(3,x,y,t4), f_avg(5,x,y,t4), f_std(5,x,y,t4), f_min(5,x,y,t4), f_max(5,x,y,t4), f_avg(7,x,y,t4), f_std(7,x,y,t4), f_min(7,x,y,t4), f_max(7,x,y,t4), f_avg(9,x,y,t4), f_std(9,x,y,t4), f_min(9,x,y,t4), f_max(9,x,y,t4), f_avg(11,x,y,t4), f_std(11,x,y,t4), f_min(11,x,y,t4), f_max(11,x,y,t4)) < 0: t4_test[x][y] = 2 else: t4_test[x][y] = 4 if texToFind == 2: print "Texting Texture 1" for x in range(255): for y in range(255): if ffunc(f_avg(3,x,y,t1), f_std(3,x,y,t1), f_min(3,x,y,t1), f_max(3,x,y,t1), f_avg(5,x,y,t1), f_std(5,x,y,t1), f_min(5,x,y,t1), f_max(5,x,y,t1), f_avg(7,x,y,t1), f_std(7,x,y,t1), f_min(7,x,y,t1), f_max(7,x,y,t1), f_avg(9,x,y,t1), f_std(9,x,y,t1), f_min(9,x,y,t1), f_max(9,x,y,t1), f_avg(11,x,y,t1), f_std(11,x,y,t1), f_min(11,x,y,t1), f_max(11,x,y,t1)) < 0: t1_test[x][y] = 2 else: t1_test[x][y] = 4 print "Testing Texture 2 (Want this one)" for x in range(255): for y in range(255): if ffunc(f_avg(3,x,y,t2), f_std(3,x,y,t2), f_min(3,x,y,t2), f_max(3,x,y,t2), f_avg(5,x,y,t2), f_std(5,x,y,t2), f_min(5,x,y,t2), f_max(5,x,y,t2), f_avg(7,x,y,t2), f_std(7,x,y,t2), f_min(7,x,y,t2), f_max(7,x,y,t2), f_avg(9,x,y,t2), f_std(9,x,y,t2), f_min(9,x,y,t2), f_max(9,x,y,t2), f_avg(11,x,y,t2), f_std(11,x,y,t2), f_min(11,x,y,t2), f_max(11,x,y,t2)) >= 0: t2_test[x][y] = 1 else: t2_test[x][y] = 3 print "Testing Texture 3" for x in range(255): for y in range(255): if ffunc(f_avg(3,x,y,t3), f_std(3,x,y,t3), f_min(3,x,y,t3), f_max(3,x,y,t3), f_avg(5,x,y,t3), f_std(5,x,y,t3), f_min(5,x,y,t3), f_max(5,x,y,t3), f_avg(7,x,y,t3), f_std(7,x,y,t3), f_min(7,x,y,t3), f_max(7,x,y,t3), f_avg(9,x,y,t3), f_std(9,x,y,t3), f_min(9,x,y,t3), f_max(9,x,y,t3), f_avg(11,x,y,t3), f_std(11,x,y,t3), f_min(11,x,y,t3), f_max(11,x,y,t3)) < 0: t3_test[x][y] = 2 else: t3_test[x][y] = 4 print "Testing Texture 4" for x in range(255): for y in range(255): if ffunc(f_avg(3,x,y,t4), f_std(3,x,y,t4), f_min(3,x,y,t4), f_max(3,x,y,t4), f_avg(5,x,y,t4), f_std(5,x,y,t4), f_min(5,x,y,t4), f_max(5,x,y,t4), f_avg(7,x,y,t4), f_std(7,x,y,t4), f_min(7,x,y,t4), f_max(7,x,y,t4), f_avg(9,x,y,t4), f_std(9,x,y,t4), f_min(9,x,y,t4), f_max(9,x,y,t4), f_avg(11,x,y,t4), f_std(11,x,y,t4), f_min(11,x,y,t4), f_max(11,x,y,t4)) < 0: t4_test[x][y] = 2 else: t4_test[x][y] = 4 if texToFind == 3: print "Testing Texture 1" for x in range(255): for y in range(255): if ffunc(f_avg(3,x,y,t1), f_std(3,x,y,t1), f_min(3,x,y,t1), f_max(3,x,y,t1), f_avg(5,x,y,t1), f_std(5,x,y,t1), f_min(5,x,y,t1), f_max(5,x,y,t1), f_avg(7,x,y,t1), f_std(7,x,y,t1), f_min(7,x,y,t1), f_max(7,x,y,t1), f_avg(9,x,y,t1), f_std(9,x,y,t1), f_min(9,x,y,t1), f_max(9,x,y,t1), f_avg(11,x,y,t1), f_std(11,x,y,t1), f_min(11,x,y,t1), f_max(11,x,y,t1)) < 0: t1_test[x][y] = 2 else: t1_test[x][y] = 4 print "Testing Texture 2" for x in range(255): for y in range(255): if ffunc(f_avg(3,x,y,t1), f_std(3,x,y,t2), f_min(3,x,y,t2), f_max(3,x,y,t2), f_avg(5,x,y,t2), f_std(5,x,y,t2), f_min(5,x,y,t2), f_max(5,x,y,t2), f_avg(7,x,y,t2), f_std(7,x,y,t2), f_min(7,x,y,t2), f_max(7,x,y,t2), f_avg(9,x,y,t2), f_std(9,x,y,t2), f_min(9,x,y,t2), f_max(9,x,y,t2), f_avg(11,x,y,t2), f_std(11,x,y,t2), f_min(11,x,y,t2), f_max(11,x,y,t2)) < 0: t2_test[x][y] = 2 else: t2_test[x][y] = 4 print "Testing Texture 3 (Want this one)" for x in range(255): for y in range(255): if ffunc(f_avg(3,x,y,t1), f_std(3,x,y,t3), f_min(3,x,y,t3), f_max(3,x,y,t3), f_avg(5,x,y,t3), f_std(5,x,y,t3), f_min(5,x,y,t3), f_max(5,x,y,t3), f_avg(7,x,y,t3), f_std(7,x,y,t3), f_min(7,x,y,t3), f_max(7,x,y,t3), f_avg(9,x,y,t3), f_std(9,x,y,t3), f_min(9,x,y,t3), f_max(9,x,y,t3), f_avg(11,x,y,t3), f_std(11,x,y,t3), f_min(11,x,y,t3), f_max(11,x,y,t3)) >= 0: t3_test[x][y] = 1 else: t3_test[x][y] = 3 print "Testing Texture 4" for x in range(255): for y in range(255): if ffunc(f_avg(3,x,y,t1), f_std(3,x,y,t4), f_min(3,x,y,t4), f_max(3,x,y,t4), f_avg(5,x,y,t4), f_std(5,x,y,t4), f_min(5,x,y,t4), f_max(5,x,y,t4), f_avg(7,x,y,t4), f_std(7,x,y,t4), f_min(7,x,y,t4), f_max(7,x,y,t4), f_avg(9,x,y,t4), f_std(9,x,y,t4), f_min(9,x,y,t4), f_max(9,x,y,t4), f_avg(11,x,y,t4), f_std(11,x,y,t4), f_min(11,x,y,t4), f_max(11,x,y,t4)) < 0: t4_test[x][y] = 2 else: t4_test[x][y] = 4 if texToFind == 4: print "Testing Texture 4" for x in range(255): for y in range(255): if ffunc(f_avg(3,x,y,t1), f_std(3,x,y,t1), f_min(3,x,y,t1), f_max(3,x,y,t1), f_avg(5,x,y,t1), f_std(5,x,y,t1), f_min(5,x,y,t1), f_max(5,x,y,t1), f_avg(7,x,y,t1), f_std(7,x,y,t1), f_min(7,x,y,t1), f_max(7,x,y,t1), f_avg(9,x,y,t1), f_std(9,x,y,t1), f_min(9,x,y,t1), f_max(9,x,y,t1), f_avg(11,x,y,t1), f_std(11,x,y,t1), f_min(11,x,y,t1), f_max(11,x,y,t1)) < 0: t1_test[x][y] = 2 else: t1_test[x][y] = 4 print "Testing Texture 2" for x in range(255): for y in range(255): if ffunc(f_avg(3,x,y,t1), f_std(3,x,y,t2), f_min(3,x,y,t2), f_max(3,x,y,t2), f_avg(5,x,y,t2), f_std(5,x,y,t2), f_min(5,x,y,t2), f_max(5,x,y,t2), f_avg(7,x,y,t2), f_std(7,x,y,t2), f_min(7,x,y,t2), f_max(7,x,y,t2), f_avg(9,x,y,t2), f_std(9,x,y,t2), f_min(9,x,y,t2), f_max(9,x,y,t2), f_avg(11,x,y,t2), f_std(11,x,y,t2), f_min(11,x,y,t2), f_max(11,x,y,t2)) < 0: t2_test[x][y] = 2 else: t2_test[x][y] = 4 print "Testing Texture 3" for x in range(255): for y in range(255): if ffunc(f_avg(3,x,y,t1), f_std(3,x,y,t3), f_min(3,x,y,t3), f_max(3,x,y,t3), f_avg(5,x,y,t3), f_std(5,x,y,t3), f_min(5,x,y,t3), f_max(5,x,y,t3), f_avg(7,x,y,t3), f_std(7,x,y,t3), f_min(7,x,y,t3), f_max(7,x,y,t3), f_avg(9,x,y,t3), f_std(9,x,y,t3), f_min(9,x,y,t3), f_max(9,x,y,t3), f_avg(11,x,y,t3), f_std(11,x,y,t3), f_min(11,x,y,t3), f_max(11,x,y,t3)) < 0: t3_test[x][y] = 2 else: t3_test[x][y] = 4 print "Testing Texture 4 (Want this one)" for x in range(255): for y in range(255): if ffunc(f_avg(3,x,y,t1), f_std(3,x,y,t4), f_min(3,x,y,t4), f_max(3,x,y,t4), f_avg(5,x,y,t4), f_std(5,x,y,t4), f_min(5,x,y,t4), f_max(5,x,y,t4), f_avg(7,x,y,t4), f_std(7,x,y,t4), f_min(7,x,y,t4), f_max(7,x,y,t4), f_avg(9,x,y,t4), f_std(9,x,y,t4), f_min(9,x,y,t4), f_max(9,x,y,t4), f_avg(11,x,y,t4), f_std(11,x,y,t4), f_min(11,x,y,t4), f_max(11,x,y,t4)) >= 0: t4_test[x][y] = 1 else: t4_test[x][y] = 3 pickle.dump(t1_test, open("testing/tex"+str(texToFind)+"_"+str(seed)+"_q1.pkl","wb")) pickle.dump(t2_test, open("testing/tex"+str(texToFind)+"_"+str(seed)+"_q2.pkl","wb")) pickle.dump(t3_test, open("testing/tex"+str(texToFind)+"_"+str(seed)+"_q3.pkl","wb")) pickle.dump(t4_test, open("testing/tex"+str(texToFind)+"_"+str(seed)+"_q4.pkl","wb"))
if result: fit1 += 1 total = total1 + total0 w0 = float(total1)/total w1 = float(total0)/total if weighted: return float(fit0*w0+fit1*w1)/total, else: return float(fit0+fit1)/total, toolbox.register("evaluate", eval) toolbox.register("select", tools.selRoulette) toolbox.register("mate", gp.cxOnePoint) toolbox.register("expr_mut", gp.genGrow, min_=0, max_=2) toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset) toolbox.decorate("mate", gp.staticLimit(operator.attrgetter('height'),max_value=15)) def accuracy(individual, dataset): func = toolbox.compile(expr=individual) acc0 = 0 acc1 = 0 total0 = 0 total1 = 0 for line in dataset: result = func(*line[:att]) if line[att] == 0: total0 += 1 if not result: acc0 += 1 if line[att] == 1: total1 += 1
def setupdeap(args, dataset, inputs, evalfun, discrete=True): """ Builds the evolutionary algorithm. :returns: :py:class:`~deap:deap.base.Toolbox`, :py:class:`~deap:deap.tools.Statistics`, :py:class:`~deap:deap.tools.Logbook` :rtype: tuple """ evalfun = functools.partial(evalfun, data=dataset) # DEAP initialization # new primitive set with 4 inputs pset = gp.PrimitiveSet("MAIN", len(inputs)) pset.addPrimitive(operator.add, 2) pset.addPrimitive(operator.sub, 2) pset.addPrimitive(operator.mul, 2) pset.addPrimitive(protectedDiv, 2) pset.addPrimitive(protectedSqrt, 1) # pset.addEphemeralConstant("rand101", lambda: random.randint(-2,2))#lambda: random.randint(-5,5)) # pset.addEphemeralConstant("1", lambda:1.0) # define the terminals set labels # Python 2.6 does not have dictionary inclusion psetdict = dict([("ARG%d" % (idx,), inp) for idx, inp in enumerate(inputs)]) # psetdict = {'ARG{}'.format(idx): inp for idx, inp in enumerate(inputs)} pset.renameArguments(**psetdict) IND_SIZE = 10 creator.create("FitnessMin", base.Fitness, weights=(-1.0,)) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMin) toolbox = base.Toolbox() statswrap = functools.partial(statsfun, toolbox=toolbox, discrete=discrete) if args.statsf: if not discrete: pset.addPrimitive(statswrap("dL1", "pdf"), 1, name="dL1pdf") pset.addPrimitive(statswrap("dL2", "pdf"), 1, name="dL2pdf") pset.addPrimitive(statswrap("dL1", "cdf"), 1, name="dL1cdf") pset.addPrimitive(statswrap("dL2", "cdf"), 1, name="dL2cdf") # pset.addPrimitive(statsfun('dL1','sf'), 1, name='dL1sf') # pset.addPrimitive(statsfun('dL2','sf'), 1, name='dL2sf') else: # poisson stats funs # pset.addPrimitive(statswrap('dL','pmf'), 1, name='pmf') pset.addPrimitive(statswrap("dL", "cdf"), 1, name="cdf") # pset.addPrimitive(statswrap('dL','ppf'), 1, name='ppf') pset.addPrimitive(statswrap("dL", "isf"), 1, name="isf") # toolbox = coop_base.toolbox # initialize coevolution species and representatives toolbox.register("get_best", tools.selBest, k=1) toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=2) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("species", tools.initRepeat, list, toolbox.individual, args.popSize) toolbox.register("compile", gp.compile, pset=pset) toolbox.register("evaluate", evalfun) # toolbox.register("select", tools.selTournament, tournsize=2) toolbox.register("select", tools.selDoubleTournament, fitness_size=3, parsimony_size=1.5, fitness_first=False) 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) toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) # collect stats stats = tools.Statistics(lambda ind: ind.fitness.values) stats.register("avg", np.mean) stats.register("std", np.std) stats.register("min", np.min) stats.register("max", np.max) logbook = tools.Logbook() logbook.header = "gen", "species", "evals", "std", "min", "avg", "max" return toolbox, stats, logbook
def mydeap(mungedtrain): import operator import math import random import numpy from deap import algorithms from deap import base from deap import creator from deap import tools from deap import gp inputs = mungedtrain.iloc[:,2:10].values.tolist() outputs = mungedtrain['Survived'].values.tolist() # Define new functions def protectedDiv(left, right): try: return left / right except ZeroDivisionError: return 1 pset = gp.PrimitiveSet("MAIN", 8) # eight input pset.addPrimitive(operator.add, 2) pset.addPrimitive(operator.sub, 2) pset.addPrimitive(operator.mul, 2) pset.addPrimitive(protectedDiv, 2) pset.addPrimitive(operator.neg, 1) pset.addPrimitive(math.cos, 1) pset.addPrimitive(math.sin, 1) pset.addPrimitive(max, 2) pset.addPrimitive(min, 2) # add more? pset.addEphemeralConstant("rand101", lambda: random.uniform(-10,10)) # adjust? pset.renameArguments(ARG0='x1') pset.renameArguments(ARG1='x2') pset.renameArguments(ARG2='x3') pset.renameArguments(ARG3='x4') pset.renameArguments(ARG4='x5') pset.renameArguments(ARG5='x6') pset.renameArguments(ARG6='x7') pset.renameArguments(ARG7='x8') creator.create("FitnessMin", base.Fitness, weights=(1.0,)) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMin) toolbox = base.Toolbox() toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=3) # toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("compile", gp.compile, pset=pset) def evalSymbReg(individual): # Transform the tree expression in a callable function func = toolbox.compile(expr=individual) # Evaluate the accuracy return sum(round(1.-(1./(1.+numpy.exp(-func(*in_))))) == out for in_, out in zip(inputs, outputs))/len(mungedtrain), toolbox.register("evaluate", evalSymbReg) toolbox.register("select", tools.selTournament, tournsize=3) 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) toolbox.decorate("mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) random.seed(318) pop = toolbox.population(n=300) # hof = tools.HallOfFame(1) stats_fit = tools.Statistics(lambda ind: ind.fitness.values) stats_size = tools.Statistics(len) mstats = tools.MultiStatistics(fitness=stats_fit, size=stats_size) mstats.register("avg", numpy.mean) mstats.register("std", numpy.std) mstats.register("min", numpy.min) mstats.register("max", numpy.max) pop, log = algorithms.eaSimple(pop, toolbox, 0.5, 0.2, 100, stats=mstats, halloffame=hof, verbose=True) # print(hof[0]) func2 =toolbox.compile(expr=hof[0]) return func2