def nova_geracao(self, populacao, elitismo):
nova_populacao = Populacao(tam_pop=populacao.get_tam_populacao())
if (elitismo):
nova_populacao.set_individuo(populacao.get_individuo(0))
while (nova_populacao.get_num_individuos() <
nova_populacao.get_tam_populacao()):
pais = self.selecao_torneio(populacao)
filhos = []
# verifica a taxa de crossover, se sim realiza o crossover, se não, mantém os pais selecionados para a próxima geração
if (random.uniform(0.0, 1.0) <= self.taxa_crossover):
filhos = self.crossover(pais[1], pais[0])
else:
filhos.append(Individuo(genes=pais[0].get_genes()))
filhos.append(Individuo(genes=pais[1].get_genes()))
# adiciona os filhos na nova geração
nova_populacao.set_individuo(filhos[0])
nova_populacao.set_individuo(filhos[1])
# ordena a nova população
nova_populacao.ordena_populacao()
return nova_populacao
def main():
eltismo = True
# tamanho da populacao
tam_pop = 30
# numero máximo de geracoes
num_max_geracoes = 10000
# define o número de genes do indivíduo baseado na solucao
num_genes = int(27)
# cria a primeira populacao aleatérioa
populacao = Populacao(num_genes, tam_pop)
tem_solucao = False
geracao = 0
print("Iniciando... Aptidao da solucao: ", algoritmo.solucao)
# loop até o critério de parada
while (not tem_solucao and geracao < num_max_geracoes):
geracao += 1
# cria nova populacao
populacao = algoritmo.nova_geracao(populacao, eltismo)
print(
"Geracao ",
geracao,
" | Aptidao: ",
populacao.get_individuo(0).aptidao,
" | Melhor: ",
populacao.get_individuo(0).get_genes()
)
# verifica se tem a solucao
tem_solucao = populacao.tem_solucao()
if (geracao == num_max_geracoes):
print(
"Número Maximo de Geracoes | ",
populacao.get_individuo(0).get_genes(),
" ",
populacao.get_individuo(0).aptidao
)
if (tem_solucao):
print(
"Encontrado resultado na geracao ",
geracao,
" | ",
populacao.get_individuo(0).get_genes(),
" (Aptidão: ",
populacao.get_individuo(0).aptidao,
")"
)
def main(): # Método principal(main)
caracter = '!, .:;?áÁãÃâÂõÕôÔóÓéêÉÊíQWERTYUIOPASDFGHJKLÇZXCVBNMqwertyuiopasdfghjklçzxcvbnm1234567890' # Caracteres aceitáveis
frase = list("Im an iron man") # Frase deverá ser encontrada
Tamanho_Populacao = 100 # Tamanho da População
NUM_CROM = len(frase) # Número de Cromossomos
Taxa_Selec = 0.6 # Taxa de seleção
Taxa_Mutac = 0.6 # Taxa de mutação
populacao = [ ] # variáveis Temporárias
listaSelec = [ ]
listaFilh = [ ]
listaN_POP = [ ]
#Cria a População Inicial
print("População Inicial")
print("_"*40)
P = Populacao (Tamanho_Populacao, frase) # variável P recebe uma instancia da classe população
populacao = P.Gera_PopInic(caracter, Tamanho_Populacao, NUM_CROM) # método para geração da população inicial
num_geracao = 0
while(is_frase(populacao, NUM_CROM)): #
# Seleção
S = Selecao(Taxa_Selec, populacao, NUM_CROM, Tamanho_Populacao) # Variável S recebe uma instancia da classe Seleção
listaSelec = S.selecao_Torneio(3) # O Método Seleção por Torneio retorna uma lista de indivíduos selecionados
#listaSelec = S.selecao_roleta()
# Cruzamento
C = Cruzamento(Tamanho_Populacao,listaSelec, NUM_CROM) # Variável C recebe a classe Cruzamento
listaFilh = C.geraCruzamento(frase) # O Método Cruzamento com varios pontos de corte retorna uma lista de filhos
# Mutação
M = Mutacao(Tamanho_Populacao, NUM_CROM, listaFilh, populacao, Taxa_Mutac,caracter) # Variável M recebe a uma instancia da classe Mutação
listaN_POP = M.gera_Mutacao(frase) # O Método de Mutação por caracter aleatório retorna uma lista de indivíduos que sofreram ou não mutação
populacao = listaN_POP # Variável população recebe nova população
Tamanho_Populacao = len(populacao) # Variável tamanho da população recebe o novo tamanho da população
num_geracao += 1 # Variável 'num_geracao' e incrementada
print("ciclo {}".format(num_geracao)) # Imprimi o número de ciclos
def executaAG(self):
novaPopulacao = Populacao()
popBuffer = []
for i in range(0, int(sizePopulacao / 2)):
pai = self.Roleta(self.populacao)
mae = self.Roleta(self.populacao)
filhos = self.Crossover(pai, mae)
filhoA = self.Mutacao(filhos[0])
filhoB = self.Mutacao(filhos[1])
popBuffer.append(filhoA)
popBuffer.append(filhoB)
for i in range(0, sizePopulacao):
novaPopulacao.setIndividuo(i, popBuffer[i])
popBuffer = ''
novaPopulacao.atuazarValores()
return novaPopulacao
def Roleta(self, pop):
numSorteado = random_value(0, 100)
for ind in pop.getPopulacao():
if (numSorteado >= ind.getRangeRoleta()[0]
and numSorteado <= ind.getRangeRoleta()[1]):
return ind
pass
def printPopulacao(self):
print(self.populacao.printPop())
def getPopulacao(self):
return self.populacao
poppp = Populacao()
mat = []
for i in range(0, sizeGeracao):
a = AlgoritmoGenetico(poppp, 0.8, 0.1)
poppp = a.getPopulacao()
b = poppp.getPopulacao()
x = []
y = []
for i in range(0, sizeFuncao):
mat.append(function(i))
for ii in range(0, sizePopulacao):
valueInt = b[ii].getInt()
x.append(function(valueInt))
def selecao_torneio(self, populacao):
populacao_intermediaria = Populacao(tam_pop=3)
# seleciona 3 indivíduos aleatóriamente na população
populacao_intermediaria.set_individuo(
populacao.get_individuo(
random.randint(0, (populacao.get_tam_populacao() - 1))))
populacao_intermediaria.set_individuo(
populacao.get_individuo(
random.randint(0, (populacao.get_tam_populacao() - 1))))
populacao_intermediaria.set_individuo(
populacao.get_individuo(
random.randint(0, (populacao.get_tam_populacao() - 1))))
# ordena a população
populacao_intermediaria.ordena_populacao()
pais = []
# seleciona os 2 melhores deste população
pais.insert(0, populacao_intermediaria.get_individuo(0))
pais.insert(1, populacao_intermediaria.get_individuo(1))
return pais
def exec_ag(prmt): populacao = Populacao(tipo_rep='real', selecao='roleta', cruzamento='alpha_beta', npop=prmt[0], nger=prmt[1], elitismo=prmt[5], gerar_log_exec=False, taxa_cruzamento=prmt[3], pv=0.9) if populacao.tipo_rep == 'real': populacao.inicializa_indiv_real(alpha=0.75, beta=0.25, taxa_mutacao=prmt[2], ndim=prmt[4], xmax=3, xmin=-3) else: populacao.inicializa_indiv_bin(nbits=prmt[5], ndim=prmt[4], taxa_mutacao=prmt[2], xmax=3, xmin=-3) for geracao_atual in range(0, populacao.nger): populacao.avalia_pop() populacao.exec_selecao() populacao.exec_cruzamento() populacao.calc_log_ger() populacao.subst_pop() if populacao.elitismo: populacao.exec_elitismo() return populacao
populacao.exec_selecao()
populacao.exec_cruzamento()
populacao.calc_log_ger()
populacao.subst_pop()
if populacao.elitismo: populacao.exec_elitismo()
return populacao
EXEC_PARALELA = int(sys.argv[1])
if not EXEC_PARALELA:
inicio = time.time()
print("\nAlgoritmo Genético em execução...")
populacao = Populacao(tipo_rep='real', selecao='roleta', cruzamento='ponto', npop=100, nger=100, elitismo=True, gerar_log_exec=False, taxa_cruzamento=0.8, pv=0.9)
if populacao.tipo_rep == 'real': populacao.inicializa_indiv_real(alpha=0.75, beta=0.25, taxa_mutacao=0.05, ndim=10, xmax=2, xmin=-2)
else: populacao.inicializa_indiv_bin(nbits=10, taxa_mutacao=0.05, ndim=10, xmax=3, xmin=-3)
print(colored('\033[1m' + populacao.parametros + '\033[0m', "green"))
for geracao_atual in tqdm(range(0, populacao.nger), position=0, leave=True):
populacao.avalia_pop()
populacao.exec_selecao()
populacao.exec_cruzamento()
populacao.calc_log_ger()
populacao.subst_pop()
if populacao.elitismo: populacao.exec_elitismo()
fim = time.time()
log_ger = list(map(list, zip(*populacao.log_ger)))
valores_indv.append(valor)
return valores_indv
## São as entradas dos parâmetros da função
tam_pop = int(input('tam_pop:'))
num_gen = int(input('num_gen:'))
corte_pos = int(input('corte_pos:'))
metd_sel = input('metd_sel:').lower()
tax_mut = float(input('tax_mut:'))
elitismo = int(input('elitismo:'))
## A população é criada
populacao = Populacao.gerarPopulacaoIni(tam_pop, grafo.__len__())
print('\nPopulação Inicial:')
f.write('\nPopulação Inicial:')
for i in populacao:
print(i)
f.write(str(i))
f.write('\n')
## Vai repetir todo o proceso de criação de uma nova geração até atingir o numero de gerações definido
for geracao in range(num_gen):
valores_indv = funcAptidao(populacao)
aptos = None
# Retirar ind infinitos (que são soluções impossíveis)
from populacao import Populacao
from constants import item
# Armazena todas as populações que já existiram
geracoes = []
# Quantidade maxima de gerações
t=10
# Gera população inicial randomicamente, adiciona a lista de gerações e avalia
populacao_inicial = Populacao()
populacao_inicial.aptidao()
geracoes.append(populacao_inicial)
print('\nPopulacao inicial\n')
for i in range(1,t,1):
print('\n', geracoes[i-1])
geracoes[i-1].selecionar()
print(f'\nGeração {i}\n')
geracoes.append(geracoes[i-1].cruzar())
geracoes[i].mutacao()
geracoes[i].aptidao()
print(geracoes[-1])
melhorCromossomo = geracoes[-1].populacao[-1].cromossomo
print('\nMelhor cromossomo:', melhorCromossomo)
def imprimir(x, cromossomo_original, popul):
pop = Populacao()
valores = pop.fitness_populacao(cromossomo_original, popul)
maior = valores.index(max(valores))
print('Geração', x, ' : ->', popul[maior])
# -*- coding: utf-8 -*-
from individuo import Individuo
from populacao import Populacao
import matplotlib.pyplot as graf
from os import system
ind = Individuo()
pop = Populacao()
opc, x = 0, 0
cro, vy = [], []
geracao_maxima = 10000
'''opc = int(input('[1]Digitar genes\n[2]Gerar automático\n[3]Gerar automático,'
' mas definindo a porcentagem de números 1\n\n'
'Escolha: '))
if opc == 1:
cromossomo = str(input('Digite sequencia de genes: '))
tam = len(cromossomo)
cro = ind.criar_digitado(cromossomo)
elif opc == 2:
tam = int(input('Tamanho do cromossomo: '))
cro = ind.criar_aleatorio(tam)
elif opc == 3:
tam = int(input('Tamanho do cromossomo: '))
pct = int(input('Porcentagem de números 1: '))
pct = int(pct / 100 * tam)
cro = ind.criar_porcentagem(tam, pct)'''
tamanho_populacao = 10
def main():
padrao_print = "Arquivo com melhor x para {} gerações = {}i_{}g_{}exec.csv"
diretorio = "CSVs" # Diretório em que serão salvo os arquivos
bests = [] # Estrutura para armazenar os melhores fitness de cada execução para cada geração
# Cria pasta se não existir
if not os.path.exists(diretorio):
os.makedirs(diretorio)
num_exec = 10
generations = [5, 10]
best_x = {generation: None for generation in generations}
# Para cada execução
for t in range(1, num_exec + 1):
# Cria as listas da execução de cada número de gerações máximas
bests.append({generation: [] for generation in generations})
for max_generations in generations:
# Abre arquivo
arq = open(f"{diretorio}/{n_indiv}i_{max_generations}g_{t}exec.csv", "wt")
# Gera população
populacao = Populacao(taxa_mutacao, taxa_crossover, n_indiv, n_bits)
for i in range(max_generations):
populacao.select()
populacao.make_crossover()
populacao.apply_mutation()
best = Individuo(n_bits, populacao.elite.bits)
if not best_x[max_generations] or best_x[max_generations][0].fitness > best.fitness:
best_x[max_generations] = (best, t)
# Escreve no arquivo e adiciona o melhor fitness na estrutura
arq.write(f"{i+1};{best}\n")
bests[-1][max_generations].append(best.fitness)
arq.close()
# Estrutura que armazena a soma de cada geração de cada execução
fitness_sum = {generation: [0] * generation for generation in generations}
# Faz as somas
for best_exec in bests:
for generation in generations:
for i in range(generation):
fitness_sum[generation][i] += best_exec[generation][i]
# Calcula médias e plota
for generation in generations:
media = []
for i in range(generation):
media.append(fitness_sum[generation][i] / num_exec)
val_eixo_x = [i for i in range(1, generation + 1)]
pl.plot(val_eixo_x, media, marker='o')
# Nomeie os eixos X e Y
pl.xlabel("Número da geração")
pl.ylabel("Fitness i-ésimo individuo")
# Marque os valores de fitness, forma destacada (em vermelho) no gráfico
for i in range(len(media)):
pl.text(val_eixo_x[i], media[i], f"{media[i]:.5}", color="red", fontsize=10)
pl.text(1, media[-1], f"{best_x[generation][0].x_normalized}", color="blue", fontsize=10)
print(padrao_print.format(generation, n_indiv, generation, best_x[generation][1]))
pl.show()
return 0
if Parametro.getData(ParmId) == 0:
print('Parâmetro não encontrado...')
sleep(2)
ParmId = 0
else:
parametro = Parametro.getData(ParmId)
# print(Parametro.getData(ParmId))
# -------------------------------------------------------- --
# BLOCO 02 - INICIALIZA A POPULAÇÃO
# -------------------------------------------------------- --
# Configuracao inicial para teste x = [4, 170, 15]
ag.Common.GetHeader(propriedade['propriedadeNome'], ParmId)
setPop = Populacao.setPopInicial(propriedade['propriedadeId'])
sleep(2)
ag.Common.GetHeader(propriedade['propriedadeNome'], ParmId)
tblPop = Populacao.getPopIncial(propriedade['propriedadeId'])
print(tblPop)
sleep(5)
# -------------------------------------------------------- --
# BLOCO 03 - SELEÇÃO DOS INDIVIDUOS
# -------------------------------------------------------- --
ag.Common.GetHeader(propriedade['propriedadeNome'], ParmId)
# REALIZA N INTERAÇÕES
qtdI = 100
import pandas as pd
from data import Data
from genetico import AlgoritmoGenetico
from populacao import Populacao
def prepare_data(file_name):
df = pd.read_csv(file_name, low_memory=False)
df = df.fillna(0)
data = Data(df)
data.generate_data_set()
return data
if __name__ == "__main__":
data = prepare_data('CompleteDataset.csv')
random_squads = data.generate_squads(1001)
populacao = Populacao(random_squads)
genetico = AlgoritmoGenetico(populacao, data)
genetico.run(500)