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
