def revolution(self, args):
#config
if (args.crossmode == "one"):
cross_func = Crossover.onePoint
elif (args.crossmode == "two"):
cross_func = Crossover.twoPoints
else:
cross_func = Crossover.randomPoints
# Prepare dataset
dataset = readDataset(args.dpath)
# Create individuals & population
ppl = Population()
for i in range(args.individuals):
individual = Individual()
individual.createGene(dataset, args.gene)
ppl.addInd(individual)
# Evolution
for i in range(args.revolution):
# Evaluation population in individuals
ppl.calcFitness(self.evaluate)
if ((i % 10) == 0):
ppl.show()
# Select parents
if (args.elite):
parents = Select.Elite(ppl, args.esize, args.mode)
parents.extend(
Select.Tournament(ppl, args.individuals - args.esize,
args.tornsize, args.mode))
else:
parents = Select.Tournament(ppl, args.individuals,
args.tornsize, args.mode)
# Clossover
children = cross_func(parents, args.individuals, args.gene,
args.crossrate)
# Mutation
children = Mutation.mutation(children, args.mutaterate, dataset)
# Swap children
ppl.setPpl(children)
# show result
ppl.calcFitness(self.evaluate)
ppl.show()
def __init__(self, algorithm_config):
start = time.time()
variable_config = algorithm_config
tab_epoch = []
tab_mean = []
tab_std = []
tab_mean2 = []
tab_std2 = []
tab_epoch2 = []
tab_elitary = []
tab_epoch3 = []
tab_epoch4 = []
tab_elitary2 = []
# chrom = Chromosome(variable_config)
# chrom = chrom.initialChromosome(variable_config)
# print(chrom)
# generujemy populację
pop = Population(variable_config)
popul = pop.initialPopulation(variable_config)
# print(popul)
randomBinSol = evaluateFitness(variable_config)
# pojedyncze x
decision_variables = randomBinSol.decVariables(variable_config, popul)
# print(decision_variables)
# dekodujemy na odpowiedniki dziesietne
decimal = randomBinSol.decoding(decision_variables, variable_config)
# print(decimal)
# zamieniamy na zmienne rzeczywiste
real = randomBinSol.realVariables(variable_config, decimal)
# print(real)
# obliczamy wartosc funkcji dla kazdej kolumny
func_solution = randomBinSol.funcSolution(variable_config, real)
# print(func_solution)
tab_mean.append(np.mean(func_solution))
tab_std.append(np.std(func_solution))
tab_epoch.append(0)
counter = 1
countEp = 0
selType = SelectionType(variable_config)
while (counter < variable_config.T):
selection = selType.selType(variable_config, func_solution, popul)
# KRZYŻOWANIE
# print("KRZYŻOWANIE")
crosov = CrossingOver(variable_config)
crosingover = crosov.crosingOver(variable_config, selection)
# print(crosingover)
# MUTACJA
# print("MUTACJA")
mutat = Mutation(variable_config)
mutation = mutat.mutation(variable_config, crosingover)
# print(mutation)
# INWERSJA
# print("INWERSJA")
inver = Inversion(variable_config)
inversion = inver.inversion(variable_config, mutation)
# print(inversion)
offspring = np.asarray(inversion)
# print(offspring)
decision_variables2 = randomBinSol.decVariables(
variable_config, offspring)
# print(decision_variables2)
# dekodujemy na odpowiedniki dziesietne
decimal2 = randomBinSol.decoding(decision_variables2,
variable_config)
# print(decimal2)
# zamieniamy na zmienne rzeczywiste
real2 = randomBinSol.realVariables(variable_config, decimal2)
# print(real2)
# obliczamy wartosc funkcji dla kazdej kolumny
func_solution2 = randomBinSol.funcSolution(variable_config, real2)
combin = Combinate()
combination = combin.newPopulation(popul, offspring, func_solution,
func_solution2, variable_config)
popul = combination[0]
func_solution = combination[1]
best = combination[2]
tab_mean.append(np.mean(func_solution))
tab_std.append(np.std(func_solution))
tab_epoch.append(counter)
tab_elitary.append(best)
tab_epoch3.append(countEp)
print(tab_elitary)
if counter != 1:
tab_mean2.append(np.mean(func_solution))
tab_std2.append(np.std(func_solution))
tab_epoch2.append(counter)
if countEp != 0:
tab_epoch4.append(countEp)
tab_elitary2.append(best)
counter += 1
countEp += 1
end = time.time()
print("wynik czasu")
el_time = (end - start)
self.__el_time = el_time
self.__tab_mean = tab_mean
self.__tab_std = tab_std
self.__tab_epoch = tab_epoch
self.__tab_mean2 = tab_mean2
self.__tab_std2 = tab_std2
self.__tab_epoch2 = tab_epoch2
self.__tab_elitary = tab_elitary
self.__tab_epoch3 = tab_epoch3
self.__tab_elitary2 = tab_elitary2
self.__tab_epoch4 = tab_epoch4
constants = get_constants(lower=-10, upper=10, bit=True)
ppl.createPopulation(functions=functions,
constants=constants,
n_ind=n_ind,
n_gene=n_gene,
n_register=n_register)
eval_function = lambda x: x[0] ^ x[1] # xor
ppl.excute_all(inputs, eval_function)
# revolution
p = ProgressBar(0, revolution)
for i in range(revolution):
#print("revolution: ", i)
p.update(i + 1)
elite = Selection.elite(ppl, elite_size)
new_p = copy.deepcopy(elite)
for j in range(n_ind - elite_size):
parent = Selection.tournament(ppl, tourn_size)
elite.append(parent)
child = Crossover.randomPoints(elite, cross_rate)
child = Mutation.mutation(child, mutate_rate, n_register, functions,
constants)
new_p.append(child)
ppl.setPopulation(new_p)
ppl.excute_all(inputs, eval_function)
if ((i % 100) == 0):
ppl.result()
ppl.result()
ppl.write_result(path)
p.finish()
roulet = Roulette_wheel(variable_config)
roulette = roulet.roulette(variable_config, func_solution, popul)
selection = roulette
#print(roulette)
'''
#KRZYŻOWANIE
#print("KRZYŻOWANIE")
crosov = CrossingOver(variable_config)
crosingover = crosov.crosingOver(variable_config, selection)
#print(crosingover)
#MUTACJA
#print("MUTACJA")
mutat = Mutation(variable_config)
mutation = mutat.mutation(variable_config, crosingover)
#print(mutation)
#INWERSJA
#print("INWERSJA")
inver = Inversion(variable_config)
inversion = inver.inversion(variable_config, mutation)
#print(inversion)
offspring = np.asarray(inversion)
#print(offspring)
decision_variables2 = randomBinSol.decVariables(variable_config, offspring)
#print(decision_variables2)
#dekodujemy na odpowiedniki dziesietne
