def genetic():
population_size = 5 # num of solutions in the population
num_generations = 10 # num of time we generate new population
# create a minimizing fitness function, cause we want to minimize RMSE
creator.create('FitnessMax', base.Fitness, weights=(-1.0, ))
# create a list to encode solution in it (binary list)
creator.create('Individual', list, fitness=creator.FitnessMax)
# create an object of Toolbox class
toolbox = base.Toolbox()
toolbox.register("attr_int2", random.randint, 100, 2000)
toolbox.register("attr_int3", random.randint, 1, 5)
toolbox.register("attr_int4", random.randint, 1, 5)
toolbox.register("attr_int5", random.randint, 1, 5)
toolbox.register("attr_int6", random.randint, 1, 6)
toolbox.register("individual",
tools.initCycle,
creator.Individual,
(toolbox.attr_int2, toolbox.attr_int3, toolbox.attr_int4,
toolbox.attr_int5, toolbox.attr_int6),
n=1)
toolbox.register('population', tools.initRepeat, list, toolbox.individual)
toolbox.register('mate', tools.cxTwoPoint)
toolbox.register('mutate',
tools.mutUniformInt,
low=[100, 1, 1, 1, 1],
up=[2000, 5, 5, 5, 6],
indpb=0.6)
toolbox.register('select', tools.selRoulette)
toolbox.register('evaluate', train_evaluate)
# create population by calling population function
population = toolbox.population(n=population_size)
hof = tools.HallOfFame(3)
# start GA
r = algorithms.eaSimple(population,
toolbox,
cxpb=0.4,
mutpb=0.1,
ngen=num_generations,
halloffame=hof,
verbose=False)
# Print top N solutions
best_individuals = tools.selBest(hof, k=3)
best_epochs = None
best_neuron1 = None
best_neuron2 = None
best_neuron3 = None
best_window = None
print("\nBest solution is:")
for bi in best_individuals:
best_epochs = bi[0]
best_neuron1 = bi[1]
best_neuron2 = bi[2]
best_neuron3 = bi[3]
best_window = bi[4]
print('\n epochs = ', best_epochs, ", neurons = [", best_neuron1, ",",
best_neuron2, ",", best_neuron3, "]", "window size = ",
best_window)
def main(teacher, paper, M, K, F, CR):
threshold = 1 - 7.5 / 50
creator.create("FitnessMin", base.Fitness, weights=(-1.0, ))
creator.create("Individual", list, fitness=creator.FitnessMin)
toolbox = base.Toolbox()
toolbox.register("paper_assignment", numpy.random.random_sample, paper)
toolbox.register("individual",
tools.initRepeat,
creator.Individual,
toolbox.paper_assignment,
n=teacher)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("select", tools.selRandom, k=3)
toolbox.register("selectBest", tools.selBest, k=1)
toolbox.register("selectWorst", tools.selWorst, k=1)
toolbox.register("evaluate", evalCost, teacher, paper, threshold)
pop = toolbox.population(n=M)
hof = tools.HallOfFame(1)
stats = tools.Statistics(lambda ind: ind.fitness.values)
stats.register("avg", numpy.mean)
stats.register("std", numpy.std)
stats.register("min", numpy.min)
stats.register("max", numpy.max)
logbook = tools.Logbook()
logbook.header = "gen", "evals", "std", "min", "avg", "max"
# Evaluate the individuals
fitnesses = toolbox.map(toolbox.evaluate, pop)
for ind, fit in zip(pop, fitnesses):
ind.fitness.values = fit
record = stats.compile(pop)
logbook.record(gen=0, evals=len(pop), **record)
print(logbook.stream)
result = []
for g in range(1, K):
for k, agent in enumerate(pop):
a, b, c = toolbox.select(pop)
maxp, = toolbox.selectBest(pop)
minp, = toolbox.selectWorst(pop)
y = toolbox.clone(agent)
index = random.randrange(K)
for idx1, arr in enumerate(agent):
for idx2, j in enumerate(arr):
if idx2 == index or random.random() < CR:
y[idx1][idx2] = a[idx1][idx2] + F * (b[idx1][idx2] -
c[idx1][idx2])
if y[idx1][idx2] > 1 or y[idx1][idx2] < 0:
y[idx1][idx2] = (int)(numpy.random.random_sample())
y.fitness.values = toolbox.evaluate(y)
if y.fitness > agent.fitness:
pop[k] = y
hof.update(pop)
record = stats.compile(pop)
logbook.record(gen=g, evals=len(pop), **record)
result.append(record["min"])
print(logbook.stream)
result.append(hof[0].fitness.values[0])
final = getFinalMatrix(hof[0], teacher, paper, threshold)
print("Best individual calculated by DE algorithm is ", final,
hof[0].fitness.values[0])
return result
def run():
for i in range(number_of_runs):
###################################################################
#EVOLUTIONARY ALGORITHM
###################################################################
#TYPE
#Create minimizing fitness class w/ single objective:
creator.create('FitnessMin', base.Fitness, weights=(-1.0, ))
#Create individual class:
creator.create('Individual', list, fitness=creator.FitnessMin)
#TOOLBOX
toolbox = base.Toolbox()
#Register function to create a number in the interval [1-100?]:
#toolbox.register('init_params', )
#Register function to use initRepeat to fill individual w/ n calls to rand_num:
toolbox.register('individual',
tools.initRepeat,
creator.Individual,
np.random.random,
n=number_of_params)
#Register function to use initRepeat to fill population with individuals:
toolbox.register('population', tools.initRepeat, list,
toolbox.individual)
#GENETIC OPERATORS:
# Register evaluate fxn = evaluation function, individual to evaluate given later
toolbox.register('evaluate', scorefxn_helper)
# Register mate fxn = two points crossover function
toolbox.register('mate', tools.cxTwoPoint)
# Register mutate by swapping two points of the individual:
toolbox.register('mutate',
tools.mutPolynomialBounded,
eta=0.1,
low=0.0,
up=1.0,
indpb=0.2)
# Register select = size of tournament set to 3
toolbox.register('select', tools.selTournament, tournsize=3)
#EVOLUTION!
pop = toolbox.population(n=number_of_individuals)
hof = tools.HallOfFame(1)
stats = tools.Statistics(key=lambda ind: [ind.fitness.values, ind])
stats.register('all', np.copy)
# using built in eaSimple algo
pop, logbook = algorithms.eaSimple(pop,
toolbox,
cxpb=crossover_rate,
mutpb=mutation_rate,
ngen=number_of_generations,
stats=stats,
halloffame=hof,
verbose=False)
# print(f'Run number completed: {i}')
###################################################################
#MAKE LISTS
###################################################################
# Find best scores and individuals in population
arr_best_score = []
arr_best_ind = []
for a in range(len(logbook)):
scores = []
for b in range(len(logbook[a]['all'])):
scores.append(logbook[a]['all'][b][0][0])
#print(a, np.nanmin(scores), np.nanargmin(scores))
arr_best_score.append(np.nanmin(scores))
#logbook is of type 'deap.creator.Individual' and must be loaded later
#don't want to have to load it to view data everytime, thus numpy
ind_np = np.asarray(logbook[a]['all'][np.nanargmin(scores)][1])
ind_np_conv = convert_individual(ind_np, arr_conversion_matrix,
number_of_params)
arr_best_ind.append(ind_np_conv)
#arr_best_ind.append(np.asarray(logbook[a]['all'][np.nanargmin(scores)][1]))
# print('Best individual is:\n %s\nwith fitness: %s' %(arr_best_ind[-1],arr_best_score[-1]))
###################################################################
#PICKLE
###################################################################
arr_to_pickle = [arr_best_score, arr_best_ind]
def get_filename(val):
filename_base = dir_to_use + '/' + stripped_name + '_'
if val < 10:
toret = '000' + str(val)
elif 10 <= val < 100:
toret = '00' + str(val)
elif 100 <= val < 1000:
toret = '0' + str(val)
else:
toret = str(val)
return filename_base + toret + '.pickled'
counter = 0
filename = get_filename(counter)
while os.path.isfile(filename) == True:
counter += 1
filename = get_filename(counter)
pickle.dump(arr_to_pickle, open(filename, 'wb'))
#scaler.fit(data)
#datos = scaler.transform(data)
datos = data
k = 2
toolbox = base.Toolbox()
toolbox.register("evaluate", operadores.ev_silhouette, datos=datos,
n_clusters=k)
toolbox.register("mate", tools.cxOnePoint)
toolbox.register("mutate", operadores.mut_centroide_random, datos=datos,
indpb=0.2)
toolbox.register("select", tools.selRandom, k=100)
halloffame = tools.HallOfFame(5, similar=np.array_equal)
inicio = time.time()
pob_inicial = generar_poblacion_centroides(k, 100, [np.min(datos, axis=0),
np.max(datos, axis=0)])
fin = time.time()
print("\nTiempo generacion poblacion {0}".format(fin - inicio))
inicio = time.time()
poblacion = clustering_genetico_simple(pob_inicial, toolbox, 0.5, 0.2, 20,
halloffame=halloffame)
fin = time.time()
print('\nBest individual:\n', halloffame[0])
print("\n Puntaje: {0}".format(halloffame[0].fitness.values))
def _fit(self, X, y, parameter_dict):
self.scorer_ = check_scoring(self.estimator, scoring=self.scoring)
n_samples = _num_samples(X)
X, y = indexable(X, y)
if y is not None:
if len(y) != n_samples:
raise ValueError(
"Target variable (y) has a different number "
"of samples (%i) than data (X: %i samples)" % (len(y), n_samples)
)
cv = self.cv
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=RuntimeWarning)
# * y.shape[1]
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create(
"Individual", list, est=clone(self.estimator), fitness=creator.FitnessMax
)
toolbox = base.Toolbox()
name_values, gene_type, maxints = _get_param_types_maxint(parameter_dict)
if self.gene_type is None:
self.gene_type = gene_type
if self.verbose:
print("Types %s and maxint %s detected" % (self.gene_type, maxints))
toolbox.register("individual", _initIndividual, creator.Individual, maxints=maxints)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register(
"evaluate",
_evalFunction,
name_values=name_values,
X=X,
y=y,
scorer=self.scorer_,
cv=cv,
iid=self.iid,
verbose=self.verbose,
error_score=self.error_score,
fit_params=self.fit_params,
)
toolbox.register(
"mate", _cxIndividual, indpb=self.gene_crossover_prob, gene_type=self.gene_type
)
toolbox.register("mutate", _mutIndividual, indpb=self.gene_mutation_prob, up=maxints)
toolbox.register("select", tools.selTournament, tournsize=self.tournament_size)
if self.n_jobs > 1:
pool = Pool(processes=self.n_jobs)
toolbox.register("map", pool.map)
pop = toolbox.population(n=self.population_size)
hof = tools.HallOfFame(1)
stats = tools.Statistics(lambda ind: ind.fitness.values)
stats.register("avg", np.mean)
stats.register("min", np.min)
stats.register("max", np.max)
if self.verbose:
msg_template = "--- Evolve in {0} possible combinations ---"
print(msg_template.format(np.prod(np.array(maxints) + 1)))
pop, logbook = algorithms.eaSimple(
pop,
toolbox,
cxpb=0.5,
mutpb=0.2,
ngen=self.generations_number,
stats=stats,
halloffame=hof,
verbose=self.verbose,
)
print(hof[0].fitness.values)
current_best_score_ = hof[0].fitness.values[0]
current_best_params_ = _individual_to_params(hof[0], name_values)
print("cbp", current_best_params_)
if self.verbose:
print(
"Best individual is: %s\nwith fitness: %s"
% (current_best_params_, current_best_score_)
)
if current_best_score_ > self.best_score_:
self.best_score_ = current_best_score_
self.best_params_ = current_best_params_
def evolveGeneration(self):
"""
A method to evolve a species of boid using a
generational genetic algorithm. Authored by Zach Sipper,
modified from evolveSteady() by Gianni Orlando. Edited
by Ryan McArdle.
:returns: the evolved species, and its fitness
"""
name = "Generation"
self.prepareEvolution()
# Initialize fitness goal and individual type
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", array.array, typecode='d',fitness=creator.FitnessMax)
#Initialize individuals, populations, and evolution operators
toolbox = base.Toolbox()
toolbox.register("individual", self.initBoids, creator.Individual, *self.parameter_bounds)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("evaluate", self.boidFitness)
toolbox.register("mate", tools.cxOnePoint)
toolbox.register("mutate", tools.mutGaussian, indpb=0.5, mu=25.5, sigma=12.5) # 50% chance for each value to mutate
toolbox.register("mutate2", tools.mutShuffleIndexes, indpb=0.5) # 50% chance for each value to mutate
toolbox.register("select", tools.selTournament, tournsize= 5)
toolbox.decorate('mate', self.checkBounds(self.parameter_bounds))
toolbox.decorate('mutate', self.checkBounds(self.parameter_bounds))
toolbox.decorate('mutate2', self.checkBounds(self.parameter_bounds))
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)
self.logbook = tools.Logbook()
self.logbook.header = 'gen','evals','min','max','avg','std'
hof = tools.HallOfFame(1)
pop = toolbox.population(n=self.mu)
#Evaluate the entire population
seed = random.randint(1,1e10)
## Evaluate the entire population for fitness in parallel
if __name__=="__main__":
with mp.Pool(self.num_processes) as pool:
fitnesses = pool.starmap(self.boidFitness, [(boid.tolist(),seed,self.current_evals,self.eval_limit) for boid in pop])
for ind, fit in zip(pop, fitnesses):
ind.fitness.values = fit,
#Extracting all the fitnesses of
fits = [ind.fitness.values[0] for ind in pop]
#Variable keeping track of the number of generations
g = 0
## Record the initial population
self.current_evals += len(pop)
record = stats.compile(pop)
logbook = tools.Logbook()
logbook.header = 'gen','evals','min','max','avg','std'
logbook.record(gen=0, evals=self.current_evals, **record)
print(logbook.stream)
hof.update(pop)
print(hof[0])
print(hof[0].fitness.values[0])
#Begin the evolution
while hof[0].fitness.values[0] < 1.0 and self.current_evals < self.eval_limit:
#A new generation
g = g + 1
# Gather all the fitnesses in one list and print the stats
fits = [ind.fitness.values for ind in pop]
############################################################
#### Code between hash lines produced by Zach Sipper and
#### edited by Ryan McArdle.
####
# Select the next generation individuals
bestIndv = tools.selBest(pop, k=2)
# Elitism: put top two individuals in next generation
nextGeneration = [*bestIndv]
#nextGeneration += bestIndv
# perform crossover on pairs until nextGeneration is equal in size to pop
# case that len(pop) is even
if len(pop) % 2 == 0:
while len(nextGeneration) < (len(pop)):
parents = toolbox.select(pop,2)
parents = list(map(toolbox.clone,parents))
toolbox.mate(parents[0], parents[1])
for parent in parents:
del parent.fitness.values
# mutation of children with 'MUTPB' chance
for parent in parents:
if random.random() < self.MUTPB:
toolbox.mutate(parent)
del parent.fitness.values
# add the pair of children to nextGeneration
nextGeneration.extend(parents)
# case the len(pop) is odd
if len(pop) % 2 == 1:
while len(nextGeneration) < len(pop)-2:
parents = toolbox.select(pop, 2)
parents = list(map(toolbox.clone, parents))
toolbox.mate(parents[0], parents[1])
for parent in parents:
del parent.fitness.values
# mutation of children with 'MUTPB' chance
for parent in parents:
if random.random() < self.MUTPB:
toolbox.mutate(parent)
del parent.fitness.values
# add the pair of children to nextGeneration
nextGeneration.extend(parents)
# add one more child to nextGeneration
parents = toolbox.select(pop,2)
toolbox.mate(parents[0], parents[1])
child = parents[0]
del child.fitness.values
# mutation of child
if random.random() < self.MUTPB:
toolbox.mutate(child)
del child.fitness.values
# add the child to nextGeneration
nextGeneration.extend(list(map(toolbox.clone,child)))
pop = list(map(toolbox.clone,nextGeneration))
####
####
############################################################
#Evaluate the population with invalid fitnesses
invalid_ind = [ind for ind in pop if not ind.fitness.valid]
seed = random.randint(1,1e10)
if __name__=="__main__":
with mp.Pool(self.num_processes) as pool:
fitnesses = pool.starmap(self.boidFitness, [(boid.tolist(),seed,self.current_evals,self.eval_limit) for boid in invalid_ind])
## Apply found fitness values
for ind, fit in zip(invalid_ind, fitnesses):
ind.fitness.values = fit,
# Extracting all the fitnesses of
fits = [ind.fitness.values[0] for ind in pop]
##################################################
## Record the new generation
hof.update(pop)
record = stats.compile(pop)
self.current_evals += len(invalid_ind)
logbook.record(gen=g, evals=self.current_evals, **record)
print(logbook.stream)
print(hof[0])
print(hof[0].fitness.values[0])
#bestFit, bestDetailFit, bestFitWeight = self.boidFitness(hof[0].tolist(),seed,self.current_evals-len(invalid_ind),self.eval_limit,detail=True)
#print(bestDetailFit)
##################################################
self.plotAndRecord(logbook,hof,name)
return hof[0]
def evolveMuPlusLambda(self,lambda_ratio=7):
"""
A method to evolve a species of boid using a
(Mu + Lambda) evolutionary strategy. Method authored
by Olusade Calhoun. Edited by Ryan McArdle.
:returns: the best individual found by the evolution
"""
name = "MuPlusLambda"+str(lambda_ratio)
self.prepareEvolution(lambda_ratio)
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", array.array, typecode="d", fitness=creator.FitnessMax, strategy=None)
creator.create("Strategy", array.array, typecode="d")
toolbox = base.Toolbox()
toolbox.register("individual", self.initBoidsStrat, creator.Individual, creator.Strategy, *self.parameter_bounds, *self.strategy_bounds)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("mate", tools.cxESBlend, alpha=0.333)
toolbox.register("mutate", tools.mutESLogNormal, c=0.01, indpb=0.1)
toolbox.register("select", tools.selRandom)
toolbox.register("evaluate", self.boidFitness)
toolbox.decorate('mate', self.checkBounds(self.parameter_bounds))
toolbox.decorate('mutate', self.checkBounds(self.parameter_bounds))
toolbox.decorate('mate', self.checkStrategy(self.strategy_bounds))
toolbox.decorate('mutate', self.checkStrategy(self.strategy_bounds))
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)
self.logbook = tools.Logbook()
self.logbook.header = 'gen','evals','min','max','avg','std'
hof = tools.HallOfFame(1)
pop = toolbox.population(n=self.mu)
seed = random.randint(1,1e10)
## Evaluate the entire population for fitness in parallel
if __name__=="__main__":
with mp.Pool(self.num_processes) as pool:
fitnesses = pool.starmap(self.boidFitness, [(boid.tolist(),seed,self.current_evals,self.eval_limit) for boid in pop])
for ind, fit in zip(pop, fitnesses):
ind.fitness.values = fit,
g = 0
self.current_evals += len(pop)
record = stats.compile(pop)
logbook = tools.Logbook()
logbook.header = 'gen','evals','min','max','avg','std'
logbook.record(gen=0, evals=self.current_evals, **record)
print(logbook.stream)
hof.update(pop)
print(hof[0])
print(hof[0].fitness.values[0])
## Main loop
while True:
if self.current_evals < (self.eval_limit - self.lambda_):
g+=1
offspring = toolbox.select(pop, self.lambda_)
offspring = list(map(toolbox.clone, offspring))
#crossover and mutation
for child1, child2 in zip(offspring[::2], offspring[1:2]):
if random.random() < self.CXPB:
toolbox.mate(child1, child2)
del child1.fitness.values
del child2.fitness.values
for mutant in offspring:
if random.random() < self.MUTPB:
toolbox.mutate(mutant)
del mutant.fitness.values
invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
seed = random.randint(1,1e10)
if __name__=="__main__":
with mp.Pool(self.num_processes) as pool:
fitnesses = pool.starmap(self.boidFitness, [(boid.tolist(),seed,self.current_evals,self.eval_limit) for boid in invalid_ind])
for ind, fit in zip(invalid_ind, fitnesses):
ind.fitness.values = fit,
#replace population with top mu+lam offspring
newGen = list(map(toolbox.clone, [*pop, *offspring]))
newGen.sort(key = lambda x: x.fitness.values[0])
pop = list(map(toolbox.clone, newGen[-self.mu:])) #selects mu highest fitness in population
##################################################
## Record the new generation
hof.update(pop)
record = stats.compile(pop)
self.current_evals += len(invalid_ind)
logbook.record(gen=g, evals=self.current_evals, **record)
print(logbook.stream)
print(hof[0])
print(hof[0].fitness.values[0])
#bestFit, bestDetailFit, bestFitWeight = self.boidFitness(hof[0].tolist(),seed,self.current_evals-len(invalid_ind),self.eval_limit,detail=True)
#print(bestDetailFit)
##################################################
else:
break
self.plotAndRecord(logbook,hof,name)
return hof[0]
def init_algorithm(self, params):
if params['algorithm_class'] not in ['simple', 'multiobjective']:
raise ValueError('Non-existent algorithm class.')
toolbox = base.Toolbox()
ngen = params['generations']
nind = params['num_individuals']
cxpb = 0.5 if params['algorithm_class'] == 'simple' else 0.9
lb, ub = -1.0, 1.0
ind_size = self.problem.ind_size
if nind % 4 != 0:
raise ValueError('Number of individuals must be multiple of four')
if hasattr(creator, 'FitnessMin') is False:
creator.create('FitnessMin', base.Fitness, weights=(-1.0, -1.0))
if hasattr(creator, 'Individual') is False:
creator.create('Individual',
array.array,
typecode='d',
fitness=creator.FitnessMin)
atr = lambda: [random.uniform(lb, ub) for _ in range(ind_size)]
ind = lambda: tools.initIterate(creator.Individual, atr)
population = [ind() for _ in range(nind)]
if params['algorithm_class'] == 'simple':
self.hof = tools.HallOfFame(1)
mut = lambda xs: tools.mutGaussian(xs, mu=0, sigma=1, indpb=0.1)
crs = tools.cxTwoPoint
sel = lambda p, n: tools.selTournament(p, n, tournsize=3)
else:
self.hof = tools.ParetoFront()
mut = lambda xs: tools.mutPolynomialBounded(
xs, low=lb, up=ub, eta=20.0, indpb=1.0 / ind_size)
crs = lambda ind1, ind2: tools.cxSimulatedBinaryBounded(
ind1, ind2, low=lb, up=ub, eta=20.0)
sel = tools.selNSGA2
toolbox.register('evaluate', self.problem.objective_function)
toolbox.register('mate', crs)
toolbox.register('mutate', mut)
toolbox.register('select', sel)
stats = tools.Statistics(lambda ind: ind.fitness.values)
stats.register('avg', np.mean, axis=0)
stats.register('std', np.std, axis=0)
stats.register('min', np.min, axis=0)
stats.register('max', np.max, axis=0)
args = (population, toolbox)
kwargs = {'cxpb': cxpb, 'ngen': ngen, 'stats': stats}
kwargs['halloffame'] = self.hof
if params['algorithm_class'] == 'simple':
kwargs['mutpb'] = 0.2
kwargs['verbose'] = True
self.algorithm = lambda: algorithms.eaSimple(*args, **kwargs)
else:
self.algorithm = lambda: self.multiobjective(*args, **kwargs)
"mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=10))
# In[ ]:
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)
population = toolbox.population(n=300)
cxpb, mutpb, ngen, mu, lambda_ = 0.6, 0.15, 300, 200, 400
stats = mstats
halloffame = tools.HallOfFame(1)
verbose = True
wholeFitness = []
singleFitness = []
earlyStoppingThresh = 0.01
earlyStoppingGens = 150
print("Start of evolution")
logbook = tools.Logbook()
logbook.header = ['gen', 'nevals'] + (stats.fields if stats else [])
# Evaluate the individuals with an invalid fitness
invalid_ind = [ind for ind in population if not ind.fitness.valid]
fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
for ind, fit in zip(invalid_ind, fitnesses):
ind.fitness.values = fit
def getParamter(real_matrix, multiple_matrix, testPosition):
creator.create("FitnessMax", base.Fitness, weights=(1.0, ))
creator.create("Individual",
array.array,
typecode='d',
fitness=creator.FitnessMax)
toolbox = base.Toolbox()
# Attribute generator
toolbox.register("attr_float", random.uniform, 0, 1)
# Structure initializers
variable_num = len(multiple_matrix)
toolbox.register("individual", tools.initRepeat, creator.Individual,
toolbox.attr_float, variable_num)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
#################################################################################################
real_labels = []
for i in range(0, len(testPosition)):
real_labels.append(real_matrix[testPosition[i][0], testPosition[i][1]])
multiple_prediction = []
for i in range(0, len(multiple_matrix)):
predicted_probability = []
predict_matrix = multiple_matrix[i]
for j in range(0, len(testPosition)):
predicted_probability.append(predict_matrix[testPosition[j][0],
testPosition[j][1]])
normalize = MinMaxScaler()
predicted_probability = normalize.fit_transform(
np.array(predicted_probability).reshape(-1, 1))
predicted_probability = predicted_probability.flatten()
multiple_prediction.append(predicted_probability)
#################################################################################################
toolbox.register("evaluate",
fitFunction,
parameter1=real_labels,
parameter2=multiple_prediction)
toolbox.register("mate", tools.cxTwoPoint)
toolbox.register("mutate", tools.mutFlipBit, indpb=0.05)
toolbox.register("select", tools.selTournament, tournsize=3)
random.seed(0)
pop = toolbox.population(n=100)
hof = tools.HallOfFame(1)
stats = tools.Statistics(lambda ind: ind.fitness.values)
stats.register("avg", numpy.mean)
stats.register("std", numpy.std)
stats.register("min", numpy.min)
stats.register("max", numpy.max)
pop, log = algorithms.eaSimple(pop,
toolbox,
cxpb=0.5,
mutpb=0.2,
ngen=50,
stats=stats,
halloffame=hof,
verbose=True)
pop.sort(key=lambda ind: ind.fitness, reverse=True)
print(pop[0])
return pop[0]
os.makedirs(experiment_name + '/' + str(enemy))
# default environment fitness is assumed for experiment
env.state_to_log() # checks environment state
strategy = cma.Strategy(centroid=[0] * n_vars, sigma=1, lambda_=20)
toolbox.register("generate", strategy.generate, creator.Individual)
toolbox.register("update", strategy.update)
# multi processing
pool = multiprocessing.Pool()
toolbox.register("map", partial(mymap, pool.map))
for i in range(10):
hof = tools.HallOfFame(1, similar=np.array_equal)
fitness_stats = tools.Statistics(lambda ind: ind.fitness.values)
fitness_stats.register("time", timeit)
energy_stats = tools.Statistics(lambda ind: ind.energy)
stats = tools.MultiStatistics(fitness=fitness_stats,
energy=energy_stats)
stats.register("avg", np.mean)
stats.register("std", np.std)
stats.register("min", np.min)
stats.register("max", np.max)
ini = time.time() # sets total time marker
gen_start_time = time.time() # sets gen time marker
# The CMA-ES algorithm converge with good probability with those settings
def main():
np.random.seed(19)
x_p = []*N
fbest = [] #世代ごとのf(x)のベスト
vbest = []
Fbest = []
a = 0.99
b = 1.01
y_start = (b - a) * np.random.rand(N) + a
y_p, fbest_nelder, Vbest_nelder, Fbest_nelder = nelder_mead(f_n, y_start, step=1.0, no_improve_thr=1.0e-5, no_improv_break=nib_n, max_iter=max_iter_n) #ネルダーミード法
y_p = P1.y_01(y_p) #yの値を0か1にする
x_p = P1.y_to_x(y_p) #yからxの値を代入
# for i in range(lambda_cmaes):
# x_p[i] = creator.Individual(x_p[i])
# population = x_p
fbest.extend(fbest_nelder)
vbest.extend(Vbest_nelder)
Fbest.extend(Fbest_nelder)
'''cnt = 0 #x to xc (普通のxをCMAES用のxに変換)
for i in range(P1.I*P1.N_t):
if(1 < x_p[cnt]):
x_p[cnt] -= P1.Q_t_min[0] - 1
cnt += 1
for i in range(P1.I*P1.N_s):
if(1 < x_p[cnt]):
x_p[cnt] -= P1.Q_s_min[0] - 1
cnt += 1
for i in range(P1.I):
if(1 < x_p[cnt]):
x_p[cnt] -= P1.E_g_min/P1.a_ge - 1
cnt += 1
for i in range(P1.I):
if(1 < x_p[cnt]):
x_p[cnt] -= P1.S_b_min/P1.a_b - 1
cnt += 1'''
# x_p, fbest_nelder = nelder_mead(f_n_x, np.array(x_p), step=0.1, no_improve_thr=1.0e-5, no_improv_break=100, max_iter=0) #さらにネルダーミードするなら
# The CMA-ES algorithm
strategy = cma.Strategy(centroid=x_p, sigma=0.1, lambda_=lambda_cmaes) #平均ベクトルをネルダーミードの最終解にする
toolbox.register("generate", strategy.generate, creator.Individual)
toolbox.register("update", strategy.update)
halloffame = tools.HallOfFame(1)
# halloffame_array = []
# C_array = []
# centroid_array = []
# best = np.ndarray((NGEN, N)) #世代ごとのxのベスト
for gen in range(NGEN): #ステップ開始
#新たな世代の個体群を生成
population = toolbox.generate()
if gen == 0:
population[0] = creator.Individual(x_p) #ネルダーミード法の解を混ぜる
# 個体群の評価
fitnesses = toolbox.map(toolbox.evaluate, population)
for ind, fit in zip(population, fitnesses):
ind.fitness.values = fit
# 個体群の評価から次世代の計算のためのパラメタ更新
toolbox.update(population)
# hall-of-fameの更新
halloffame.update(population)
V_c, f_c = P1.evaluate_f(halloffame[0])
fbest.append(f_c) #V, Fで入力しているときは1
vbest.append(V_c)
bestF = halloffame[0].fitness.values[0]
Fbest.append(bestF)
print("{} generation's (bestF, f, V) =({}, {}, {})".format(gen+1, bestF, f_c, V_c))
# halloffame_array.append(halloffame[0])
# C_array.append(strategy.C)
# centroid_array.append(strategy.centroid)
if (gen+1)%100 == 0:
y = []
f = [0]*P1.P
g = [0]*P1.M
h = [0]*int(P1.Q)
x = halloffame[0]# best[gen]
for n in range(P1.N_x):
if x[n] < P1.eps[0]:
y.append(0.0)
else:
y.append(1.0)
#evaluation
f, g, h = P1.evaluation(x, y, f, g, h)
#output
print(x)
print(y)
for p in range(P1.P):
print("f%d = %.10g " % (p+1, f[p]))
V = 0.0
for m in range(P1.M):
# print("g%d = %.10g" % (m+1, g[m]))
if g[m] > 0.0:
V += g[m]
for q in range(P1.Q):
# print("h%d = %.10g" % (q+1, h[q]))
abs(q)
V += abs(h[q])
#check feasibility
print('Sum of violation = {:.10g}'.format(V))
print("Tolerance = {:.2g} ".format(P1.eps[0]))
if P1.checkFeasibility(x, y):
print("Input solution is feasible.")
else:
print("Input solution is infeasible.")
#グラフ描画
x = np.arange(1, len(fbest)+1)
y = np.array(fbest)
fig = plt.figure(1)
fig.subplots_adjust(left=0.2)
plt.yscale('log')
plt.plot(x, y)
plt.xlabel("step, generation")
plt.ylabel("f")
fig.savefig("img_f.pdf")
x = np.arange(1, len(vbest)+1)
y = np.array(vbest)
fig = plt.figure(2)
fig.subplots_adjust(left=0.2)
plt.yscale('log')
plt.plot(x, y)
plt.xlabel("step, generation")
plt.ylabel("V")
fig.savefig("img_V.pdf")
x = np.arange(1, len(Fbest)+1)
y = np.array(Fbest)
fig = plt.figure(3)
fig.subplots_adjust(left=0.2)
plt.yscale('log')
plt.plot(x, y)
plt.xlabel("step, generation")
plt.ylabel("F")
fig.savefig("img_F.pdf")
def main(self, NGen=1000, NIndiv=100, DoPlot=True):
#os.system("rm png/*.png")
#random.seed(64)
#np.random.seed(64)
toolbox = self.toolbox
# pool = multiprocessing.Pool(processes=6)
# toolbox.register("map", pool.map)
self.pop = toolbox.population(n=NIndiv)
self.hof = tools.HallOfFame(1, similar=numpy.array_equal)
#self.hof = tools.ParetoFront(1, similar=numpy.array_equal)
# stats = tools.Statistics(lambda ind: ind.fitness.values)
# stats.register("avg", numpy.mean)
# stats.register("std", numpy.std)
# stats.register("min", numpy.min)
# stats.register("max", numpy.max)
for indiv in self.pop:
indiv.fill(0)
#print "Best indiv start",
#self.ArrayMethodsMachine.PM.PrintIndiv(self.IslandBestIndiv)
#print
if self.IslandBestIndiv is not None:
#SModelArrayMP,Alpha=self.ArrayMethodsMachine.DeconvCLEAN()
#AModelArrayMP=None
DicoModelMP = self.ListInitIslands[self.iIsland]
if DicoModelMP is not None:
SModelArrayMP, AModelArrayMP = DicoModelMP["S"], DicoModelMP[
"Alpha"]
else:
SModelArrayMP, _ = self.ArrayMethodsMachine.DeconvCLEAN()
AModelArrayMP = np.zeros_like(SModelArrayMP)
if NGen == 0:
self.ArrayMethodsMachine.PM.ReinitPop(self.pop,
SModelArrayMP,
AlphaModel=AModelArrayMP)
self.ArrayMethodsMachine.KillWorkers()
return self.pop[0]
if np.max(np.abs(self.IslandBestIndiv)) == 0:
#print "NEW"
self.ArrayMethodsMachine.PM.ReinitPop(self.pop,
SModelArrayMP,
AlphaModel=AModelArrayMP)
else:
#print "MIX"
NIndiv = len(self.pop) / 10
pop0 = self.pop[0:NIndiv]
pop1 = self.pop[NIndiv::]
pop1 = self.pop
pop0 = []
pop1 = self.pop[0:1]
pop0 = self.pop[1::]
# self.ArrayMethodsMachine.PM.ReinitPop(pop0,SModelArray)
# half with the best indiv
SModelArrayBest = self.ArrayMethodsMachine.PM.ArrayToSubArray(
self.IslandBestIndiv, "S")
AlphaModel = None
if "Alpha" in self.ArrayMethodsMachine.PM.SolveParam:
AlphaModel = self.ArrayMethodsMachine.PM.ArrayToSubArray(
self.IslandBestIndiv, "Alpha")
GSigModel = None
if "GSig" in self.ArrayMethodsMachine.PM.SolveParam:
GSigModel = self.ArrayMethodsMachine.PM.ArrayToSubArray(
self.IslandBestIndiv, "GSig")
self.ArrayMethodsMachine.PM.ReinitPop(pop1,
SModelArrayBest,
AlphaModel=AlphaModel,
GSigModel=GSigModel)
# half of the pop with the MP model
#SModelArrayBest0=SModelArrayBest.copy()
#mask=(SModelArrayBest0==0)
#SModelArrayBest0[mask]=SModelArrayMP[mask]
#self.ArrayMethodsMachine.PM.ReinitPop(pop0,SModelArrayBest0,AlphaModel=AlphaModel,GSigModel=GSigModel)
self.ArrayMethodsMachine.PM.ReinitPop(pop0,
SModelArrayMP,
AlphaModel=AModelArrayMP)
# _,Chi20=self.ArrayMethodsMachine.GiveFitnessPop(pop0)
# _,Chi21=self.ArrayMethodsMachine.GiveFitnessPop(pop1)
# print
# print Chi20
# print Chi21
# stop
self.pop = pop1 + pop0
#print
# if self.IslandBestIndiv is not None:
# if np.max(np.abs(self.IslandBestIndiv))==0:
# #print "deconv"
# SModelArray,Alpha=self.ArrayMethodsMachine.DeconvCLEAN()
# #print "Estimated alpha",Alpha
# AlphaModel=np.zeros_like(SModelArray)+Alpha
# #AlphaModel[SModelArray==np.max(SModelArray)]=0
# self.ArrayMethodsMachine.PM.ReinitPop(self.pop,SModelArray)#,AlphaModel=AlphaModel)
# #print self.ArrayMethodsMachine.GiveFitness(self.pop[0],DoPlot=True)
# #stop
# #print self.pop
# else:
# SModelArray=self.ArrayMethodsMachine.PM.ArrayToSubArray(self.IslandBestIndiv,"S")
# AlphaModel=None
# if "Alpha" in self.ArrayMethodsMachine.PM.SolveParam:
# AlphaModel=self.ArrayMethodsMachine.PM.ArrayToSubArray(self.IslandBestIndiv,"Alpha")
# GSigModel=None
# if "GSig" in self.ArrayMethodsMachine.PM.SolveParam:
# GSigModel=self.ArrayMethodsMachine.PM.ArrayToSubArray(self.IslandBestIndiv,"GSig")
# self.ArrayMethodsMachine.PM.ReinitPop(self.pop,SModelArray,AlphaModel=AlphaModel,GSigModel=GSigModel)
# set best Chi2
# _=self.ArrayMethodsMachine.GiveFitnessPop([self.IslandBestIndiv])
_ = self.ArrayMethodsMachine.GiveFitnessPop(self.pop)
self.pop, log = algorithms.eaSimple(
self.pop,
toolbox,
cxpb=0.3,
mutpb=0.5,
ngen=NGen,
halloffame=self.hof,
#stats=stats,
verbose=False,
ArrayMethodsMachine=self.ArrayMethodsMachine,
DoPlot=DoPlot,
MutConfig=self.MutConfig)
self.ArrayMethodsMachine.KillWorkers()
# #:param mu: The number of individuals to select for the next generation.
# #:param lambda\_: The number of children to produce at each generation.
# #:param cxpb: The probability that an offspring is produced by crossover.
# #:param mutpb: The probability that an offspring is produced by mutation.
# mu=70
# lambda_=50
# cxpb=0.3
# mutpb=0.5
# ngen=1000
# self.pop, log= algorithms.eaMuPlusLambda(self.pop, toolbox, mu, lambda_, cxpb, mutpb, ngen,
# stats=None, halloffame=None, verbose=__debug__,
# ArrayMethodsMachine=self.ArrayMethodsMachine)
V = tools.selBest(self.pop, 1)[0]
#print "Best indiv end"
#self.ArrayMethodsMachine.PM.PrintIndiv(V)
# V.fill(0)
# S=self.ArrayMethodsMachine.PM.ArrayToSubArray(V,"S")
# G=self.ArrayMethodsMachine.PM.ArrayToSubArray(V,"GSig")
# S[0]=1.
# #S[1]=2.
# G[0]=1.
# #G[1]=2.
# MA=self.ArrayMethodsMachine.PM.GiveModelArray(V)
# # print "Sum best indiv",MA.sum(axis=1)
# # print "Size indiv",V.size
# # print "indiv",V
# # print self.ArrayMethodsMachine.ListPixData
# # print MA[0,:]
return V
def evolve_weights(toolbox,
centroids,
initial_weights,
values,
ngen,
npop,
stop_after,
cxpb,
mutpb,
force,
verbose=False):
NC, ND = centroids.shape
N = len(values)
pop = [WeightIndividual(NC, ND, None) for _ in range(npop)]
for i, ind in enumerate(pop):
if i == 0:
ind.weights[:, :] = initial_weights
else:
#random
for k in range(NC):
ind.weights[k, :] = np.random.random(ND)
ind.weights[k, :] /= np.sum(ind.weights[k, :])
ind.weights[k, :] = fix_weights(ind.weights[k, :], force=force)
ind.check()
hof = tools.HallOfFame(1, similar=similar_op_weights)
stats = tools.Statistics(key=lambda ind: ind.fitness.values)
stats.register("avg", np.mean)
stats.register("min", np.min)
stats.register("max", np.max)
logbook = tools.Logbook()
logbook.header = "gen", "min", "avg", "max", "best"
#logger.info("Evaluating initial population")
# Evaluate the individuals with an invalid fitness
invalid_ind = [ind for ind in pop if not ind.fitness.valid]
fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
for ind, fit in zip(invalid_ind, fitnesses):
ind.fitness.values = fit
hof.update(pop)
record = stats.compile(pop) if stats else {}
logbook.record(gen=0, best=hof[0].fitness.values[0], **record)
if verbose: print(logbook.stream)
evaluations = 0
no_improvements = 0
#logger.info("Starting evolution!")
for gen in range(1, ngen + 1):
prev_fitness = hof[0].fitness.values[0]
# Select the next generation individuals
offspring = toolbox.select(pop, len(pop))
# Vary the pool of individuals
offspring = algorithms.varAnd(offspring, toolbox, cxpb, mutpb)
# Evaluate the individuals with an invalid fitness
invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
for ind, fit in zip(invalid_ind, fitnesses):
ind.fitness.values = fit
evals_gen = len(invalid_ind)
# Update the hall of fame with the generated individuals
if hof is not None:
hof.update(offspring)
# Replace the current population by the offspring
pop[:] = offspring
# Append the current generation statistics to the logbook
record = stats.compile(pop) if stats else {}
logbook.record(gen=gen, best=hof[0].fitness.values[0], **record)
#logger.info(logbook.stream)
if verbose: print(logbook.stream)
evaluations += evals_gen
current_fitness = hof[0].fitness.values[0]
if current_fitness >= prev_fitness:
no_improvements += 1
else:
no_improvements = 0
if no_improvements > stop_after:
break
return pop, stats, hof, logbook, gen, evaluations
def main():
# Seed our random number generator
random.seed(random.SystemRandom().random())
# We start by importing SCHEDULE.txt with each team specifics.
print("Importing team schedules")
teams_to_schedule = [] # Master list of teams to schedule
conflicting_teams = [] # Master list of teams that can't play at same time
general_population = [] # Holds our current population of schedules
with open("SCHEDULE.txt", "r") as input_file:
team_number = 1
for line in input_file:
if (len(line.strip()) == 0):
continue
single_data_line = line.strip().split("-")
schedule_write = [
] # Single line list to add to master list after setting
# String has been split. Check if we're adding 1 or 2 teams to the schedule.
# Teams with both a V and JV require two separate teams
# Each team needs a unique number, issued by team_number
if (single_data_line[1] == '1') or (single_data_line[1] == '2'):
# Single Team Case
if single_data_line[1] == '1':
single_data_line[0] = single_data_line[0] + " V"
else:
single_data_line[0] = single_data_line[0] + " JV"
# print (single_data_line[0], " has just a V or JV to play")
schedule_write.append(single_data_line[0]) # Team Name
schedule_write.append(team_number) # Unique Team Number
schedule_write.append(int(
single_data_line[1])) # 1 for V, 2 for JV
schedule_write.append(int(
single_data_line[3])) # Rank from 1-3
schedule_write.append(int(single_data_line[4])) # Start time
schedule_write.append(int(single_data_line[5])) # End time
# print ("Importing :", schedule_write)
teams_to_schedule.append(schedule_write)
cop_to_rank = [
int(single_data_line[1]),
int(single_data_line[3])
]
lvl_and_rank.append(cop_to_rank[:]) # Specify copy
elif single_data_line[1] == '3':
# Varsity and JV team, [2] will be Y if they can play at the same time
if (single_data_line[2] == 'N') or (single_data_line[2]
== 'n'):
# Add team numbers to conflict pool
add_conflict = []
add_conflict.append(team_number)
add_conflict.append(team_number + 1)
conflicting_teams.append(add_conflict)
global num_of_conflicts
num_of_conflicts += 1
# Parse rank structure for later addition to schedule_write
parsed_rank = single_data_line[3].strip().split(",")
# Create varsity team first
temp_name_string = single_data_line[0] + " V"
schedule_write.append(temp_name_string) # Team Name
schedule_write.append(team_number) # Unique Team Number
schedule_write.append(int(1)) # 1 for V, 2 for JV
schedule_write.append(int(parsed_rank[0])) # Rank from 1-3
schedule_write.append(int(single_data_line[4])) # Start time
schedule_write.append(int(single_data_line[5])) # End time
teams_to_schedule.append(schedule_write)
cop_to_rank = [int(1), int(parsed_rank[0])]
lvl_and_rank.append(cop_to_rank[:]) # Specify copy
# print ("Importing :", schedule_write)
team_number += 1 # Increment our team counter for special case
schedule_write = [] # Clear out our list to create 2nd JV team
temp_name_string = single_data_line[0] + " JV"
schedule_write.append(temp_name_string) # Team Name
schedule_write.append(team_number) # Unique Team Number
schedule_write.append(int(2)) # 1 for V, 2 for JV
schedule_write.append(int(parsed_rank[1])) # Rank from 1-3
schedule_write.append(int(single_data_line[4])) # Start time
schedule_write.append(int(single_data_line[5])) # End time
teams_to_schedule.append(schedule_write)
cop_to_rank = [int(2), int(parsed_rank[1])]
lvl_and_rank.append(cop_to_rank[:]) # Specify copy
# print ("Importing :", schedule_write)
# print (single_data_line[0], " has both V and JV to play")
else:
print("Problem with SCHEDULE.txt, please fix team named:",
single_data_line[0])
exit()
# store off current team number (also # of teams imported)
global num_of_teams
num_of_teams = team_number
# increment our team_number counter
team_number += 1
print("Import successful. Starting Genetic Algorithm.")
print("Number of teams to schedule: ", num_of_teams)
# We are done reading our file in...
# print("\n\nOur conflicting teams: ")
# print(conflicting_teams)
print("Our individual teams: ")
print(teams_to_schedule)
# Time to set up our Genetic Algo. We have a single objective for fitness,
# which is to maximize it.
creator.create("FitnessMax", base.Fitness, weights=(1.0, ))
# Our individual is a list (with nested lists, needs not be specified)
creator.create("Individual", list, fitness=creator.FitnessMax)
# Initialize our toolbox
toolbox = base.Toolbox()
# Register our individual and population, call custom individual creation function.
# Single_help is used to prevent the same ID being used, and creates individual
# hourly time slots for all courts
toolbox.register("single_help", single_slot)
toolbox.register("individual", tools.initRepeat, creator.Individual,
toolbox.single_help, tot_slots)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
# Register custom evaluate, mutate, and crossover. Use tournament selection.
toolbox.register("evaluate", calc_fitness)
toolbox.register("mate", schedule_cx)
toolbox.register("mutate", schedule_mut)
toolbox.register("select", tools.selTournament, tournsize=tour_size)
pop = toolbox.population(n=pop_size)
# References to our population are as follows:
# pop[Individual][TimeSegment][Court][TeamSide]
# eg pop[4][0][0][0] would reference the 5th individual schedule, first time
# slot, first court, and the first team scheduled for that court.
generate_schedule(pop, teams_to_schedule, conflicting_teams)
print("Initial population successfully generated")
print("Population Size: ", pop_size, " Number of Generations: ",
num_of_gens)
print("Mutation Prob: ", mutpb, " Crossover Prob: ", cxpb)
print("BEGIN GENETIC ALGORITHM")
# print("Member 1: \n", pop[0])
hof = tools.HallOfFame(1)
# After everything has been set, register stats and run gen algo
stats = tools.Statistics(lambda ind: ind.fitness.values)
stats.register("avg", numpy.mean)
stats.register("std", numpy.std)
stats.register("min", numpy.min)
stats.register("max", numpy.max)
pop, log = algorithms.eaSimple(pop,
toolbox,
cxpb=cxpb,
mutpb=mutpb,
ngen=num_of_gens,
stats=stats,
halloffame=hof,
verbose=True)
print("Best last iteration: \n", hof)
print("Level and rank: \n", lvl_and_rank)
# print("Our individual teams: ")
# print(teams_to_schedule)
return pop, log, hof
def main(celda, tbs, sinr, capacidad_data):
print("Carga ok ...ajustando variables")
tbs_run1 = tbs[celda]
tbs_run1t = np.transpose(tbs_run1)
sinr_run1 = sinr[celda]
sinr_run1t = np.transpose(sinr_run1)
#otras variables
maximo = np.max(sinr_run1t[celda])
minimo = np.min(sinr_run1t[celda])
#
multiplicador = (sinr_run1t[celda] - minimo) / maximo
#
throughput30 = np.zeros(30)
#
def eval_Throughput(individual):
for cromosoma in range(30):
throughput30[cromosoma] = int(
capacidad_data.iloc[int(tbs_run1t[celda][cromosoma]) + 1,
individual[cromosoma]])
for cromosoma in range(30):
throughput30[cromosoma] = throughput30[cromosoma] * (
multiplicador[cromosoma])
throughput = np.sum(throughput30)
recursos = np.sum(individual)
thinit = throughput
#maximo, 0,8 y 0.45
if recursos > 100:
throughput = throughput - 0.81 * throughput
if np.count_nonzero(individual) != 29:
throughput = throughput - 0.56 * throughput
return throughput,
#
creator.create("FitnessMax", base.Fitness, weights=(1.0, ))
creator.create("Individual",
array.array,
typecode='i',
fitness=creator.FitnessMax)
toolbox = base.Toolbox()
toolbox.register("indices", random.choices, range(9), k=equipos_terminales)
toolbox.register("individual", tools.initIterate, creator.Individual,
toolbox.indices)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("mate", tools.cxOrdered)
toolbox.register("mutate", tools.mutShuffleIndexes,
indpb=0.09) #antes 0.05
toolbox.register("select", tools.selTournament, tournsize=5)
#
toolbox.register("evaluate", eval_Throughput)
#start with a population of 300 individuals
pop = toolbox.population(n=300)
#only save the very best one
hof = tools.HallOfFame(1)
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)
# use one of the built in GA's with a probablilty of mating of 0.7
# a probability of mutating 0.2 and 140 generations.
algorithms.eaSimple(pop,
toolbox,
0.7,
0.2,
200,
stats=stats,
halloffame=hof) #antes 0.1
return pop, stats, hof
def evolveSteady(self):
"""
A method to evolve a species of boid using a
steady-state genetic algorithm. Method authored by
Gianni Orlando. Edited by Ryan McArdle.
:returns: the evolved species, and its fitness
"""
name = "Steady"
self.prepareEvolution()
self.eval_limit = self.eval_limit_steady
# Initialize fitness goal and individual type
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", array.array, typecode='d',fitness=creator.FitnessMax)
# Initialize individuals, populations, and evolution operators
toolbox = base.Toolbox()
toolbox.register("individual", self.initBoids, creator.Individual, *self.parameter_bounds)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("evaluate", self.boidFitness)
toolbox.register("mate", tools.cxOnePoint)
toolbox.register("mutate", tools.mutGaussian, indpb=0.5, mu=25.5, sigma=12.5) # 50% chance for each value to mutate
toolbox.register("mutate2", tools.mutShuffleIndexes, indpb=0.5) # 50% chance for each value to mutate
toolbox.register("select", tools.selTournament, tournsize= 5)
toolbox.decorate('mate', self.checkBounds(self.parameter_bounds))
toolbox.decorate('mutate', self.checkBounds(self.parameter_bounds))
toolbox.decorate('mutate2', self.checkBounds(self.parameter_bounds))
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)
self.logbook = tools.Logbook()
self.logbook.header = 'gen','evals','min','max','avg','std'
hof = tools.HallOfFame(1)
pop = toolbox.population(n=self.mu)
# Evaluate the entire population
seed = random.randint(1,1e10)
## Evaluate the entire population for fitness in parallel
if __name__=="__main__":
with mp.Pool(self.num_processes) as pool:
fitnesses = pool.starmap(self.boidFitness, [(boid.tolist(),seed,self.current_evals,self.eval_limit) for boid in pop])
for ind, fit in zip(pop, fitnesses):
ind.fitness.values = fit,
# Extracting all the fitnesses of
fits = [ind.fitness.values[0] for ind in pop]
# Variable keeping track of the number of generations
g = 0
## Record the initial population
self.current_evals += len(pop)
record = stats.compile(pop)
logbook = tools.Logbook()
logbook.header = 'gen','evals','min','max','avg','std'
logbook.record(gen=0, evals=self.current_evals, **record)
print(logbook.stream)
hof.update(pop)
print(hof[0])
print(hof[0].fitness.values[0])
# Begin the evolution
while hof[0].fitness.values[0] < 1.0 and self.current_evals < self.eval_limit:
# A new generation
g = g + 1
# Gather all the fitnesses in one list and print the stats
fits = [ind.fitness.values for ind in pop]
# Select the next generation individuals
offspring = pop
bestIndv = tools.selBest(offspring,k=2)
worstIndv = tools.selWorst(offspring,k=2)
# Clone the selected individuals
offspring = list(map(toolbox.clone, offspring))
# Apply crossover the two individuals (tournmanet
# selection)
parents = toolbox.select(offspring,2)
parent1, parent2 = parents[0], parents[1]
replace1 = offspring[offspring.index(worstIndv[0])]
replace2 = offspring[offspring.index(worstIndv[1])]
for child1, child2 in zip([parent1], [parent2]):
if random.random() < self.CXPB:
toolbox.mate(child1, child2)
if random.random() < self.MUTPB:
toolbox.mutate(child1)
del child1.fitness.values
if random.random() < self.MUTPB:
toolbox.mutate(child2)
del child2.fitness.values
if random.random() < self.MUTPB:
toolbox.mutate2(child1)
del child1.fitness.values
if random.random() < self.MUTPB:
toolbox.mutate2(child2)
del child1.fitness.values
offspring[offspring.index(replace1)] = parent1
offspring[offspring.index(replace2)] = parent2
pop[:] = offspring
# Evaluate the population with invalid fitnesses
invalid_ind = [ind for ind in pop if not ind.fitness.valid]
seed = random.randint(1,1e10)
if __name__=="__main__":
with mp.Pool(self.num_processes) as pool:
fitnesses = pool.starmap(self.boidFitness, [(boid.tolist(),seed,self.current_evals,self.eval_limit) for boid in invalid_ind])
## Apply found fitness values
for ind, fit in zip(invalid_ind, fitnesses):
ind.fitness.values = fit,
# Extracting all the fitnesses of
fits = [ind.fitness.values[0] for ind in pop]
##################################################
## Record the new generation
hof.update(pop)
record = stats.compile(pop)
self.current_evals += len(invalid_ind)
logbook.record(gen=g, evals=self.current_evals, **record)
print(logbook.stream)
print(hof[0])
print(hof[0].fitness.values[0])
#bestFit, bestDetailFit, bestFitWeight = self.boidFitness(hof[0].tolist(),seed,self.current_evals-len(invalid_ind),self.eval_limit,detail=True)
#print(bestDetailFit)
##################################################
self.plotAndRecord(logbook,hof,name)
return hof[0]
def main():
np.random.seed(64)
pop = toolbox.population(n=POPNUM)
hof = tools.HallOfFame(1)
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)
ok_count = 0
#pop,hof = algorithms.eaSimple(pop,toolbox,cxpb=0.5,mutpb=0.01,ngen=200,stats=stats,halloffame=hof,verbose=True)
fitness = list(map(toolbox.evaluate,pop))
for ind, fit in zip(pop, fitness):
ind.fitness.values = fit
#print("gen ","min ","max ","mean","std")
stop_gen = 200
for gen in range(NGEN):
# Select the next generation individuals
offspring = toolbox.select(pop, len(pop))
# Clone the selected individuals
offspring = list(map(toolbox.clone, offspring))
# Apply crossover and mutation on the offspring
for child1, child2 in zip(offspring[::2], offspring[1::2]):
# cross two individuals with probability CXPB
if random.random() < CXPB:
toolbox.mate(child1, child2)
# fitness values of the children
# must be recalculated later
del child1.fitness.values
del child2.fitness.values
for mutant in offspring:
# mutate an individual with probability MUTPB
if random.random() < MUTPB:
toolbox.mutate(mutant)
del mutant.fitness.values
# Evaluate the individuals with an invalid fitness
invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
fitness = list(map(toolbox.evaluate,invalid_ind))
for ind, fit in zip(invalid_ind, fitness):
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]
hof.update(pop)
length = len(pop)
mean = sum(fits) / length
sum2 = sum(x*x for x in fits)
std = abs(sum2 / length - mean**2)**0.5
#print(gen ,min(fits) ,max(fits) ,mean ,std)
with open('griewank.txt',mode='a') as f:
f.write(str(gen))
f.write(" ")
f.write(str(min(fits)))
f.write(" ")
f.write(str(mean))
f.write("\n")
"""
time 20.42633295059204
[-3.191757675565447, 2.158503392015575e-09, 16.294035978157076, -6.375366880774475, -7.618792813179073, 1.1405896238647264e-08, 0.00027775284370455254]
"""
if min(fits) <= np.exp(-10):
stop_gen = gen
ok_count = 1
break
return pop,hof,ok_count,stop_gen
def evolveMuCommaLambda(self,lambda_ratio=7):
"""
A method to evolve a species of boid using a
(Mu,Lambda) evolutionary strategy. Authored by Ryan
McArdle.
:returns: the best individual found by the evolution
"""
name = "muCommaLambda"+str(lambda_ratio)
self.prepareEvolution(lambda_ratio)
## Create Fitness, Individuals, and Strategy variables
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", array.array, typecode='d', fitness=creator.FitnessMax, strategy=None)
creator.create("Strategy", array.array, typecode="d")
## Sets up our evolutionary approach
toolbox = base.Toolbox()
toolbox.register('individual', self.initBoidsStrat, creator.Individual, creator.Strategy, *self.parameter_bounds, *self.strategy_bounds)
toolbox.register('population', tools.initRepeat, list, toolbox.individual)
toolbox.register("mate", tools.cxESBlend, alpha=0.333)
toolbox.register("mutate", tools.mutESLogNormal, c=1.0, indpb=1/6)
toolbox.register('select', tools.selRandom)
toolbox.register('evaluate', self.boidFitness)
toolbox.decorate('mate', self.checkBounds(self.parameter_bounds))
toolbox.decorate('mutate', self.checkBounds(self.parameter_bounds))
toolbox.decorate('mate', self.checkStrategy(self.strategy_bounds))
toolbox.decorate('mutate', self.checkStrategy(self.strategy_bounds))
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)
self.logbook = tools.Logbook()
self.logbook.header = 'gen','evals','min','max','avg','std'
hof = tools.HallOfFame(1)
## Initializes the population with n individuals
g = 0
pop = toolbox.population(n=self.mu)
seed = random.randint(1,1e10)
## Evaluate the entire population for fitness in parallel
if __name__=="__main__":
with mp.Pool(self.num_processes) as pool:
fitnesses = pool.starmap(self.boidFitness, [(boid.tolist(),seed,self.current_evals,self.eval_limit) for boid in pop])
## Apply fitness values
for ind, fit in zip(pop, fitnesses):
ind.fitness.values = fit,
## Record initial population in stats logbook
self.current_evals += len(pop)
record = stats.compile(pop)
logbook = tools.Logbook()
logbook.header = 'gen','evals','min','max','avg','std'
logbook.record(gen=0, evals=self.current_evals, **record)
print(logbook.stream)
hof.update(pop)
print(hof[0])
print(hof[0].fitness.values[0])
## Loop for each generation until stopping criteria
while self.current_evals < (self.eval_limit - self.lambda_):
g+=1
## Select the next generation individuals
offspring = toolbox.select(pop, self.lambda_)
## Clone the selected individuals
offspring = list(map(toolbox.clone, offspring))
## Apply crossover and mutation on the offspring
for child1, child2 in zip(offspring[::2], offspring[1::2]):
if random.random() < self.CXPB:
toolbox.mate(child1, child2)
del child1.fitness.values
del child2.fitness.values
for mutant in offspring:
if random.random() < self.MUTPB:
toolbox.mutate(mutant)
del mutant.fitness.values
## Evaluate the individuals with an invalid fitness
invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
seed = random.randint(1,1e10)
if __name__=="__main__":
with mp.Pool(self.num_processes) as pool:
fitnesses = pool.starmap(self.boidFitness, [(boid.tolist(),seed,self.current_evals,self.eval_limit) for boid in invalid_ind])
## Apply found fitness values
for ind, fit in zip(invalid_ind, fitnesses):
ind.fitness.values = fit,
##### MuPlusLambda
### New generation
#new_gen = list(map(toolbox.clone, [*pop,*offspring]))
### Sort the new generation by fitness
#new_gen.sort(key=lambda x: x.fitness.values[0])
### Replace population with top mu of new generation
#pop = list(map(toolbox.clone, new_gen[-self.mu:]))
#####
#### MuCommaLambda
## Sort the new generation by fitness
offspring.sort(key=lambda x: x.fitness.values[0])
## Replace population with top mu of new generation
pop = list(map(toolbox.clone, offspring[-self.mu:]))
####
##################################################
## Record the new generation
hof.update(pop)
record = stats.compile(pop)
self.current_evals += len(invalid_ind)
logbook.record(gen=g, evals=self.current_evals, **record)
print(logbook.stream)
print(hof[0])
print(hof[0].fitness.values[0])
#bestFit, bestDetailFit, bestFitWeight = self.boidFitness(hof[0].tolist(),seed,self.current_evals-len(invalid_ind),self.eval_limit,detail=True)
#print(bestDetailFit)
##################################################
self.plotAndRecord(logbook,hof,name)
return hof[0]
def search_expression(input_values,
output_values,
pset,
max_height=50,
population_size=10,
cxpb=0.5,
mutpb=0.1,
num_evals_limit=500,
leading_at_0=None,
leading_at_inf=None,
hard_penalty_default_value=None,
include_leading_powers=False,
default_value=50.):
"""Searches expression using evolutionary algorithm.
Args:
input_values: Numpy array with shape [num_input_values]. List of input
values to univariate function.
output_values: Numpy array with shape [num_output_values]. List of output
values from the univariate function.
pset: deap.gp.PrimitiveSet.
max_height: Integer, the max value of the height of tree.
population_size: Integer, the size of population.
cxpb: Float, the probability of mating two individuals.
mutpb: Float, the probability of mutating an individual.
num_evals_limit: Integer, the limit of the number of evaluations.
leading_at_0: Float, desired leading power at 0.
leading_at_inf: Float, desired leading power at inf.
hard_penalty_default_value: Float, the default value for hard penalty.
Default None, the individual will be evaluated by soft penalty instead
of hard penalty.
include_leading_powers: Boolean, whether to include leading powers in
evaluation.
default_value: Float, default value if leading power error is nan.
Returns:
individual: creator.Individual, the best individual in population.
toolbox: deap.base.Toolbox, it contains the evolution operators.
"""
toolbox = get_toolbox(pset, max_height)
toolbox.register('evaluate',
evaluate_individual,
input_values=input_values,
output_values=output_values,
toolbox=toolbox,
leading_at_0=leading_at_0,
leading_at_inf=leading_at_inf,
hard_penalty_default_value=hard_penalty_default_value,
include_leading_powers=include_leading_powers,
default_value=default_value)
population = toolbox.population(n=population_size)
halloffame = tools.HallOfFame(1)
evolutionary_algorithm_with_num_evals_limit(
population=population,
toolbox=toolbox,
cxpb=cxpb,
mutpb=mutpb,
num_evals_limit=num_evals_limit,
halloffame=halloffame)
return halloffame[0], toolbox
def main(args):
global SUPERVISED, NO_SUB_IND, toolbox
#For elitism, at least the best individual
#is recorded
NO_ELI = (int)(POP_SIZE * GP_ELI)
if NO_ELI < 10:
NO_ELI = 10
filename = "iteration"+str(args[0])+".txt"
file = open(filename,'w+')
run_index = int(args[0])
supervised = int(args[1])
if supervised == 0:
SUPERVISED = False
else:
SUPERVISED = True
#setWeight()
NO_SUB_IND = int(args[2])
toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.sub_individual, n=NO_SUB_IND)
toolbox.register("population", tools.initRepeat, list, toolbox.individual, n=POP_SIZE)
random.seed(1617**2*run_index)
#FitnessFunction.setWeight(src_feature=Core.src_feature, src_label=Core.src_label,
# tarU_feature=Core.tarU_feature, tarU_label=Core.tarU_soft_label)
time_start = time.clock()
pop = toolbox.population()
hof = tools.HallOfFame(NO_ELI)
#evaluate the population
fitness = toolbox.map(toolbox.evaluate, pop)
for ind, fit in zip(pop, fitness):
ind.fitness.values = fit
#Update the HoF
hof.update(pop)
towrite = "Supervised: %r \n" \
"Number of sub tree: %d\n" \
"Source weight: %f\n" \
"Diff source and target weight: %f\n" \
"Target weight: %g \n" % (SUPERVISED, NO_SUB_IND,
FitnessFunction.srcWeight,
FitnessFunction.margWeight,
FitnessFunction.tarWeight)
for gen in range(NGEN):
print(gen)
towrite = towrite + ("----Generation %i -----\n" %gen)
#Select the next generation individuals
#Leave space for elitism
offspringS = toolbox.select(pop, len(pop)-NO_ELI)
# Clone the selected individuals
offspring = [toolbox.clone(ind) for ind in offspringS]
#go through each individual
for i in range(1, len(offspring), 2):
if random.random() < GP_CXPB:
#perform crossover for all the features
first = offspring[i-1]
second = offspring[i]
first, second = crossoverEach(first, second)
del first.fitness.values
del second.fitness.values
for i in range(len(offspring)):
if random.random() < GP_MUTBP:
parent = pop[i]
for j in range(1, len(parent)):
if random.random() < GP_MUTSUB:
parent[j] = toolbox.mutate(parent[j])
del parent.fitness.values
#Now put HOF back to offspring
for ind in hof:
offspring.append(toolbox.clone(ind))
# Evaluate the individuals with an invalid fitness
invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
for ind, fit in zip(invalid_ind, fitnesses):
ind.fitness.values = fit
#Now update the hof for the next iteration
hof.update(offspring)
pop[:] = offspring
# Gather all the fitnesses in one list and print the stats
fits = [ind.fitness.values[0] for ind in pop]
length = len(pop)
mean = sum(fits) / length
sum2 = sum(x*x for x in fits)
std = abs(sum2 / length - mean**2)**0.5
towrite = towrite + (" Min %s\n" % min(fits))
towrite = towrite + (" Max %s\n" % max(fits))
towrite = towrite + (" Avg %s\n" % mean)
towrite = towrite + (" Std %s\n" % std)
bestInd = hof[0]
funcs = [toolbox.compile(expr=tree) for tree in bestInd]
src_feature = GPUtility.buildNewFeatures(Core.src_feature, funcs)
tarU_feature = GPUtility.buildNewFeatures(Core.tarU_feature, funcs)
tarL_feature = GPUtility.buildNewFeatures(Core.tarL_feature, funcs)
if SUPERVISED:
src_err, diff_marg, tar_err = FitnessFunction.domain_differece(src_feature=src_feature, src_label=Core.src_label,
classifier=Core.classifier,
tarU_feature=tarU_feature, tarU_soft_label=Core.tarU_soft_label,
tarL_feature=tarL_feature, tarL_label=Core.tarL_label)
else:
src_err, diff_marg, tar_err = FitnessFunction.domain_differece(src_feature=src_feature, src_label=Core.src_label,
classifier=Core.classifier,
tarU_feature=tarU_feature, tarU_soft_label=Core.tarU_soft_label)
towrite = towrite + (" Source Error: %f \n Diff Marg: %f \n Target Error: %f \n" %(src_err, diff_marg, tar_err))
acc = 1.0 - FitnessFunction.classification_error(training_feature=src_feature, training_label=Core.src_label,
classifier=Core.classifier,
testing_feature=tarU_feature, testing_label=Core.tarU_label)
towrite = towrite + (" Accuracy on unlabel target: "+str(acc) + "\n")
# Update the pseudo label and weight
Core.classifier.fit(src_feature, Core.src_label)
Core.tarU_soft_label = Core.classifier.predict(tarU_feature)
#FitnessFunction.setWeight(Core.src_feature, Core.src_label, Core.tarU_feature, Core.tarU_SoftLabel)
time_elapsed = (time.clock() - time_start)
#process the result
bestInd = hof[0]
towrite = towrite + "----Final -----\n"
funcs = [toolbox.compile(expr=tree) for tree in bestInd]
src_feature = GPUtility.buildNewFeatures(Core.src_feature, funcs)
tarU_feature = GPUtility.buildNewFeatures(Core.tarU_feature, funcs)
acc = 1.0 - FitnessFunction.classification_error(training_feature=src_feature, training_label=Core.src_label,
classifier=Core.classifier,
testing_feature=tarU_feature, testing_label=Core.tarU_label)
towrite = towrite + ("Accuracy on the target (TL): %f\n" % acc)
towrite = towrite + "Accuracy on the target (No TL): %f\n" % (
1.0 - FitnessFunction.classification_error(training_feature=Core.src_feature, training_label=Core.src_label,
classifier=Core.classifier,
testing_feature=Core.tarU_feature, testing_label=Core.tarU_label))
towrite = towrite + ("Computation time: %f\n" % time_elapsed)
towrite = towrite + ("Number of features: %d\n" % len(bestInd))
file.write(towrite)
file.close()
def main():
# Initialize dictionary to keep track of Hall Of Fame (HOF) data
hofData = {}
for oneName in NAME_TO_FACTOR:
hofData[oneName] = []
# Keep track of HOF over time, so that we can evaluate efficiency over different pT ranges
bestIndividuals = []
# Data for plotting efficiency as a function of pT
pTCutData = {}
for i, cut in enumerate(PT_CUTS):
cutRange = 0, 100
if i == len(PT_CUTS) - 1:
cutRange = cut, 12345
else:
cutRange = cut, PT_CUTS[i + 1]
pTCutData[cutRange] = []
# Objects to keep track of seeding algorithm metrics for HOF
scores = []
efficiencies = []
fakeRateList = []
dupRateList = []
# Objects that will compile the data for population graphs
logbook = tools.Logbook()
popData = {}
popData["Score"] = tools.Statistics(key=lambda ind: ind.fitness.values[0])
popData["Efficiency"] = tools.Statistics(
key=lambda ind: ind.fitness.values[1])
popData["FakeRate"] = tools.Statistics(
key=lambda ind: ind.fitness.values[2])
popData["DuplicateRate"] = tools.Statistics(
key=lambda ind: ind.fitness.values[3])
for oneName in NAME_TO_FACTOR:
popData[oneName] = tools.Statistics(
key=lambda ind: ind[NAME_TO_INDEX[oneName]])
# mstats = tools.MultiStatistics(popData)
# mstats = tools.MultiStatistics(Score=popData["Score"], Efficiency=popData["Efficiency"], FakeRate=popData["FakeRate"], DuplicateRate=popData["DuplicateRate"], sigmaScattering=popData["sigmaScattering"],
# maxSeedsPerSpM=popData["maxSeedsPerSpM"], maxPt=popData["maxPt"], impactMax=popData["impactMax"], deltaRMax=popData["deltaRMax"], deltaRMin=popData["deltaRMin"], radLengthPerSeed=popData["radLengthPerSeed"])
stats_score = tools.Statistics(key=lambda ind: ind.fitness.values[0])
stats_eff = tools.Statistics(key=lambda ind: ind.fitness.values[1])
stats_fake = tools.Statistics(key=lambda ind: ind.fitness.values[2])
stats_dup = tools.Statistics(key=lambda ind: ind.fitness.values[3])
stats_sigmaScattering = tools.Statistics(
key=lambda ind: ind[NAME_TO_INDEX["sigmaScattering"]])
stats_maxSeedsPerSPM = tools.Statistics(
key=lambda ind: ind[NAME_TO_INDEX["maxSeedsPerSpM"]])
stats_maxPt = tools.Statistics(key=lambda ind: ind[NAME_TO_INDEX["maxPt"]])
stats_impactMax = tools.Statistics(
key=lambda ind: ind[NAME_TO_INDEX["impactMax"]])
stats_deltaRMin = tools.Statistics(
key=lambda ind: ind[NAME_TO_INDEX["deltaRMin"]])
stats_deltaRMax = tools.Statistics(
key=lambda ind: ind[NAME_TO_INDEX["deltaRMax"]])
stats_radLengthPerSeed = tools.Statistics(
key=lambda ind: ind[NAME_TO_INDEX["radLengthPerSeed"]])
mstats = tools.MultiStatistics(Score=stats_score,
Efficiency=stats_eff,
FakeRate=stats_fake,
DuplicateRate=stats_dup,
sigmaScattering=stats_sigmaScattering,
maxSeedsPerSpM=stats_maxSeedsPerSPM,
maxPt=stats_maxPt,
impactMax=stats_impactMax,
deltaRMax=stats_deltaRMax,
deltaRMin=stats_deltaRMin,
radLengthPerSeed=stats_radLengthPerSeed)
mstats.register("avg", np.mean)
mstats.register("std", np.std)
mstats.register("min", np.min)
mstats.register("max", np.max)
hof = tools.HallOfFame(1)
# initialize NPOP copies of initial guess
pop = toolbox.population_guess()
indPrint(pop[0])
firstFit = toolbox.evaluate(pop[0])
print(firstFit)
for ind in pop:
ind.fitness.values = firstFit
g = 0
bestEff = 0
bestDup = 20
bestFake = 100
# Stop condition is that the efficiency is greater than 99.4, duplicate % is less than 60, and fakerate is less than 10%
# or the number of generations reaches NGEN (100).
while g < NGEN and ((bestEff < 99.4) or bestDup > 60 or bestFake > 10):
g = g + 1
print("-- Generation %i --" % g)
# Select the next generation individuals
offspring = toolbox.select(pop, len(pop))
# Clone the selected individuals
offspring = list(map(toolbox.clone, offspring))
# Apply mutation on the offspring
maxMutants = 16
mutantsCount = 1
numParamsDiffCount = [] # for debugging
for i, mutant in enumerate(offspring):
prevInd = []
for j in range(len(mutant)):
prevInd.append(mutant[j])
if mutantsCount == maxMutants:
break # I only have 16 cores so evaluating more individuals will slow down
if random.random() < MUTPB:
mutantsCount += 1
toolbox.mutate(mutant)
numMutatedParams = 0
for j in range(len(mutant)): # for debugging
if prevInd[j] != mutant[j]:
numMutatedParams += 1
del mutant.fitness.values
numParamsDiffCount.append(numMutatedParams)
print(
f"List of # of mutated params in each individual: {numParamsDiffCount}"
)
# Evaluate the individuals with an invalid fitness (the mutated individuals)
invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
print(f"Evaluating {len(invalid_ind)} individuals...")
fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
# Print and store data
toPrint = 1
printCounter = 0
for ind, fit in zip(invalid_ind, fitnesses):
ind.fitness.values = fit
if (printCounter < 1 and fit[1] == -1):
print("This ind broke the seeding algo")
indPrint(
ind
) # print first toPrint individual(s) that cause seedingalgo to break
printCounter += 1
pop[:] = offspring
hof.update(pop)
# Gather all the fitnesses in one list and print the stats
scoreList = [ind.fitness.values[0] for ind in pop]
effs = [ind.fitness.values[1] for ind in pop]
fakeRates = [ind.fitness.values[2] for ind in pop]
dupRates = [ind.fitness.values[3] for ind in pop]
length = len(pop)
mean = sum(effs) / length
print("Efficiency:")
printStats(effs, length, "Percent")
print("Duplicate Rate:")
printStats(dupRates, length, "Percent")
print("Fake Rate:")
printStats(fakeRates, length, "Percent")
print("The best one so far:", end=" ")
# record data for analyzing best individual
goodOne = hof[0]
bestIndividuals.append(goodOne)
for oneName in hofData:
paramVal = goodOne[
NAME_TO_INDEX[oneName]] * NAME_TO_FACTOR[oneName]
if oneName == "maxSeedsPerSpM":
hofData[oneName].append(int(paramVal))
else:
hofData[oneName].append(paramVal)
scores.append(goodOne.fitness.values[0])
bestEff = goodOne.fitness.values[1]
efficiencies.append(bestEff)
bestFake = goodOne.fitness.values[2]
fakeRateList.append(bestFake)
bestDup = goodOne.fitness.values[3]
dupRateList.append(bestDup)
indPrint(goodOne)
print("Best score (Score, efficiency, fakeRate, dupRate):", end=" ")
print(goodOne.fitness.values)
# record data for analyzing the population
logbook.record(gen=g, **mstats.compile(pop))
# record efficiency over different pT ranges
for cutRange in pTCutData:
cutRangeInputs = []
for goodOne in bestIndividuals:
names, params = createNamesAndParams(goodOne)
names.append("fltPrtPtMin")
params.append(cutRange[0])
names.append("fltPrtPtMax")
params.append(cutRange[1])
args = paramsToInput(params, names)
cutRangeInputs.append(args)
print(f"Evaluating pT range {cutRange}")
avgScores = toolbox.map(executeAlg, cutRangeInputs)
for avgScore in avgScores:
pTCutData[cutRange].append(avgScore["efficiency"])
plotPtRange(pTCutData)
# Make plots for the population
for oneName in NAME_TO_FACTOR:
#print("Length of data is " + str(len(logbook.chapters[oneName].select("max"))))
plotLogbook("Score", oneName, logbook)
plotLogbook("Efficiency", oneName, logbook)
plotLogbook("DuplicateRate", oneName, logbook)
plotLogbook("FakeRate", oneName, logbook)
# Make plots for the best individual
for oneName in hofData:
plotHOF("Score", scores, oneName, hofData[oneName])
plotHOF("Efficiency", efficiencies, oneName, hofData[oneName])
plotHOF("DuplicateRate", dupRateList, oneName, hofData[oneName])
plotHOF("FakeRate", fakeRateList, oneName, hofData[oneName])
# Plot the score, efficiency, dupliceate rate and fake rate all here
plotScores(efficiencies, fakeRateList, dupRateList)
print(f"Wrote plots to {plotDirectory}")
return logbook, hof
def main():
with open('data.csv') as csvfile:
readCSV = csv.reader(csvfile, delimiter=',')
for row in readCSV:
nCheckboard = int(row[0])
mCheckboard = int(row[1])
sizesel = int(row[2])
populSize = int(row[3])
numgen = int(row[4])
# Get the cardinalities from the second line of data.csv
row = next(readCSV)
for line in range(len(row)):
cardinalities.append(int(row[line]))
print(cardinalities)
# Dimensions of the checkboard which determine the size of the individual
numberOfVariables = nCheckboard * mCheckboard
creator.create("FitnessMax", base.Fitness, weights=(1.0, ))
creator.create("Individual",
array.array,
typecode='b',
fitness=creator.FitnessMax)
toolbox = base.Toolbox()
# Structure initializers
toolbox.register("individual", initRepeatWithCardinalities,
creator.Individual, randomUnderCardinality,
int(nCheckboard) * int(mCheckboard))
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("evaluate",
bd.evalCheckboardNeighbours,
nCB=nCheckboard,
mCB=nCheckboard)
toolbox.register("select", tools.selBest)
random.seed(64)
pop = toolbox.population(n=populSize)
hof = tools.HallOfFame(1)
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)
pop, log = ad.treeEDA(pop,
toolbox,
sizesel,
cardinalities,
ngen=numgen,
stats=stats,
halloffame=hof,
vbse=True)
return pop, log, hof
creator.create("FitnessMax", base.Fitness, weights=(-1.0, ))
creator.create("Individual", list, fitness=creator.FitnessMax)
toolbox = base.Toolbox()
toolbox.register("attr_bool", random.randint, 0, 4)
toolbox.register("individual", tools.initRepeat, creator.Individual,
toolbox.attr_bool, MAX_MOVES)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("evaluate", evalMaze)
toolbox.register("mutate", tools.mutUniformInt, indpb=0.05, low=0, up=4)
toolbox.register("mate", tools.cxOnePoint)
toolbox.register("select", tools.selTournament, tournsize=3)
pop = toolbox.population(n=500)
hof1 = tools.HallOfFame(1)
pop, log = algorithms.eaSimple(pop,
toolbox,
cxpb=0.50,
mutpb=0.25,
ngen=50,
halloffame=hof1,
verbose=False)
first_agent = hof1[0]
print(hof1[0])
pop2 = toolbox.population(n=500)
hof2 = tools.HallOfFame(1)
def main(verbose=True):
NRESTARTS = 10 # Initialization + 9 I-POP restarts
SIGMA0 = 2.0 # 1/5th of the domain [-5 5]
toolbox = base.Toolbox()
toolbox.register("evaluate", benchmarks.rastrigin)
halloffame = tools.HallOfFame(1)
stats = tools.Statistics(lambda ind: ind.fitness.values)
stats.register("avg", numpy.mean)
stats.register("std", numpy.std)
stats.register("min", numpy.min)
stats.register("max", numpy.max)
logbooks = list()
nsmallpopruns = 0
smallbudget = list()
largebudget = list()
lambda0 = 4 + int(3 * numpy.log(N))
regime = 1
i = 0
while i < (NRESTARTS + nsmallpopruns):
# The first regime is enforced on the first and last restart
# The second regime is run if its allocated budget is smaller than the allocated
# large population regime budget
if i > 0 and i < (NRESTARTS + nsmallpopruns) - 1 and sum(smallbudget) < sum(largebudget):
lambda_ = int(lambda0 * (0.5 * (2**(i - nsmallpopruns) * lambda0) / lambda0)**(numpy.random.rand()**2))
sigma = 2 * 10**(-2 * numpy.random.rand())
nsmallpopruns += 1
regime = 2
smallbudget += [0]
else:
lambda_ = 2**(i - nsmallpopruns) * lambda0
sigma = SIGMA0
regime = 1
largebudget += [0]
t = 0
# Set the termination criterion constants
if regime == 1:
MAXITER = 100 + 50 * (N + 3)**2 / numpy.sqrt(lambda_)
elif regime == 2:
MAXITER = 0.5 * largebudget[-1] / lambda_
TOLHISTFUN = 10**-12
TOLHISTFUN_ITER = 10 + int(numpy.ceil(30. * N / lambda_))
EQUALFUNVALS = 1. / 3.
EQUALFUNVALS_K = int(numpy.ceil(0.1 + lambda_ / 4.))
TOLX = 10**-12
TOLUPSIGMA = 10**20
CONDITIONCOV = 10**14
STAGNATION_ITER = int(numpy.ceil(0.2 * t + 120 + 30. * N / lambda_))
NOEFFECTAXIS_INDEX = t % N
equalfunvalues = list()
bestvalues = list()
medianvalues = list()
mins = deque(maxlen=TOLHISTFUN_ITER)
# We start with a centroid in [-4, 4]**D
strategy = cma.Strategy(centroid=numpy.random.uniform(-4, 4, N), sigma=sigma, lambda_=lambda_)
toolbox.register("generate", strategy.generate, creator.Individual)
toolbox.register("update", strategy.update)
logbooks.append(tools.Logbook())
logbooks[-1].header = "gen", "evals", "restart", "regime", "std", "min", "avg", "max"
conditions = {"MaxIter" : False, "TolHistFun" : False, "EqualFunVals" : False,
"TolX" : False, "TolUpSigma" : False, "Stagnation" : False,
"ConditionCov" : False, "NoEffectAxis" : False, "NoEffectCoor" : False}
# Run the current regime until one of the following is true:
## Note that the algorithm won't stop by itself on the optimum (0.0 on rastrigin).
while not any(conditions.values()):
# Generate a new population
population = toolbox.generate()
# Evaluate the individuals
fitnesses = toolbox.map(toolbox.evaluate, population)
for ind, fit in zip(population, fitnesses):
ind.fitness.values = fit
halloffame.update(population)
record = stats.compile(population)
logbooks[-1].record(gen=t, evals=lambda_, restart=i, regime=regime, **record)
if verbose:
print((logbooks[-1].stream))
# Update the strategy with the evaluated individuals
toolbox.update(population)
# Count the number of times the k'th best solution is equal to the best solution
# At this point the population is sorted (method update)
if population[-1].fitness == population[-EQUALFUNVALS_K].fitness:
equalfunvalues.append(1)
# Log the best and median value of this population
bestvalues.append(population[-1].fitness.values)
medianvalues.append(population[int(round(len(population)/2.))].fitness.values)
# First run does not count into the budget
if regime == 1 and i > 0:
largebudget[-1] += lambda_
elif regime == 2:
smallbudget[-1] += lambda_
t += 1
STAGNATION_ITER = int(numpy.ceil(0.2 * t + 120 + 30. * N / lambda_))
NOEFFECTAXIS_INDEX = t % N
if t >= MAXITER:
# The maximum number of iteration per CMA-ES ran
conditions["MaxIter"] = True
mins.append(record["min"])
if (len(mins) == mins.maxlen) and max(mins) - min(mins) < TOLHISTFUN:
# The range of the best values is smaller than the threshold
conditions["TolHistFun"] = True
if t > N and sum(equalfunvalues[-N:]) / float(N) > EQUALFUNVALS:
# In 1/3rd of the last N iterations the best and k'th best solutions are equal
conditions["EqualFunVals"] = True
if all(strategy.pc < TOLX) and all(numpy.sqrt(numpy.diag(strategy.C)) < TOLX):
# All components of pc and sqrt(diag(C)) are smaller than the threshold
conditions["TolX"] = True
# Need to transfor strategy.diagD[-1]**2 from pyp/numpy.float64 to python
# float to avoid OverflowError
if strategy.sigma / sigma > float(strategy.diagD[-1]**2) * TOLUPSIGMA:
# The sigma ratio is bigger than a threshold
conditions["TolUpSigma"] = True
if len(bestvalues) > STAGNATION_ITER and len(medianvalues) > STAGNATION_ITER and \
numpy.median(bestvalues[-20:]) >= numpy.median(bestvalues[-STAGNATION_ITER:-STAGNATION_ITER + 20]) and \
numpy.median(medianvalues[-20:]) >= numpy.median(medianvalues[-STAGNATION_ITER:-STAGNATION_ITER + 20]):
# Stagnation occured
conditions["Stagnation"] = True
if strategy.cond > 10**14:
# The condition number is bigger than a threshold
conditions["ConditionCov"] = True
if all(strategy.centroid == strategy.centroid + 0.1 * strategy.sigma * strategy.diagD[-NOEFFECTAXIS_INDEX] * strategy.B[-NOEFFECTAXIS_INDEX]):
# The coordinate axis std is too low
conditions["NoEffectAxis"] = True
if any(strategy.centroid == strategy.centroid + 0.2 * strategy.sigma * numpy.diag(strategy.C)):
# The main axis std has no effect
conditions["NoEffectCoor"] = True
stop_causes = [k for k, v in list(conditions.items()) if v]
print(("Stopped because of condition%s %s" % ((":" if len(stop_causes) == 1 else "s:"), ",".join(stop_causes))))
i += 1
return halloffame
def main():
random.seed(1)
pop = toolbox.population(n=250)
hof = tools.HallOfFame(1)
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)
#pop,log = algorithms.eaSimple(pop,toolbox,cxpb=0.5,mutpb=0.2,ngen=300,stats=stats,halloffame=hof,verbose=True)
for i in range(NGEN):
# Select the next generation individuals
offspring = toolbox.select(pop, len(pop))
# Clone the selected individuals
offspring = list(map(toolbox.clone, offspring))
# Apply crossover and mutation on the offspring
for child1, child2 in zip(offspring[::2], offspring[1::2]):
# cross two individuals with probability CXPB
if random.random() < CXPB:
toolbox.mate(child1, child2)
# fitness values of the children
# must be recalculated later
del child1.fitness.values
del child2.fitness.values
for mutant in offspring:
# mutate an individual with probability MUTPB
if random.random() < MUTPB:
toolbox.mutate(mutant)
del mutant.fitness.values
# Evaluate the individuals with an invalid fitness
invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
fitness = list(map(toolbox.evaluate, invalid_ind))
for ind, fit in zip(invalid_ind, fitness):
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]
hof.update(pop)
length = len(pop)
mean = sum(fits) / length
sum2 = sum(x * x for x in fits)
std = abs(sum2 / length - mean**2)**0.5
#print("gen:",i," Min %s" % min(fits)," Max %s" % max(fits)," Avg %s" % mean," Std %s" % std)
print(i, max(fits), mean)
with open('CartPole-v2.txt', mode='a') as f:
f.write(str(i))
f.write(" ")
f.write(str(max(fits)))
f.write(" ")
f.write(str(mean))
f.write("\n")
"""
if i%50 == 0:
with open('gen'+str(i)+'checkpoint_maxstepsliner_hardcore','wb') as fp:
pickle.dump(pop,fp)
"""
return pop, log, hof
return toolbox
if __name__ == "__main__":
# Problem size
num_individuals = 10
num_generations = 125
# Create a strategy using CMA-ES algorithm
strategy = cma.Strategy(centroid=[5.0]*num_individuals, sigma=5.0,
lambda_=20*num_individuals)
# Create toolbox based on the above strategy
toolbox = create_toolbox(strategy)
# Create hall of fame object
hall_of_fame = tools.HallOfFame(1)
# Register the relevant stats
stats = tools.Statistics(lambda x: x.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", "evals", "std", "min", "avg", "max"
# Objects that will compile the data
sigma = np.ndarray((num_generations, 1))
axis_ratio = np.ndarray((num_generations, 1))
diagD = np.ndarray((num_generations, num_individuals))
def create_new_features(X, Y, n=4):
def hellinger(individual, X, Y):
func = toolbox.compile(expr=individual)
X0 = X[Y == -1]
X1 = X[Y == 1]
genX0 = np.array([func(*X0[i]) for i in range(X0.shape[0])])
genX1 = np.array([func(*X1[i]) for i in range(X1.shape[0])])
genX = np.array([func(*X[i]) for i in range(X.shape[0])])
X0_all = np.all(genX0[0] == genX0)
X1_all = np.all(genX1[0] == genX1)
# genX = np.linspace(np.min(genX), np.max(genX), 10000)
# print(gp.PrimitiveTree(individual))
# print(genX0)
# print(genX1)
if X0_all:
k0 = np.vectorize(lambda x: 1 if x == genX0[0] else 0)
else:
k0 = ss.gaussian_kde(genX0)
if X1_all:
k1 = np.vectorize(lambda x: 1 if x == genX1[0] else 0)
else:
k1 = ss.gaussian_kde(genX1)
p_x0 = k0(genX)
p_x0 = p_x0 / np.sum(p_x0)
p_x1 = k1(genX)
p_x1 = p_x1 / np.sum(p_x1)
# p_y0 = X0.shape[0] / (X0.shape[0] + X1.shape[0])
# p_y1 = X1.shape[0] / (X0.shape[0] + X1.shape[0])
# p_x = (p_y0 * p_x0) + (p_y1 * p_x1)
# p_y0x = (p_x0 * p_y0) / p_x
# p_y1x = (p_x1 * p_y1) / p_x
# print('-'*79)
# print(np.sum(p_x0))
# print(np.sum(p_x1))
# print((p_x0 * p_y0).shape)
# print(p_x.shape)
# print(p_x0[0])
# print(p_x[0])
# print(p_y0x[0])
# print(np.sum(p_x))
# print(np.sum(p_y0x))
# print(np.sum(p_y1x))
# print('-'*79)
# dist = np.sqrt(np.sum(np.square(np.sqrt(p_y0x) - np.sqrt(p_y1x))))
dist = np.sqrt(np.sum(np.square(np.sqrt(p_x0) - np.sqrt(p_x1))))
return dist,
toolbox.register('evaluate', hellinger, Y=Y, X=X)
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))
pop = toolbox.population(n=300)
hof = tools.HallOfFame(n)
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, log = algorithms.eaSimple(pop,
toolbox,
0.8,
0.1,
20,
stats=mstats,
halloffame=hof,
verbose=True)
features_expr = [str(gp.PrimitiveTree(ind)) for ind in hof]
features_func = [toolbox.compile(expr=ind) for ind in hof]
return features_expr, features_func, str(log)
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)
# Run algoritm
pop = toolbox.population(n=300)
hof = tools.HallOfFame(5)
pop, log = algorithms.eaSimple(pop,
toolbox,
0.5,
0.1,
1000,
stats=mstats,
halloffame=hof,
verbose=True)
#print(log)
# Display solutions as function code and score
for solution in hof:
tree = gp.PrimitiveTree(solution)
print('Program:', str(tree), 'Scores:', solution.fitness)
def fit(self, X, y):
print(
f'fit(): pop_size={self.pop_size}, n_gen={self.n_gen}, cxpb={self.cxpb}, mutpb={self.mutpb},',
f'n_sim={self.n_sim}, max_time={self.max_time}')
# The primitives of the tree and their arities.
pset = gp.PrimitiveSet("main", 4, prefix='x')
pset.renameArguments(x0='dz', x1='temp', x2='hum', x3='wind')
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)
# Issue: log fails when passed negative numbers.
# pset.addPrimitive(math.log, 1)
# Ephemeral constants randomly generate constants to be inserted into trees
pset.addEphemeralConstant("randunif", ephemeral_uniform)
pset.addEphemeralConstant("randnorm", ephemeral_normal)
# HACK: sklearn.model_selection.GridSearchCV calls fit multiple times in parallel.
# creator complains when creating the same class multiple times.
# checking to see if the class exists already, while addressing race conditions, fixes the problem.
if not hasattr(creator, 'FitnessMax'):
creator.create("FitnessMax", base.Fitness, weights=(1.0, ))
# HACK: sklearn.model_selection.GridSearchCV calls fit multiple times in parallel.
# creator complains when creating the same class multiple times.
# checking to see if the class exists already, while addressing race conditions, fixes the problem.
if not hasattr(creator, 'Individual'):
creator.create("Individual",
gp.PrimitiveTree,
fitness=creator.FitnessMax,
pset=pset)
toolbox = base.Toolbox()
toolbox.register("expr", gp.genFull, pset=pset, min_=1, max_=3)
toolbox.register("individual", tools.initIterate, creator.Individual,
toolbox.expr)
toolbox.register("population", tools.initRepeat, list,
toolbox.individual)
self.compile_context = dict(
**pset.context) # convert to normal objects for pickling
self.compile_arguments = list(
pset.arguments) # convert to normal objects for pickling
toolbox.register("compile",
compile,
arguments=self.compile_arguments,
context=self.compile_context)
evaluate = EvaluateWildfire(x=X, y=y, model=self)
toolbox.register("evaluate", evaluate)
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=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 = toolbox.population(n=self.pop_size)
hof = tools.HallOfFame(1)
pop, log = algorithms.eaSimple(population=pop,
toolbox=toolbox,
cxpb=self.cxpb,
mutpb=self.mutpb,
ngen=self.n_gen,
stats=mstats,
halloffame=hof,
verbose=False)
tree = gp.PrimitiveTree(hof[0])
print('tree', tree)
print('hof', hof)
print('log', log)
print('fitnesses', evaluate.fitnesses)
# save best model
self.best_ind = {
'expr': str(tree),
'context': self.compile_context,
'arguments': self.compile_arguments
}
# self.hof = hof
# self.best_ind = hof[0]
# self.best_tree = gp.PrimitiveTree(self.best_ind)
self.log = log
self.fitnesses = evaluate.fitnesses
