def reproducao(self, ID):
pos = self.grelha.procura(ID)
livres = self.grelha.adjLivre(pos)
ocupados = self.grelha.adjOcupado(pos)
ocupadoInd = False
for p in ocupados:
if self.grelha.individuoQ(pos):
ocupadoInd = True
break
if len(livres) >= 2 and ocupadoInd:
if self.probQ(self.Tr):
new_pos = livres.pop(random.randrange(len(livres)))
new_ID = self.contador
self.grelha.adicionar(Individuo(new_ID, "S"), new_pos)
self.IDs += [new_ID]
self.CAP.adicionar(
Evento(new_ID, "des",
self.tempo + self.randomExp(self.Td)))
self.CAP.adicionar(
Evento(new_ID, "rep",
self.tempo + self.randomExp(self.Tr)))
self.CAP.adicionar(
Evento(new_ID, "mor",
self.tempo + self.randomExp(self.Tm)))
self.CAP.adicionar(
Evento(new_ID, "ava",
self.tempo + self.randomExp(self.tempoAva("S"))))
self.contador += 1
self.CAP.adicionar(
Evento(ID, "rep", self.tempo + self.randomExp(self.Tr)))
def test_funcaoDeFitness():
valorEsperado = 1
individuo = Individuo.Individuo([0, 0, 0, 0])
valorRetornado = individuo.funcaoDeFitness()
assert valorEsperado == valorRetornado
def test_insereGrauDaRoleta():
valorEsperado = 45
individuo = Individuo.Individuo([0, 0, 0, 0])
individuo.insereGrauDaRoleta(8)
valorRetornado = individuo.grausDaRoleta
assert valorEsperado == valorRetornado
def recombinacionEnUnPunto(indiv1, indiv2):
genotipo1 = indiv1.getLista()
genotipo2 = indiv2.getLista()
hijo1 = genotipo1[:]
hijo2 = genotipo2[:]
aleatorio = random.randrange(1, len(genotipo1))
for i in range(aleatorio, len(genotipo1)):
hijo1[i] = genotipo2[i]
hijo2[i] = genotipo1[i]
hijo1 = Individuo(hijo1)
hijo2 = Individuo(hijo2)
return hijo1, hijo2
def popula(self, Ps, Pi):
c = 0
livres = []
for x in range(-self.N, self.N + 1):
for y in range(-self.N, self.N + 1):
if self.livreQ([x, y]):
livres += [[x, y]]
for i in range(Ps):
pos = livres.pop(random.randrange(len(livres)))
self.adicionar(Individuo(c, "S"), pos)
c += 1
for i in range(Pi):
pos = livres.pop(random.randrange(len(livres)))
self.adicionar(Individuo(c, "I"), pos)
c += 1
def recombinacionUniforme(padre1, padre2, probabilidadDeMutacion):
padre1 = padre1.getLista()
padre2 = padre2.getLista()
hijo1 = padre1[:]
hijo2 = padre2[:]
if (not (probabilidadDeMutacion > 0 and probabilidadDeMutacion < 10)):
probabilidadDeMutacion = random.randrange(10)
for i in range(0, len(padre1) - 1):
aleatorio2 = random.randrange(10)
if (aleatorio2 > probabilidadDeMutacion):
hijo1[i] = padre2[i]
hijo2[i] = padre1[i]
hijo1 = Individuo(hijo1)
hijo2 = Individuo(hijo2)
return hijo1, hijo2
def mutacionUniforme(indiv, probabilidadDeMutacion):
mutacion = indiv.getLista()
if (not (probabilidadDeMutacion > 0 and probabilidadDeMutacion < 10)):
probabilidadDeMutacion = randint(0, 10)
for i in range(0, len(mutacion) - 1):
aleatorio2 = randint(0, 10)
if (aleatorio2 > probabilidadDeMutacion):
mutacion[i] = randint(0, 10)
res = Individuo(mutacion)
return res
def recombinacionEnDosPuntos(indiv1, indiv2):
genotipo1 = indiv1.getLista()
genotipo2 = indiv2.getLista()
hijo1 = genotipo1[:]
hijo2 = genotipo2[:]
aleatorio1 = random.randrange(1, len(genotipo1))
aleatorio2 = random.randrange(aleatorio1, len(genotipo1))
#print('aleatorio1 = ', aleatorio1)
#print('aleatorio2 = ', aleatorio2)
for i in range(aleatorio1, len(genotipo1)):
if (i >= aleatorio1 and i <= aleatorio2):
hijo1[i] = genotipo2[i]
hijo2[i] = genotipo1[i]
hijo1 = Individuo(hijo1)
hijo2 = Individuo(hijo2)
return hijo1, hijo2
def __init__(self, pobInicial=POB_INICIAL):
self.genAnterior = []
self.genActual = []
self.tamanioMax = pobInicial
self.numGen = 0
for x in range(0, pobInicial):
self.genActual.append(Individuo.Individuo(CANT_GENES))
self.genAnterior = self.genActual[:]
self.primerMejor = self.genActual[0]
self.mejorHastaAhora = self.primerMejor
for x in self.genActual:
if (not self.primerMejor.esMejor(x)):
self.primerMejor = x
self.mostrarPoblacionActual()
def primerArranque():
for i in range(22):
padre1, aciertospadre1 = cargaArchivo(i)
x = Individuo(padre1)
poblacion.append(x)
tamanopoblacionrestante = tamanopoblacion - 22
while (len(poblacion) < tamanopoblacion):
x = random.randint(1, 5)
randomselector = random.randint(0, 21)
randomselector2 = random.randint(0, 21)
if (x == 1):
beta = poblacion[randomselector]
individuoAguardar = intercambioAleatorio(beta, 0)
poblacion.append(individuoAguardar)
if (x == 2):
beta = poblacion[randomselector]
individuoAguardar = mutacionUniforme(beta, 0)
poblacion.append(individuoAguardar)
if (x == 3):
alfa = poblacion[randomselector]
beta = poblacion[randomselector2]
individuoAguardar1, individuoAguardar2 = recombinacionEnUnPunto(
alfa, beta)
poblacion.append(individuoAguardar1)
poblacion.append(individuoAguardar2)
if (x == 4):
alfa = poblacion[randomselector]
beta = poblacion[randomselector2]
individuoAguardar1, individuoAguardar2 = recombinacionEnDosPuntos(
alfa, beta)
poblacion.append(individuoAguardar1)
poblacion.append(individuoAguardar2)
if (x == 5):
alfa = poblacion[randomselector]
beta = poblacion[randomselector2]
individuoAguardar1, individuoAguardar2 = recombinacionUniforme(
alfa, beta, 5)
poblacion.append(individuoAguardar1)
poblacion.append(individuoAguardar2)
def intercambioAleatorio(indiv, cambioporparametro):
cambios = 0
listaNuestra = indiv.getLista()
if (cambioporparametro > 16) or (cambioporparametro == 0):
cambios = randint(1, 16)
else:
cambios = cambioporparametro
for i in range(cambios):
pos1 = randint(0, 15)
pos2 = randint(0, 15)
numero1 = listaNuestra[pos1]
numero2 = listaNuestra[pos2]
listaNuestra[pos1] = numero2
listaNuestra[pos2] = numero1
res = Individuo(listaNuestra)
return res
import pytest
import algoritmoGenetico
import Individuo
#variaveis para testes
populacao = list()
individuo1 = Individuo.Individuo([0, 0, 0, 0])
individuo2 = Individuo.Individuo([0, 0, 0, 1])
individuo3 = Individuo.Individuo([0, 1, 0, 1])
individuo4 = Individuo.Individuo([0, 1, 0, 0])
populacao.append(individuo1)
populacao.append(individuo2)
populacao.append(individuo3)
populacao.append(individuo4)
def test_escolheMelhorIndividuo():
#arrange
valorEsperado = [0, 1, 0, 1]
#action
valorRetornado = algoritmoGenetico.escolheMelhorIndividuo(
populacao).cromossomos
#assert
assert valorEsperado == valorRetornado
def test_calculaSomatoria():
#arrange
valorEsperado = 8
def inicializa_populacao(self):
for i in range(self.tamanho_populacao):
self.populacao.append(Individuo.Individuo())
self.melhor_solucao = self.populacao[0]
def nuevoMain(tamanopoblacion, algoritmoDeMutacion, algoritmoDeCruce,
estrategiaDeSeleccion, iteracionesMaximas):
poblacion = []
poblacionElegida = []
granpoblacion = []
proximapoblacion = []
selectorMutacion = algoritmoDeMutacion
selectorCruce = algoritmoDeCruce
selectorSeleccion = estrategiaDeSeleccion
fin = False
esPrimerArranque = True
IndividuoDePrueba = Individuo(
[5, 2, 9, 7, 2, 2, 3, 8, 3, 5, 9, 5, 4, 9, 9, 1])
individuoMejorPorAhora = IndividuoDePrueba
individuoGanador = 0
calidadMejorPorAhora = 0
contadorVueltas = 0
listaParaMediaDeFitness = []
def primerArranque():
for i in range(22):
padre1, aciertospadre1 = cargaArchivo(i)
x = Individuo(padre1)
poblacion.append(x)
tamanopoblacionrestante = tamanopoblacion - 22
while (len(poblacion) < tamanopoblacion):
x = random.randint(1, 5)
randomselector = random.randint(0, 21)
randomselector2 = random.randint(0, 21)
if (x == 1):
beta = poblacion[randomselector]
individuoAguardar = intercambioAleatorio(beta, 0)
poblacion.append(individuoAguardar)
if (x == 2):
beta = poblacion[randomselector]
individuoAguardar = mutacionUniforme(beta, 0)
poblacion.append(individuoAguardar)
if (x == 3):
alfa = poblacion[randomselector]
beta = poblacion[randomselector2]
individuoAguardar1, individuoAguardar2 = recombinacionEnUnPunto(
alfa, beta)
poblacion.append(individuoAguardar1)
poblacion.append(individuoAguardar2)
if (x == 4):
alfa = poblacion[randomselector]
beta = poblacion[randomselector2]
individuoAguardar1, individuoAguardar2 = recombinacionEnDosPuntos(
alfa, beta)
poblacion.append(individuoAguardar1)
poblacion.append(individuoAguardar2)
if (x == 5):
alfa = poblacion[randomselector]
beta = poblacion[randomselector2]
individuoAguardar1, individuoAguardar2 = recombinacionUniforme(
alfa, beta, 5)
poblacion.append(individuoAguardar1)
poblacion.append(individuoAguardar2)
while (fin == False):
mejorPorVuelta = IndividuoDePrueba
calidadMejorPorVuelta = 0
if (algoritmoDeMutacion == 0):
selectorMutacion = random.randint(1, 2)
if (algoritmoDeCruce == 0):
selectorCruce = random.randint(1, 3)
if (selectorSeleccion == 0):
selectorSeleccion = random.randint(1, 2)
if (esPrimerArranque == True):
primerArranque()
esPrimerArranque = False
#print("Longitud poblacion "+str(len(poblacion)))
mitad = int(len(poblacion) / 2)
#Primer Paso: Seleccion
if (selectorSeleccion == 1):
poblacionElegida = seleccionPorTorneo(poblacion, mitad, 2)
elif (selectorSeleccion == 2):
poblacionElegida = seleccionPorRuleta(poblacion, mitad)
#print("Longitud poblacion elegida "+str(len(poblacionElegida)))
#Cruzamos individuos
condicion = False
while (condicion == False):
# print("Tamano antes del primer padre "+str(len(poblacionElegida)))
al1 = random.randint(0, len(poblacionElegida) - 1)
#print(al1)
padre1 = poblacionElegida.pop(al1)
#print("Tamano antes del segundo padre "+str(len(poblacionElegida)))
al2 = random.randint(0, len(poblacionElegida) - 1)
#print(al2)
padre2 = poblacionElegida.pop(al2)
#print("Tamano final "+str(len(poblacionElegida)))
if (selectorCruce == 1):
indiv1, indiv2 = recombinacionEnUnPunto(padre1, padre2)
elif (selectorCruce == 2):
indiv1, indiv2 = recombinacionEnDosPuntos(padre1, padre2)
elif (selectorCruce == 3):
indiv1, indiv2 = recombinacionUniforme(padre1, padre2, 5)
granpoblacion.append(indiv1)
granpoblacion.append(indiv2)
if (len(poblacionElegida) == 0):
condicion = True
#Mutamos individuos
longitudParaSegundoFor = len(granpoblacion)
contadorMutaciones = 0
for i in range(longitudParaSegundoFor):
#print("Estoy mutando")
padre1 = granpoblacion[i]
if (selectorMutacion == 1):
indiv = intercambioAleatorio(padre1, 5)
elif (selectorMutacion == 2):
indiv = mutacionUniforme(padre1, 5)
granpoblacion.append(indiv)
#print(contadorMutaciones)
contadorMutaciones = contadorMutaciones + 1
#Buscamos al mejor
#print("Antes del for")
#print(len(granpoblacion))
for a in granpoblacion:
#print("Dentro del for")
if (a.getCalidad() == 22):
individuoGanador = a
fin = True
print("---------------------------------------")
print("------------Fin del Algoritmo----------")
print("SE HA ENCONTRADO UNA SOLUCION ")
print(individuoGanador.getLista())
print("Con un fitness de: " +
str(individuoGanador.getCalidad()))
print("---------------------------------------")
if (a.getCalidad() > calidadMejorPorAhora):
individuoMejorPorAhora = a
calidadMejorPorAhora = a.getCalidad()
if (a.getCalidad() > calidadMejorPorVuelta):
mejorPorVuelta = a
calidadMejorPorVuelta = a.getCalidad()
listaParaMediaDeFitness.append(calidadMejorPorVuelta)
#print(a)
#print("Despues del for")
print("---------------------------------------")
print("Iteracion: " + str(contadorVueltas))
print("Mejor Fitness encontrado = " + str(calidadMejorPorAhora))
print("Mejor Fitness encontrado en esta iteracion = " +
str(calidadMejorPorVuelta))
#Comprobamos las vueltas
if (contadorVueltas == iteracionesMaximas):
fin = True
print("---------------------------------------")
print("------------Fin del Algoritmo----------")
print(
"No se ha encontrado una solucion exacta, pero el mejor candidato es: "
)
print(individuoMejorPorAhora.getLista())
print("Con un fitness de: " +
str(individuoMejorPorAhora.getCalidad()))
print("---------------------------------------")
print("La media de fitness por Generacion es de")
total = 0
for i in listaParaMediaDeFitness:
total = total + i
res = total / len(listaParaMediaDeFitness)
print(res)
contadorVueltas = contadorVueltas + 1
#Reemplazo
proximapoblacion.extend(poblacion)
proximapoblacion.extend(granpoblacion)
proximapoblacion.sort(key=lambda individuo: individuo.calidad,
reverse=True)
aux = proximapoblacion[0:tamanopoblacion]
poblacion = aux[:]
granpoblacion = []