def fitness_optimo(funcion, x_min, x_max, num_bits, dimen):
"""
Devuelve el mejor fitness posible que se puede obtener con la amplitud
del intervalo (x_max - x_min) dada y el número de bits usados
:param funcion: Determina la función que se pretende maximizar
:param x_min: Inicio del intervalo de maximización para cada dimensión
:param x_max: Final del intervalo de maximización para cada dimensión
:param num_bits: número de bits usados para codificar el valor real de la
variable xi
:param dimen: Número de dimensiones de la función a evaluar
:return: devuelve el mejor fitness posible que se puede obtener con la
amplitud del intervalo (x_max - x_min) dada y el número de bits
usados
"""
delta = (x_max - x_min) / (2**num_bits - 1)
if funcion == "Esfera":
optimo = bin(round((-x_min) / delta))
elif funcion == "Schwefel":
optimo = bin(round((420.9687 - x_min) / delta))
else:
return 1
gen_optimo = bitarray(optimo[2:])
genes_optimos = []
for j in range(dimen):
genes_optimos.append(gen_optimo)
indiv_optimo = Individuo(genes_optimos)
indiv_optimo.set_fitness()
mejor_posible = indiv_optimo.get_fitness()
return mejor_posible
def __init__(self,
tx_mutacao: int,
tx_cross: int,
n_individ: int,
n_bits: int,
interv_min: int = None,
interv_max: int = None):
"""
Instancia uma população com N indivíduos e com as taxas recebidas.
:param tx_mutacao: Inteiro (entre 0 e 100) que representa a chance de um bit ser alterado.
:param tx_cross: Inteiro (entre 0 e 100) que representa a chance de ocorrer um crossover.
:param n_individ: Inteiro positivo. É a quantidade de indivíduos da população.
:param n_bits: Inteiro positivo. É o tamanho da cadeia genética de cada indivíduo.
:param interv_min: Valor real que representa o valor mínimo que um código genético pode assumir.
:param interv_max: Valor real que representa o valor máximo que um código genético pode assumir.
"""
# Atualize as propriedades com os valores recebidos
self.n_ind = n_individ
self.__taxa_mut = tx_mutacao
self.__taxa_cross = tx_cross
self.__n_bits = n_bits
# Gera os indiviuos da população
self.individuos: [Individuo] = [
Individuo(n_bits=n_bits) for i in range(self.n_ind)
]
self.elite = Individuo(self.__n_bits, self.get_best_or_worst().bits)
def gera_nova_populacao(self, shapes = None):
self.populacao = sorted(self.populacao, key=lambda x: x.avaliacao)
nova_populacao = []
while len(nova_populacao) < len(self):
p1 = self.seleciona()
p2 = self.seleciona()
while p1 == p2:
p2 = self.seleciona()
if shapes:
f1, f2 = Individuo.crossover_rede(p1, p2, shapes)
else:
f1, f2 = Individuo.crossover(p1, p2)
if random() < self.prob_mutacao:
f1.mutacao()
if random() < self.prob_mutacao:
f2.mutacao()
nova_populacao.append(f1)
nova_populacao.append(f2)
while len(nova_populacao) > len(self):
nova_populacao.remove(nova_populacao[randint(
0, len(nova_populacao))])
self.populacao = nova_populacao
self.geracao += 1
def test6(conn, limite):
"""
Test movimiento aleatorio total con dos individuos moviendose con memoria
"""
tipo = "test6"
# Situamos a los individuos inicialmente
a = Individuo(random.randrange(1, borde), random.randrange(1, borde), borde)
b = Individuo(random.randrange(1, borde), random.randrange(1, borde), borde)
t1 = Tablero()
t2 = Tablero()
# Bucle de busqueda
exito = False
while exito == False:
a.x, a.y = t1.dameCasilla()
b.x, b.y = t2.dameCasilla()
if a.x == -1 or b.x == -1:
break
a.movimientos += 1
b.movimientos += 1
if a.movimientos >= limite:
break
if b.movimientos >= limite:
break
if a.x == b.x and a.y == b.y: # Si estan en la misma casilla... exito
exito = True
print tipo, ":", a.movimientos
escribeEnDB(conn, tipo, a.movimientos, b.movimientos, exito)
def avaliacao(geracao):
aux = Individuo()
aux.avaliacao = 64*64
melhor_avaliacao = aux
for individuo in geracao:
if (individuo.avaliacao <= melhor_avaliacao.avaliacao):
melhor_avaliacao = individuo
return melhor_avaliacao
def crearIndividuos(self):
for i in range(self.poblacion_inicial - 1):
individuo = Individuo(self.prob_contagio, self.prob_muerte,
self.dias_recuperacion)
self.poblacion.append(individuo)
individuo_contagiado = Individuo(self.prob_contagio, self.prob_muerte,
self.dias_recuperacion)
individuo_contagiado.setContagiado()
self.poblacion.append(individuo_contagiado)
self.estadisticas.append([1, self.poblacion_inicial - 1,
0]) # enfermos, vivos, muertos
def criaPopulacao(self):
vPos = 0
for n in range(0, self.POPULACAO_TREINAMENTO):
indiv = Individuo()
# TRONCO
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
tronco = self.worldNP.attachNewNode(BulletRigidBodyNode('Box'))
tronco.node().setMass(1.0)
tronco.node().addShape(shape)
tronco.setPos(vPos + 2, 0.5, 3)
tronco.setScale(2, 0.6, 4)
tronco.setCollideMask(BitMask32.allOn())
#self.boxNP.node().setDeactivationEnabled(False)
indiv.tronco = tronco
self.world.attachRigidBody(tronco.node())
visualNP = loader.loadModel('models/box.egg')
visualNP.clearModelNodes()
visualNP.reparentTo(tronco)
frameA = TransformState.makePosHpr(Point3(0, 0, -2),
Vec3(0, 0, 90))
# PÉS
shape = BulletBoxShape(Vec3(0.5, 1, 0.2))
posicaoPes = [1, 2]
for i in range(2):
for j in range(1):
x = i + posicaoPes[i] + vPos
y = 0.0
z = j
pe = self.criaPe(shape, x, y, z)
if i == 1:
indiv.pe1 = pe
else:
indiv.pe2 = pe
# Cone
# frameB = TransformState.makePosHpr(Point3(-5, 0, 0), Vec3(0, 0, 0))
# cone = BulletConeTwistConstraint(tronco, pe, frameA, frameB)
# cone.setDebugDrawSize(2.0)
# cone.setLimit(30, 45, 170, softness=1.0, bias=0.3, relaxation=8.0)
# self.world.attachConstraint(cone)
self.individuos.append(indiv)
vPos = vPos + 4
def Gera_PopInic(self, caracter, TAM_Pop,
NUM_CROM): # Gera uma população inicial
for x in range(0, TAM_Pop): # Laço para
IND = Individuo(caracter) # Variável recebe indivíduo
F = Fitness(
self.Frase,
NUM_CROM) # A Variável F recebe instancia da classe fitness
self.listPop.append(
F.Calc_Fitness(IND.Gera_Individuo(NUM_CROM))
) # Adiciona o individuo na lista de populações e calcula o Fitness
print(self.listPop[x]) # imprimi o indivíduo
return self.listPop # retorna a lista de indivíduos
def cruzamentoUniforme(self, pais, txCruzamento):
#declaração dos pais e filhos
pai1 = pais[0]
pai2 = pais[1]
combinacaoPai1 = pai1.getCombinacao()
combinacaoPai2 = pai2.getCombinacao()
tam1 = len(combinacaoPai1)
tam2 = len(combinacaoPai2)
filhos = pais
i = 0
aux = []
#sorteio dos genes
while i < tam1:
aux.append(random.randint(0, 1))
i = i + 1
cruz = random.randint(0, 100)
if cruz < txCruzamento:
i = 0
filho1 = Individuo()
filho2 = Individuo()
combinacaoFilho1 = []
combinacaoFilho2 = []
while i < tam1:
if aux[i] == 0:
combinacaoFilho1.append(combinacaoPai1[i])
combinacaoFilho2.append(combinacaoPai2[i])
elif aux[i] == 1:
combinacaoFilho1.append(combinacaoPai2[i])
combinacaoFilho2.append(combinacaoPai1[i])
i = i + 1
filho1.setCombinacao(combinacaoFilho1)
filho2.setCombinacao(combinacaoFilho2)
filhos = [filho1, filho2]
return filhos
def __apply_elite(self):
temp_best = self.get_best_or_worst()
if temp_best.fitness <= self.elite.fitness:
self.elite = Individuo(self.__n_bits, temp_best.bits)
# Se o pior individuo tiver o fitness pior que o da elite
# Coloca a elite no lugar dele
else:
worst = self.get_best_or_worst(best=False)
if worst.fitness > self.elite.fitness:
idx = self.individuos.index(worst)
self.individuos[idx] = Individuo(self.__n_bits,
self.elite.bits)
def cruzamento(individuos, primIndice, segIndice, pc, pm):
probCruzamento = random.random()
novosFilhos = []
filhoUm = []
filhoDois = []
if probCruzamento <= pc:
posicaoCruzamento = random.randint(0, TOTAL_GENES - 1)
for i in range(TOTAL_GENES):
geneUm = 0
geneDois = 0
if i <= posicaoCruzamento:
geneUm = individuos[primIndice].genes[i]
geneDois = individuos[segIndice].genes[i]
else:
geneUm = individuos[segIndice].genes[i]
geneDois = individuos[primIndice].genes[i]
filhoUm.append(geneUm)
filhoDois.append(geneDois)
novosFilhos.append(filhoUm)
novosFilhos.append(filhoDois)
novosFilhos = mutacao(novosFilhos, pm)
for i in range(len(novosFilhos)):
novoFilho = Individuo(novosFilhos[i], 0, 0, 0)
individuos.append(novoFilho)
return individuos
def sex(tabela, horarios, professores, casais): # reprodução sexuada
prole = set()
contador_de_rejeitados = 0
for casal in casais:
combinacao = combinar(casal[0].genes, casal[1].genes)
try:
somo_a = Individuo(tabela, horarios, professores, combinacao[0])
prole.add(somo_a)
except Exception:
contador_de_rejeitados += 1
try:
somo_b = Individuo(tabela, horarios, professores, combinacao[1])
prole.add(somo_b)
except Exception:
contador_de_rejeitados += 1
return prole
def cromosoma_binario_a_individuo(cromosoma):
"""Se transforma el cromosoma (lista de binarios) en
un objeto del tipo Individuo.
Parameters
----------
cromosoma : list of int
lista de numeros binarios que forman el cromosoma.
Returns
-------
Individuo
True if successful, False otherwise.
"""
lista_enteros = []
numero_de_gen = 0
gen_binario = ''
for gen in cromosoma:
gen_binario += str(gen)
numero_de_gen += 1
if numero_de_gen != 0 and numero_de_gen % comidas.BITS_GEN == 0:
gen_entero = int(gen_binario, 2)
lista_enteros.append(gen_entero)
gen_binario = ''
return Individuo(lista_enteros, cromosoma.fitness)
def geraPopulacaoinicial(origem,pontos):
populacao = []
qtdIndividuosInicial = len(pontos)*2 # a quantidade de individuos vai depender da quantidade de pontos
print("-----------------------GERANDO POPULAÇÃO-----------------------------------")
print("QUANTIDADE INICIAL DE INDIVIDUOS " + str(qtdIndividuosInicial))
print("\n")
for i in range(qtdIndividuosInicial):
print("INDIVIDUO: " + str(i+1))
pontosEmbaralhado = shuffle(pontos)
calculo = calculateRoute(origem, pontosEmbaralhado)
individuo = Individuo(origem, pontosEmbaralhado,
calculo["routes"][0]["legs"][0]["duration"]["value"],
calculo["routes"][0]["legs"][0]["distance"]["value"],
calculo["routes"][0]["legs"][0]["duration"]["text"],
calculo["routes"][0]["legs"][0]["distance"]["text"])
populacao.append(individuo)
print(str(individuo))
print("________________________________________________________________________")
return populacao
def cruzamento(self, piscina: list, geracao: int) -> list:
nova_populacao = []
percentual = int(self.size_pop * self.taxa_cruzamento)
percentual = percentual if percentual % 2 == 0 else percentual + 1
size = len(piscina)
for _ in range(percentual):
indv = piscina[randrange(size)]
indv2 = piscina[randrange(size)]
filho1, filho2 = self.cruzamentoUmPonto(indv.cromossomo,
indv2.cromossomo)
nova_populacao.append(Individuo(cromossomo=filho1,
geracao=geracao))
nova_populacao.append(Individuo(cromossomo=filho2,
geracao=geracao))
return nova_populacao
def __init__(self):
self.populacao = []
for i in range(0, sizePopulacao):
self.populacao.append(Individuo())
self.calcularFitness()
self.calcularFitnessPercent()
self.calcularRangeRoleta()
def gerar_populacao(tamanho_populacao):
populacao = []
for i in range(tamanho_populacao):
individuo = Individuo()
#print (individuo)
#print (individuo.cromossomo)
populacao.append(individuo)
return populacao
def OrdenarPopulacao(self):
aux = Individuo()
for i in range(0, sizePopulacao):
for j in range(0, sizePopulacao):
if (self.populacao[i].getFitnessPercent() <
self.populacao[j].getFitnessPercent()):
aux = self.populacao[i]
self.populacao[i] = self.populacao[j]
self.populacao[j] = aux
def generate_data_set(self):
for index, player in self.df.iterrows():
position = self.get_position(player['Preferred Positions'])
overall = player['Overall']
price = player['Value']
name = player['Name']
individuo = Individuo(overall, price, name, position, 0)
self.v_positions[self.PLAYERS[individuo.position]].append(
individuo)
def test3(conn, limite):
"""
Test movimiento aleatorio a las casillas contiguas con un individuo quieto
"""
tipo = "test3"
# Situamos a los individuos inicialmente
a = Individuo(random.randrange(1, borde), random.randrange(1, borde), borde)
b = Individuo(random.randrange(1, borde), random.randrange(1, borde), borde)
# Bucle de busqueda
exito = False
while not exito:
a.moverAContigua()
if a.movimientos >= limite:
break
if a.x == b.x and a.y == b.y: # Si estan en la misma casilla... exito
exito = True
escribeEnDB(conn, tipo, a.movimientos, b.movimientos, exito)
def genera_poblacion_inicial(_long_gen, _num_genes, _mu):
"""
Devuelve una lista de instancias de la clase Individuo con el número de
genes y la longitud de estos especificados.
:param _long_gen: longitud de los genes
:param _num_genes: número de genes de cada individuo
:param _mu:
:return:
"""
_poblacion = []
for _i in range(_mu):
g = genera_genes(_long_gen, _num_genes) # Genera genes de un nuevo individuo
indiv = Individuo(g) # Creacción de individuo
indiv.set_fitness() # Cálculo del fitness
_poblacion.append(indiv) # Annade nuevo individuo a la población
_poblacion.sort()
asigna_probabilidades(_poblacion) # Asigna las probabilidades a cada individuo
return _poblacion
def assex(somos, tabela, horarios, professores): # reprodção assexuada
clones = set()
for somo in somos:
try:
clones.add(
Individuo(tabela, horarios, professores,
shuffle(list(somo.genes))))
except Exception:
pass
return clones
def test4(conn, limite):
"""
Test movimiento aleatorio total con los dos individuos moviendose
"""
tipo = "test4"
# Situamos a los individuos inicialmente
a = Individuo(random.randrange(1, borde), random.randrange(1, borde), borde)
b = Individuo(random.randrange(1, borde), random.randrange(1, borde), borde)
# Bucle de busqueda
exito = False
while not exito:
a.moverAContigua()
b.moverAContigua()
if a.movimientos >= limite:
break
if b.movimientos >= limite:
break
if a.x == b.x and a.y == b.y: # Si estan en la misma casilla... exito
exito = True
if exito == False:
print "Fracaso en test4"
escribeEnDB(conn, tipo, a.movimientos, b.movimientos, exito)
def iniciaPopulacao(listPop: list):
if len(listPop) == NP:
return listPop
for i in range(NP):
listInd = generateGenes()
novoIndividuo = Individuo(listInd, 0, 0, 0)
listPop.append(novoIndividuo)
for j in range(len(listPop)):
if listInd == listPop[j].genes and j != 0:
listPop.remove(novoIndividuo)
return iniciaPopulacao(listPop)
def make_crossover(self):
"""
Faz crossover entre individuos pelo método de 1 corte
"""
children: [Individuo] = []
while len(children) <= self.n_ind:
# Sorteia a taxa de crossover de 0% a 100%
tax = randint(0, 100)
# Escolhe aleatoriamente 2 individuos
ind1: Individuo = choice(self.individuos)
ind2: Individuo = choice(self.individuos)
# Se a taxa estiver no valor aceitável
if tax <= self.__taxa_cross:
# Sorteia a posição de corte
cut_pos = randint(1, self.__n_bits - 2)
# Gera os bits
bits1 = ind1.bits[:cut_pos] + ind2.bits[cut_pos:]
bits2 = ind2.bits[:cut_pos] + ind1.bits[cut_pos:]
# Gera os filhos
children.append(Individuo(self.__n_bits, bits1))
children.append(Individuo(self.__n_bits, bits2))
else:
# Adiciona os pais como filhos
children.append(ind1)
children.append(ind2)
# Muda os individuos para os filhos gerados
self.individuos = children
self.__apply_elite()
def gera_Mutacao(self, Frase): # Método para gerar mutação no filhos
listaTmp = []
listaFin = []
listaFinal = []
TX_Mut_A = round(random.random()) # Número aleatorio entre 0 e 1
for x in self.lista_Filho:
if(TX_Mut_A <= self.TX_Mutac): # Se o número aleatorio for menor e igual que taxa de mutação, o indivíduo sofre a mutação em 2 duas posições aleatorias
x1 = random.randint(0, self.NUM_CROM-1) # x1 = valor de posição aleatoria
x2 = random.randint(0, self.NUM_CROM-1) # x2 = valor de posição aleatoria
I = Individuo(self.Caract) # instancia clase indivíduo
x[x1] = I.get_caracter() # Modifica o caracter na posição x1 por um novo caracter na mesma posição
x[x2] = I.get_caracter() # Modifica o caracter na posição x2 por um novo caracter na mesma posição
F = Fitness(Frase, self.NUM_CROM) # Recalcula o Fitness
listaTmp.append(F.Calc_Fitness(x))
else: # Caso a condição não seja aceita
listaTmp.append(x) # Adicione o indivíduo na lista sem alteração
print('Mutação nos Filhos') # imprimi os filhos com ou sem mutação
for y in listaTmp:
print(y)
for z in self.lista_Selec: # Adiciona os filhos e pais dentro de uma lista
listaFin.append(z)
for z in listaTmp:
listaFin.append(z)
listaFin.sort(key=lambda x: x[self.NUM_CROM]) # Ordena a lista de pais e filhos
for x in range(self.TAM_Pop, len(listaFin)): # gera uma lista com o melhor dos pais e filhos
listaFinal.append(listaFin[x])
print('Nova População') # imprimi a lista com os melhores
for y in listaFinal:
print(y)
return listaFinal # retorna a lista com nova população
def crossover(populacao):
print("_________________CROSSOVER____________________________\n")
newPopulacao = []
for i in populacao: #vou gerar a mesma quantidade de individuos para a nova geracao
filho = Individuo()
filhoParte1 = []
pai1 = selecaoRoleta(populacao)
pai2 = selecaoRoleta(populacao)
#escolho os genes inicial e final para pegarmos do pai1
gene1 = int(randint(0,len(pai1.pontos)))
gene2 = int(randint(0, len(pai1.pontos)))
menor = min(gene1,gene2)
maior = max(gene1,gene2)
#print("maior " + str(maior) + "menor " + str(menor))
for i in range(menor,maior):
filhoParte1.append(pai1.pontos[i])
filhoParte2 = [ponto for ponto in pai2.pontos if ponto not in filhoParte1] #pega os pontos restantes que não estão na parte 1
filho.pontos = filhoParte1 + filhoParte2 #junta as duas partes para formar uma só
calculo = calculateRoute(pai1.origem, filho.pontos)
filho.origem = pai1.origem
filho.duracao = calculo["routes"][0]["legs"][0]["duration"]["value"]
filho.distancia = calculo["routes"][0]["legs"][0]["distance"]["value"]
filho.duracaoText = calculo["routes"][0]["legs"][0]["duration"]["text"]
filho.distanciaText = calculo["routes"][0]["legs"][0]["distance"]["text"]
newPopulacao.append(filho)
print("_________________NOVO INDIVIDUO____________________________\n")
print(str(filho))
return newPopulacao
def gerar_individuo(self):
operador = random.choice(self.operadores)
raiz = No(operador)
individuo = Individuo(raiz)
self.gerar_subarvore(individuo.raiz)
individuo.altura()
individuo.fitness(self.altura_maxima)
return individuo
def cruzamentoUmPonto(self, pais, txCruzamento):
pai1 = pais[0]
pai2 = pais[1]
combinacaoPai1 = pai1.getCombinacao()
combinacaoPai2 = pai2.getCombinacao()
tam1 = len(combinacaoPai1)
tam2 = len(combinacaoPai2)
filhos = pais
cruz = random.randint(0, 100)
if cruz < txCruzamento:
filho1 = Individuo()
filho2 = Individuo()
crossOver = random.randint(1, (tam1 - 2))
combinacaoFilho1 = [
*combinacaoPai1[:crossOver], *combinacaoPai2[crossOver:tam2]
]
combinacaoFilho2 = [
*combinacaoPai2[:crossOver], *combinacaoPai1[crossOver:tam1]
]
filho1.setCombinacao(combinacaoFilho1)
filho2.setCombinacao(combinacaoFilho2)
filhos = [filho1, filho2]
return filhos
def mutacao(self, populacao):
tamanho_populacao = len(populacao)
num_mutacao = int(tamanho_populacao - (tamanho_populacao*self.percentual_mutacao)/100)
for i in range(0, num_mutacao):
indece = random.randint(0, (tamanho_populacao-1))
novo_individual1 = populacao[indece]
lista_nos1 = self.tree2list(novo_individual1.raiz, [])
ponto_troca1 = random.randint(1, len(lista_nos1) - 1)
no_itercambio1 = lista_nos1[ponto_troca1] # type:No
operador = random.choice(self.operadores)
raiz = No(operador)
novo_individual_gerado = Individuo(raiz)
self.gerar_subarvore(novo_individual_gerado.raiz)
pai_aux = no_itercambio1.pai
novo_individual_gerado.raiz.pai = pai_aux
if no_itercambio1.pai.esquerdo == pai_aux:
no_itercambio1.pai.esquerdo = novo_individual_gerado.raiz
else:
no_itercambio1.pai.direito = novo_individual_gerado.raiz
novo_individual1.altura()
novo_individual1.fitness(self.altura_maxima)
return populacao
from datetime import datetime
from individuo import Individuo
from poblacion import Poblacion
from generacion import Generacion
# Entrada definida
try :
n = int(sys.argv[1])
except :
exit()
try :
k = int(sys.argv[2])
except :
exit()
k_maxima = Individuo.max_k(n)
# limites iniciales
if k < 0 or k > ((n*(n-1))/2) or k > k_maxima or n < 2 or n > 50 :
exit()
individuos = int(n**1.6)
poblacion = Poblacion(individuos, n)
generacion = Generacion(poblacion)
h_inicio = datetime.now()
print 'Individuos: %i' % (individuos)
# evoluciona la poblacion hasta alcanzar el fitness
while not poblacion.campeon(k) :
generacion.ronda(k, 0.30, 0.5, 0.75)
# mostrar mejor individuo
def nueva_generacion(_poblacion, _mu, _lambda):
"""
Función que realiza las operaciones necesarias para crear una nueva generación
Partiendo de una población inicial con los valores de fitness, probabilidad de
selección individual para cruze y probabilidad acumulada para cada individuo reliza
el resto del proceso:
1. Selección de padres para reproducción usando el algoritmo estocástico universal (SUS)
2. Cruze
3. Mutación
4. Selección hijos (relevo generacional) y Elitismo
5. Igualmente completa el resto de información para cada individuo:
- Valor de fitness
- Probabilidad selección padre y probabilidad acumulada
:param _poblacion:
:param _mu:
:param _lambda:
:return:
"""
# ############################## Selección de los padres ##########################
seleccion_padres = 0
indice = 0
r = random.uniform(0, 1 / _lambda)
lista_padres = []
while seleccion_padres < _lambda:
while r <= _poblacion[indice].get_prob_padre_acumulada():
lista_padres.append(_poblacion[indice])
r = r + 1 / _lambda
seleccion_padres += 1
indice += 1
# ############################# CRUZE Y MUTACIÓN ############################
random.shuffle(lista_padres) # Barajamos los padres --> cruze aleatorio
elite = max(_poblacion) # Se reserva el mejor para aplicar elitismo
_poblacion = [] # Reseteo de la población - relevo generacional
k = 0
while k < (_mu - 1):
hijos = lista_padres[k].cruze(lista_padres[k + 1]) # Generamos los hijos (por parejas)
_poblacion.append(Individuo(hijos[0]))
_poblacion.append(Individuo(hijos[1]))
_poblacion[k].mutacion() # Se muta cada uno
_poblacion[k + 1].mutacion() # de los hijos
_poblacion[k].set_fitness()
_poblacion[k + 1].set_fitness()
k += 2
mejor_hijo = max(_poblacion)
if elite > mejor_hijo:
peor_hijo = min(_poblacion)
_poblacion.remove(peor_hijo)
_poblacion.append(elite)
_poblacion.sort()
pos = 0
acum = 0
for _elem in _poblacion:
_elem.set_prob_lin(pos)
acum += _elem.get_prob_padre()
_elem.set_prob_padre_acumulada(acum)
pos += 1
return _poblacion
def Crossover(self, pai, mae):
novoInd = [0, 0]
pontoDeCorte = random_value(0, sizeCromossomo)
paiBuffer = Individuo()
maeBuffer = Individuo()
novoInd[self.PAI] = Individuo()
novoInd[self.MAE] = Individuo()
for i in range(0, sizeCromossomo):
paiBuffer.setGene(i, pai.getGene(i))
maeBuffer.setGene(i, mae.getGene(i))
novoInd[self.PAI].setGene(i, pai.getGene(i))
novoInd[self.MAE].setGene(i, mae.getGene(i))
if (random_value(0, 10) < self.taxaCrossover):
for i in range(pontoDeCorte, sizeCromossomo):
novoInd[self.PAI].setGene(i, maeBuffer.getGene(i))
novoInd[self.MAE].setGene(i, paiBuffer.getGene(i))
return novoInd
def iniciarOtimizacao(self, hasMapEscolhasUsuario):
numeroIndividuos = int(
hasMapEscolhasUsuario[Constantes.numeroIndividuos])
populacao = [Individuo() for i in range(0, numeroIndividuos)]
self.melhorIndividuo = MetricasPopulacao.melhorIndividuoPopulacao(
populacao)
self.piorIndividuo = MetricasPopulacao.piorIndividuoPopulacao(
populacao)
filhos = [1, 2]
positionPais = []
for i in range(0,
int(hasMapEscolhasUsuario[Constantes.numeroGeracao])):
populacao = MetricasPopulacao.rankearPopulacao(populacao)
listaFitness = MetricasPopulacao.getListaFitness(populacao)
newPopulacao = []
if (hasMapEscolhasUsuario[Constantes.temElitismo] == "s"):
j = 2
else:
j = 0
while j < (numeroIndividuos / 2):
positionPais = []
#Verificar metodo de selecao:
if (hasMapEscolhasUsuario[Constantes.tipoSelecao] == "r"):
positionPais = self.selecaoDosPaisRoleta(listaFitness)
else:
positionPais.append(
self.selecaoDosPaisTorneio(listaFitness))
positionPais.append(
self.selecaoDosPaisTorneio(listaFitness))
pais = [populacao[positionPais[0]], populacao[positionPais[1]]]
#Verificar metodo de cruzamento:
if (hasMapEscolhasUsuario[Constantes.tipoCruzamento] == "p"):
filhos = self.cruzamentoUmPonto(
pais, hasMapEscolhasUsuario[Constantes.taxaCruzamento])
else:
filhos = self.cruzamentoUniforme(
pais, hasMapEscolhasUsuario[Constantes.taxaCruzamento])
#verifica tipo mutacao:
if (hasMapEscolhasUsuario[Constantes.tipoMutacao] == "a"):
filhos[0] = self.mutacaoBitAleatorio(
filhos[0],
hasMapEscolhasUsuario[Constantes.taxaMutacao])
filhos[1] = self.mutacaoBitAleatorio(
filhos[1],
hasMapEscolhasUsuario[Constantes.taxaMutacao])
else:
filhos[0] = self.mutacaoBitABit(
filhos[0],
hasMapEscolhasUsuario[Constantes.taxaMutacao])
filhos[1] = self.mutacaoBitABit(
filhos[1],
hasMapEscolhasUsuario[Constantes.taxaMutacao])
newPopulacao.append(filhos[0])
newPopulacao.append(filhos[1])
j = j + 1
populacao = newPopulacao if hasMapEscolhasUsuario[
Constantes.temElitismo] == "n" else [
*populacao[:1], *newPopulacao
]
# def atualizarPopulacao(self, filhos):
# newPopulacao=filhos
# return newPopulacao
#metricas
self.melhorIndividuo = MetricasPopulacao.melhorIndividuoPopulacao(
populacao)
self.piorIndividuo = MetricasPopulacao.piorIndividuoPopulacao(
populacao)
self.listMelhoresFitness.append(self.melhorIndividuo.getFitness())
self.listPioresFitness.append(self.piorIndividuo.getFitness())
