def control_main():
toolbox.register("evaluate",
evalSymbRegCtrl,
points=[x / 10. for x in range(-10, 10)])
random.seed(318)
pop = toolbox.population(n=75)
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)
ITERATIONS = 100
pop, log = algorithms.eaSimple(pop,
toolbox,
0.5,
0.1,
ITERATIONS,
stats=mstats,
halloffame=hof,
verbose=False)
# print log
return pop, log, hof
def main():
#random.seed(10)
random.seed(1234)
pop = toolbox.population(n=100)
hof = tools.HallOfFame(1)
stats_fit = tools.Statistics(lambda ind: ind.fitness.values)
stats_size = tools.Statistics(len)
#stats = tools.Statistics(lambda ind: ind.fitness.values)
stats = tools.MultiStatistics(fitness=stats_fit, size=stats_size)
stats.register("avg", numpy.mean)
stats.register("std", numpy.std)
stats.register("min", numpy.min)
stats.register("max", numpy.max)
#_ , logbook = algorithms.eaSimple(pop, toolbox, 0.5, 0.2, 40, stats, halloffame=hof)
_, logbook = algorithms.eaSimple(pop,
toolbox,
0.5,
0.2,
40,
stats,
halloffame=hof,
verbose=True)
return pop, stats, hof, logbook
def main():
#random.seed(31415926535)
pop = toolbox.population(n=200)
hof = tools.HallOfFame(20)
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)
try:
pop, log = algorithms.eaSimple(pop, toolbox, 0.5, 0.1, 20, stats=mstats,
halloffame=hof, verbose=True)
except KeyboardInterrupt:
pass
print()
for idx, y in enumerate(hof):
err, cost = evalInvSqrt(y, points)
optim_params = {key: val for key, val in zip(string.ascii_lowercase, [hex(float2Int(x)) for x in y.optim_params])}
print("#{idx:01d}: ({err:.6f}, {cost}) {eq} {optim_params}".format(
eq=getInfix(y),
**locals()
))
return pop, log, hof
def search(self, npop=100, ngen=100, cxpb=0.7, mutpb=0.2, verbose=False):
lambda_ = npop
self.pop = self.tb.population(n=npop)
self.hof = tools.HallOfFame(10)
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)
self.pop, log = algorithms.eaMuPlusLambda(self.pop,
self.tb,
mu=npop,
lambda_=lambda_,
cxpb=cxpb,
mutpb=mutpb,
ngen=ngen,
stats=mstats,
halloffame=self.hof,
verbose=verbose)
self.best = self.hof[0]
self.print_ind(self.best)
return self.pop, log, self.hof
def main():
pop = toolbox.population(n=7000)
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("min", numpy.min)
mstats.register("max", numpy.max)
#############################################C.O, Muta,Gener##########
try:
pop, log = algorithms.eaSimple(pop, toolbox, 0.8, 0.8, 1000, stats=mstats,
halloffame=hof, verbose=True)
print (hof[0])
plot_pred(hof)
except MemoryError:
print (hof[0])
plot_pred(hof)
except KeyboardInterrupt:
print (hof[0])
plot_pred(hof)
def main():
random.seed(318)
pop = toolbox.population(n=1000)
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.1, ngen=10, stats=mstats,
halloffame=hof, verbose=True)
print (hof.items[0])
TestData=[]
for i in range(0, 180):
x = random.randrange(-10, 10) / 10.
y = random.randrange(-10, 10) / 10.
TestData.append((x, y))
Testfitness = toolbox.evaluate(hof.items[0], points=TestData)
print("Test fitness=" + str(Testfitness))
return pop, log, hof
def main():
global snake
global pset
pop = toolbox.population(n=POPULATION_SIZE)
hof = tools.HallOfFame(1)
stats_fit = tools.Statistics(lambda ind: ind.fitness.values)
stats_score = tools.Statistics(lambda ind: ind.score)
stats_steps = tools.Statistics(lambda ind: ind.steps)
stats_depth = tools.Statistics(lambda ind: ind.height)
stats_size = tools.Statistics(lambda ind: len(ind))
stats = tools.MultiStatistics(fitness=stats_fit,
score=stats_score,
steps=stats_steps,
size=stats_size,
depth=stats_depth)
stats.register("avg", numpy.mean)
stats.register("std", numpy.std)
stats.register("min", numpy.min)
stats.register("max", numpy.max)
sm, log = algorithms.eaSimple(pop,
toolbox,
MATE_RATE,
MUTATION_RATE,
GENERATIONS,
stats,
halloffame=hof,
verbose=True)
return pop, hof, stats, log
def main():
random.seed(69)
with open("santafe_trail.txt") as trail_file:
ant.parse_matrix(trail_file)
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)
algorithms.eaSimple(pop,
toolbox,
0.5,
0.2,
90,
mstats,
halloffame=hof,
verbose=True)
return pop, hof, mstats
def main():
global tfin, flag, n, old_hof
global size_gen, size_pop, Mu, Lambda, mutpb, cxpb, Trfun, Ttfun
global Rfun, Thetafun, Vrfun, Vtfun, mfun
flag = False
pool = multiprocessing.Pool(nbCPU)
toolbox.register("map", pool.map)
old_entropy = 0
for i in range(200):
pop = funs.POP(toolbox.population(n=size_pop_tot))
if pop.entropy > old_entropy and len(
pop.indexes) == len(pop.categories) - 1:
best_pop = pop.items
old_entropy = pop.entropy
#if nt > 0:
# pop2 = toolbox.popx()
# for ind in pop2:
# del ind.fitness.values
#best_pop = pop2 + best_pop
# else:
# pop = toolbox.population(n=size_pop)
# if pop.entropy > old_entropy and len(pop.indexes) == len(pop.categories) - 1:
# best_pop = pop.items
# old_entropy = pop.entropy
hof = funs.HallOfFame(10)
print("INITIAL POP SIZE: %d" % size_pop_tot)
print("GEN SIZE: %d" % size_gen)
print("\n")
stats_fit = tools.Statistics(lambda ind: ind.fitness.values)
mstats = tools.MultiStatistics(fitness=stats_fit)
mstats.register("avg", np.mean, axis=0)
mstats.register("min", funs.Min)
#################################### EVOLUTIONARY ALGORITHM - EXECUTION ###################################
pop, log = funs.eaMuPlusLambdaTol(best_pop,
toolbox,
Mu,
Lambda,
size_gen,
1.0,
mutpb,
cxpb,
limit_size,
stats=mstats,
halloffame=hof,
verbose=True)
####################################################################################################################
pool.close()
pool.join()
return pop, log, hof
def __init__(self,
orig_ind,
fitness,
generate,
generate_params,
select,
timeout=None):
creator.create("FitnessMax", base.Fitness, weights=(1.0, ))
creator.create("Individual", list, fitness=creator.FitnessMax)
self.toolbox = base.Toolbox()
# Attribute generator
self.toolbox.register("random_ind", generate, orig_ind,
generate_params)
# Structure initializers
self.toolbox.register("individual", tools.initRepeat,
creator.Individual, self.toolbox.random_ind, 1)
self.toolbox.register("population", tools.initRepeat, list,
self.toolbox.individual)
self.toolbox.register("evaluate", fitness)
self.toolbox.register("select", select)
stats_fit = tools.Statistics(key=lambda ind: ind.fitness.values)
stats_size = tools.Statistics(key=len)
self.mstats = tools.MultiStatistics(fitness=stats_fit, size=stats_size)
self.mstats.register("avg", np.mean)
self.mstats.register("std", np.std)
self.mstats.register("min", np.min)
self.mstats.register("max", np.max)
self.logbook = tools.Logbook()
self.timeout = timeout
self.orig_ind = orig_ind
def main():
random.seed(318)
pop = toolbox.population(n=300)
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", numpy.mean)
mstats.register("std", numpy.std)
mstats.register("min", numpy.min)
mstats.register("max", numpy.max)
generations = 400
pop, log = algorithms.eaSimple(pop,
toolbox,
0.5,
0.1,
generations,
stats=mstats,
halloffame=hof,
verbose=True)
print()
print("HallofFame:")
for i in range(len(hof)):
print("{} - {}".format(i, hof[i]))
# print log
return pop, log, hof
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)
pop, logbook = algorithms.eaSimple(pop,
toolbox,
0.5,
0.1,
50,
stats=mstats,
halloffame=hof,
verbose=True)
expr = hof[0]
tree = gp.PrimitiveTree(expr)
print(tree)
draw_logbook(logbook)
return pop, logbook, hof
def main():
random.seed(318)
pop = toolbox.population(n=100)
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.9,
0.1,
200,
stats=mstats,
halloffame=hof,
verbose=True)
# print log
print('Best individual : ', str(hof[0]), hof[0].fitness)
return pop, log, hof
def main():
# list all the functions to analyse
functions = [math.sin]
# create the toolbox
toolbox = get_toolbox(functions[0])
random.seed(318)
# create a new population
pop = toolbox.population(n=300)
hof = tools.HallOfFame(30)
# collect some statistics
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)
# do the evolution
pop, log = algorithms.eaSimple(pop, toolbox, 0.5, 0.1, 40, stats=mstats,
halloffame=hof, verbose=True)
# print(log)
# print the Hall of Fame together with their fitness value
for ind in hof:
print('%.4f'%(ind.fitness.getValues())[0], ':', ind)
return pop, log, hof
def main():
NGEN = 40
MU = 100
LAMBDA = 200
CXPB = 0.3
MUTPB = 0.6
pop = toolbox.population(n=MU)
hof = tools.ParetoFront()
price_stats = tools.Statistics(key=lambda ind: ind.fitness.values[0])
time_stats = tools.Statistics(key=lambda ind: ind.fitness.values[1])
stats = tools.MultiStatistics(price=price_stats, time=time_stats)
stats.register("avg", numpy.mean, axis=0)
stats.register("std", numpy.std, axis=0)
stats.register("min", numpy.min, axis=0)
algorithms.eaMuPlusLambda(pop,
toolbox,
MU,
LAMBDA,
CXPB,
MUTPB,
NGEN,
stats,
halloffame=hof)
return pop, stats, hof
def main():
random.seed(318)
# 存在するcpu分プロセスを流す
pool = Pool(multiprocessing.cpu_count())
toolbox.register("map", pool.map)
# 世代設定
pop = toolbox.population(n=300)
# 世代の中での最適解を抽出
hof = tools.HallOfFame(1)
# logとして出力する各値
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.5,
0.1,
7,
stats=mstats,
halloffame=hof,
verbose=True)
pool.close()
# logの表示
return pop, log, hof
def GPMain(randomSeeds):
random.seed(randomSeeds)
pop = toolbox.population(population)
hof = tools.HallOfFame(10)
log = tools.Logbook()
stats_fit = tools.Statistics(key=lambda ind: ind.fitness.values)
stats_size_tree = tools.Statistics(key=len)
stats_size_feature = tools.Statistics(
key=lambda ind: feature_length(ind, x_train[1, :, :], toolbox))
mstats = tools.MultiStatistics(fitness=stats_fit,
size_tree=stats_size_tree,
size_feature=stats_size_feature)
mstats.register("avg", np.mean)
mstats.register("std", np.std)
mstats.register("min", np.min)
mstats.register("max", np.max)
log.header = ["gen", "evals"] + mstats.fields
pop, log = evalGP.eaSimple(randomSeeds,
pop,
toolbox,
cxProb,
mutProb,
elitismProb,
generation,
stats=mstats,
halloffame=hof,
verbose=True)
return pop, log, hof
def main():
random.seed(318)
pop = toolbox.population(n=300)
hof = tools.HallOfFame(1)
toolbox.register("map", scoop.futures.map)
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.1,
40,
stats=mstats,
halloffame=hof,
verbose=True)
# print log
return pop, log, hof
def __init__(self,trainingX,trainingY,classifier=KNN(n_neighbors=3,n_jobs=-1),
populationSize=100,mutationRate=0.3,crossoverRate=0.7,
kfodls=-1,ngens=100,numberOfFilters=20):
creator.create("FitnessMin", base.Fitness, weights=(1.0,))
creator.create("Individual", list, fitness=creator.FitnessMin,
__eq__=lambda self, other: np.array_equal(self[0], other[0]))
self.mutationRate=mutationRate
self.crossoverRate=crossoverRate
self.ngens=ngens
self.numberOfFilters=numberOfFilters
self.trainingX=np.array(trainingX)
self.trainingY=np.array(trainingY)
toolbox = base.Toolbox()
toolbox.register("individual",generate, icls=creator.Individual,numberOfFilters=numberOfFilters)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
TX,TY,FX,FY=self.splitData(trainingX,trainingY)
toolbox.register("evaluate", self.fitness, trainingX=TX, trainingY=TY,fitnessX=FX,fitnessY=FY,classifier=classifier)
toolbox.register("mate", self.cross)
toolbox.register("mutate", self.mutation)
stats_fit = tools.Statistics(lambda ind: ind.fitness.values)
mstats = tools.MultiStatistics(fitness=stats_fit)
mstats.register("std", np.std)
mstats.register("min", np.min)
mstats.register("max", np.max)
mstats.register("av", np.average)
toolbox.register("select", selection, tournsize=3,icls=creator.Individual,numberOfFilters=numberOfFilters)
self.hof = tools.HallOfFame(1)
self.pop = toolbox.population(populationSize)
self.mstats=mstats
self.toolbox=toolbox
def main():
#inicializa la semilla aleatorios. Arranca con un aleatorio diferente.
random.seed()
pop = toolbox.population(n=200)
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,
cxpb=0.5,
mutpb=0.1,
ngen=50,
stats=mstats,
halloffame=hof,
verbose=True)
print(hof[0])
return pop, log, hof
def gp_algo():
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)
cr = 0.5
mr = 0.1
gens = 1
# print log
pop, log = algorithms.eaSimple(pop,
toolbox,
cr,
mr,
gens,
stats=mstats,
halloffame=hof,
verbose=True)
return pop, log, hof
def main():
pool = multiprocessing.Pool(nbCPU)
toolbox.register("map", pool.map)
pop = toolbox.population(n=size_pop_tot)
hof = tools.HallOfFame(10)
print("INITIAL POP SIZE: %d" % size_pop_tot)
print("GEN SIZE: %d" % size_gen)
print("\n")
stats_fit = tools.Statistics(lambda ind: ind.fitness.values)
mstats = tools.MultiStatistics(fitness=stats_fit)
mstats.register("avg", np.mean, axis=0)
mstats.register("min", ifuns.Min)
#################################### EVOLUTIONARY ALGORITHM - EXECUTION ###################################
pop, log, pop_statistics, ind_lengths = funs.eaMuPlusLambdaTolSimple(pop, toolbox, mu=Mu, lambda_=Lambda, cxpb=cxpb,
mutpb=mutpb, ngen=size_gen, creator=creator,
pset=pset, stats=mstats, halloffame=hof,
verbose=True, mod_hof=mod_hof, fit_tol=fit_tol,
check=False)
####################################################################################################################
pool.close()
pool.join()
return pop, log, hof, pop_statistics, ind_lengths
def main():
random.seed()
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.1,
40,
stats=mstats,
halloffame=hof,
verbose=True)
#print log
print '\nBest individual seen:'
print hof.__getitem__(0)
print '\nEval this individual:'
eval = toolbox.compile(hof.__getitem__(0))
print eval(1)
return pop, log, hof
def init_stats(self):
meta_stats = tools.Statistics()
meta_stats.register("proc", lambda _: self.island_name)
fitness_stats = tools.Statistics(key=lambda ind: ind.fitness.values)
fitness_stats.register("avg", np.mean)
# fitness_stats.register("avg_non_inf", self.avg_non_inf)
fitness_stats.register("std", np.std)
# fitness_stats.register("std_non_inf", self.std_non_inf)
fitness_stats.register("min", np.min)
# fitness_stats.register("max_non_inf", self.max_non_inf)
# fitness_stats.register("%_non_inf", self.percent_non_inf)
fitness_stats.register("max", np.max)
fitness_stats.register("dist", self.distance_from_target_energy)
# fitness_stats.register("unique_%", self.unique_percentage_by_fitness)
hypotheses_stats = tools.Statistics()
hypotheses_stats.register("rule_avg", self.avg_num_of_rules)
# hypotheses_stats.register("unique_%_h", self.unique_percentage_by_hypothesis)
hypotheses_stats.register("rule_max", self.max_num_of_rules)
hypotheses_stats.register("state_avg", self.avg_num_of_inner_states)
hypotheses_stats.register("state_max", self.max_num_of_inner_states)
# hypotheses_stats.register("avg_trns_stts", self.avg_num_states_in_transducer)
# hypotheses_stats.register("avg_hyp_sz", self.avg_hypothesis_size_bytes)
stats = tools.MultiStatistics(a_meta=meta_stats,
c_hypotheses=hypotheses_stats,
b_fitness=fitness_stats)
hall_of_fame = tools.HallOfFame(ga_config.HALL_OF_FAME_HYPOTHESES)
return stats, hall_of_fame
def run_gp(toolbox, num_threads, population_size, hof_size, elite_fraction,
crossover_rate, mutation_rate, max_iterations, train_docs_clusters,
train_docs_classes, validation_fraction, logistic_regression_mode):
pool = Pool(num_threads)
toolbox.register("map", pool.map)
pop = toolbox.population(n=population_size)
hof = tools.HallOfFame(hof_size)
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 = eaElitism(pop, toolbox, elite_fraction, crossover_rate,
mutation_rate, max_iterations, mstats, hof, True,
train_docs_clusters, train_docs_classes,
validation_fraction, logistic_regression_mode)
pool.close()
return dict(population=pop, log=log, hof=hof)
def main():
random.seed(time.time())
genN = 2
popN = 10
pop = toolbox.population(n=popN)
hof = tools.HallOfFame(1)
stats_fit = tools.Statistics(lambda ind: ind.fitness.values)
stats_size = tools.Statistics(len)
mstats = tools.MultiStatistics(fitness=stats_fit)
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.8,
0.15,
genN,
stats=mstats,
halloffame=hof,
verbose=True)
print(hof)
input()
return pop, log, hof
def main():
random.seed(318)
pop = toolbox.population(n=300)
hof = tools.HallOfFame(1)
print '-' * 20
for i in range(10):
expr = pop[i].js_str()
expr = expr.replace('add', '+')
expr = expr.replace('mul', '*')
expr = expr.replace('sub', '-')
expr = expr.replace('neg', '-')
expr = expr.replace('protectedDiv', '/')
print expr
print '-' * 20
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.1,
40,
stats=mstats,
halloffame=hof,
verbose=True)
# print log
return pop, log, hof
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)
pop, log = gp.harm(pop,
toolbox,
0.5,
0.1,
40,
alpha=0.05,
beta=10,
gamma=0.25,
rho=0.9,
stats=mstats,
halloffame=hof,
verbose=True)
# print log
return pop, log, hof
def main():
random.seed(318)
pop = toolbox.population(n=300)
hof = tools.HallOfFame(1)
# CXPB - Probabilidade de crossover
# MUTPB - Probabilidade de mutação
# NGEN - Numero de gerações
CXPB, MUTPB, NGEN = 0.6, 0.1, 50
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,
CXPB,
MUTPB,
NGEN,
stats=mstats,
halloffame=hof,
verbose=True)
# pop, log = gp.harm(pop, toolbox, 0.5, 0.1, 40, alpha=0.05, beta=10, gamma=0.25, rho=0.9, stats=mstats,
# halloffame=hof, verbose=True)
# print log
print(str(hof[0]))
return pop, log, hof
def main():
random.seed(318)
pop = toolbox.population(n=300)
init_model = gp.PrimitiveTree.from_string("add(mul(o1,o2),mul(o3,o4))",pset)
init_model.fitness = creator.FitnessMin
perf_pop = []
perf_pop.append(init_model)
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", np.mean)
mstats.register("std", np.std)
mstats.register("min", np.min)
mstats.register("max", np.max)
pop, log = algorithms.eaSimple(perf_pop, toolbox, 0.5, 0.1, 40, stats=mstats,
halloffame=hof, verbose=True)
print(pop[1])
# print log
return pop, log, hof
