def test_optimize(self):
geneSet = [i for i in range(1, 512 + 1)]
longitud = 10
segundosMáximos = 2
def fnObtenerAptitud(genes):
horaInicio = time.time()
cuenta = 0
stdout = sys.stdout
sys.stdout = None
while time.time() - horaInicio < segundosMáximos:
if self.test(genes, segundosMáximos):
cuenta += 1
sys.stdout = stdout
distancia = abs(sum(genes) - 1023)
fracción = 1 / distancia if distancia > 0 else distancia
cuenta += round(fracción, 4)
return cuenta
def fnMostrar(cromosoma):
print("{}\t{}".format(cromosoma.Genes, cromosoma.Aptitud))
initial = [512, 256, 128, 64, 32, 16, 8, 4, 2, 1]
print("initial:", initial, fnObtenerAptitud(initial))
aptitudÓptima = 10 * segundosMáximos
genetic.obtener_mejor(fnObtenerAptitud,
longitud,
aptitudÓptima,
geneSet,
fnMostrar,
segundosMáximos=600)
def resolver(self, búsquedaDeUbicación, secuenciaÓptima):
geneSet = [i for i in búsquedaDeUbicación.keys()]
def fnCrear():
return random.sample(geneSet, len(geneSet))
def fnMostrar(candidato):
mostrar(candidato, horaInicio)
def fnObtenerAptitud(genes):
return obtener_aptitud(genes, búsquedaDeUbicación)
def fnMudar(genes):
mudar(genes, fnObtenerAptitud)
def fnIntercambio(padre, donante):
return intercambiar(padre, donante, fnObtenerAptitud)
aptitudÓptima = fnObtenerAptitud(secuenciaÓptima)
horaInicio = datetime.datetime.now()
mejor = genetic.obtener_mejor(fnObtenerAptitud,
None,
aptitudÓptima,
None,
fnMostrar,
fnMudar,
fnCrear,
edadMáxima=500,
tamañoDePiscina=25,
intercambiar=fnIntercambio)
self.assertTrue(not aptitudÓptima > mejor.Aptitud)
def generar(self, tamañoDiagonal, edadMáxima):
nCuadrado = tamañoDiagonal * tamañoDiagonal
geneSet = [i for i in range(1, nCuadrado + 1)]
sumaEsperada = tamañoDiagonal * (nCuadrado + 1) / 2
def fnObtenerAptitud(genes):
return obtener_aptitud(genes, tamañoDiagonal, sumaEsperada)
def fnMostrar(candidato):
mostrar(candidato, tamañoDiagonal, horaInicio)
geneÍndices = [i for i in range(0, len(geneSet))]
def fnMudar(genes):
mudar(genes, geneÍndices)
def fnCreaciónPersonalizada():
return random.sample(geneSet, len(geneSet))
valorÓptimo = Aptitud(0)
horaInicio = datetime.datetime.now()
mejor = genetic.obtener_mejor(fnObtenerAptitud, nCuadrado, valorÓptimo,
geneSet, fnMostrar, fnMudar,
fnCreaciónPersonalizada, edadMáxima)
self.assertTrue(not valorÓptimo > mejor.Aptitud)
def resolver(self, operaciones, operacionesPriorizadas,
soluciónDeLongitudÓptima):
números = [1, 2, 3, 4, 5, 6, 7]
totalEsperado = evaluar(soluciónDeLongitudÓptima,
operacionesPriorizadas)
númerosMin = (1 + len(soluciónDeLongitudÓptima)) / 2
númerosMax = 6 * númerosMin
horaInicio = datetime.datetime.now()
def fnMostrar(candidato):
mostrar(candidato, horaInicio)
def fnEvaluar(genes):
return evaluar(genes, operacionesPriorizadas)
def fnObtenerAptitud(genes):
return obtener_aptitud(genes, totalEsperado, fnEvaluar)
def fnCrear():
return crear(números, operaciones, númerosMin, númerosMax)
def fnMudar(niño):
mudar(niño, números, operaciones, númerosMin, númerosMax,
fnObtenerAptitud)
aptitudÓptima = fnObtenerAptitud(soluciónDeLongitudÓptima)
mejor = genetic.obtener_mejor(fnObtenerAptitud,
None,
aptitudÓptima,
None,
fnMostrar,
fnMudar,
fnCrear,
edadMáxima=50)
self.assertTrue(not aptitudÓptima > mejor.Aptitud)
def test(self,
valoresDeBits=[512, 256, 128, 64, 32, 16, 8, 4, 2, 1],
segundosMáximos=None):
geneSet = [i for i in range(2)]
horaInicio = datetime.datetime.now()
def fnMostrar(candidato):
mostrar(candidato, horaInicio, valoresDeBits)
def fnObtenerAptitud(genes):
return obtener_aptitud(genes, valoresDeBits)
aptitudÓptima = 3.14159
def fnMudar(genes):
mudar(genes, len(valoresDeBits))
longitud = 2 * len(valoresDeBits)
mejor = genetic.obtener_mejor(fnObtenerAptitud,
longitud,
aptitudÓptima,
geneSet,
fnMostrar,
fnMudar,
edadMáxima=250,
segundosMáximos=segundosMáximos)
return mejor.Aptitud >= aptitudÓptima
def encontrarCaballoPosiciones(self, tableroAncho, tableroAltura,
caballosEsperados):
horaInicio = datetime.datetime.now()
def fnMostrar(candidato):
mostrar(candidato, horaInicio, tableroAncho, tableroAltura)
def fnObtenerAptitud(genes):
return obtener_aptitud(genes, tableroAncho, tableroAltura)
todasPosiciones = [Posición(x, y)
for y in range(tableroAltura)
for x in range(tableroAncho)]
if tableroAncho < 6 or tableroAltura < 6:
posicionesNoBordeadas = todasPosiciones
else:
posicionesNoBordeadas = [i for i in todasPosiciones
if 0 < i.X < tableroAncho - 1 and
0 < i.Y < tableroAltura - 1]
def fnObtenerPosiciónAleatoria():
return random.choice(posicionesNoBordeadas)
def fnMutar(genes):
mutar(genes, tableroAncho, tableroAltura, todasPosiciones,
posicionesNoBordeadas)
def fnCrear():
return crear(fnObtenerPosiciónAleatoria, caballosEsperados)
aptitudÓptima = tableroAncho * tableroAltura
mejor = genetic.obtener_mejor(fnObtenerAptitud, None, aptitudÓptima,
None, fnMostrar, fnMutar, fnCrear)
self.assertTrue(not aptitudÓptima > mejor.Aptitud)
def test(self):
geneSet = [i for i in range(1, 9 + 1)]
horaInicio = datetime.datetime.now()
valorÓptimo = 100
def fnMostrar(candidato):
mostrar(candidato, horaInicio)
reglasDeValidación = construir_las_reglas_de_validación()
def fnObtenerAptitud(genes):
return obtener_aptitud(genes, reglasDeValidación)
def fnCrear():
return random.sample(geneSet * 9, 81)
def fnMudar(genes):
mudar(genes, reglasDeValidación)
mejor = genetic.obtener_mejor(fnObtenerAptitud,
None,
valorÓptimo,
None,
fnMostrar,
fnMudar,
fnCrear,
edadMáxima=50)
self.assertEqual(mejor.Aptitud, valorÓptimo)
def resolver_desconocidos(self, numUnknowns, geneSet, ecuaciones,
fnGenesAEntradas):
horaInicio = datetime.datetime.now()
edadMáxima = 50
ventana = Ventana(max(1, int(len(geneSet) / (2 * edadMáxima))),
max(1, int(len(geneSet) / 3)), int(len(geneSet) / 2))
geneÍndices = [i for i in range(numUnknowns)]
geneSetOrdenado = sorted(geneSet)
def fnMostrar(candidato):
mostrar(candidato, horaInicio, fnGenesAEntradas)
def fnObtenerAptitud(genes):
return obtener_aptitud(genes, ecuaciones)
def fnMudar(genes):
mudar(genes, geneSetOrdenado, ventana, geneÍndices)
aptitudÓptima = Aptitud(0)
mejor = genetic.obtener_mejor(fnObtenerAptitud,
numUnknowns,
aptitudÓptima,
geneSet,
fnMostrar,
fnMudar,
edadMáxima=edadMáxima)
self.assertTrue(not aptitudÓptima > mejor.Aptitud)
def rellenar_mochila(self, artículos, pesoMáximo, volumenMáximo,
aptitudÓptima):
horaInicio = datetime.datetime.now()
ventana = Ventana(1,
max(1, int(len(artículos) / 3)),
int(len(artículos) / 2))
artículosOrdenados = sorted(artículos,
key=lambda artículo: artículo.Valor)
def fnMostrar(candidato):
mostrar(candidato, horaInicio)
def fnObtenerAptitud(genes):
return obtener_aptitud(genes)
def fnCrear():
return crear(artículos, pesoMáximo, volumenMáximo)
def fnMudar(genes):
mudar(genes, artículosOrdenados, pesoMáximo, volumenMáximo,
ventana)
mejor = genetic.obtener_mejor(fnObtenerAptitud, None, aptitudÓptima,
None, fnMostrar, fnMudar, fnCrear,
edadMáxima=50)
self.assertTrue(not aptitudÓptima > mejor.Aptitud)
def ordenar_numeros(self, numerosTotales):
#Inicia el temporizador
#crea las funciones auxiliares y la aptitud optima
# Despues lamma a genetic.obtener_mejor()
#Finalmente, asevera que la aptitud del resultado es optima
genSet = [i for i in range(100)] #LISTA POR COMPRENSION
aptitudOptima = Aptitu(numerosTotales, 0)
mejor = genetic.obtener_mejor(fnObtenerAptitud, numerosTotales,
aptitudOptima, genSet, fnMostrar)
self.assertTrue(not aptitudOptima > mejor.Aptitud)
def fnFunciónDeOptimización(longitudVariable):
nonlocal longitudMáxima
longitudMáxima = longitudVariable
return genetic.obtener_mejor(fnObtenerAptitud,
None,
len(reglas),
None,
fnMostrar,
fnMudar,
fnCrear,
tamañoDePiscina=3,
segundosMáximos=30)
def adivine_contraseña(self, objetivo):
horaInicio = datetime.datetime.now()
def fnObtenerAptitud(genes):
return obtener_aptitud(genes, objetivo)
def fnMostrar(candidato):
mostrar(candidato, horaInicio)
aptitudÓptima = len(objetivo)
mejor = genetic.obtener_mejor(fnObtenerAptitud, len(objetivo),
aptitudÓptima, self.geneSet, fnMostrar)
self.assertEqual(mejor.Genes, objetivo)
def test(self, tamaño=8):
geneSet = [i for i in range(tamaño)]
horaInicio = datetime.datetime.now()
def fnMostrar(candidato):
mostrar(candidato, horaInicio, tamaño)
def fnObtenerAptitud(genes):
return obtener_aptitud(genes, tamaño)
aptitudÓptima = Aptitud(0)
mejor = genetic.obtener_mejor(fnObtenerAptitud, 2 * tamaño,
aptitudÓptima, geneSet, fnMostrar)
self.assertTrue(not aptitudÓptima > mejor.Aptitud)
def test(self, longitud=100):
geneSet = [0, 1]
horaInicio = datetime.datetime.now()
def fnMostrar(candidato):
mostrar(candidato, horaInicio)
def fnObtenerAptitud(genes):
return obtener_aptitud(genes)
aptitudÓptima = longitud
mejor = genetic.obtener_mejor(fnObtenerAptitud, longitud,
aptitudÓptima, geneSet, fnMostrar)
self.assertEqual(mejor.Aptitud, aptitudÓptima)
def ordenar_números(self, númerosTotales):
geneSet = [i for i in range(100)]
horaInicio = datetime.datetime.now()
def fnMostrar(candidato):
mostrar(candidato, horaInicio)
def fnObtenerAptitud(genes):
return obtener_aptitud(genes)
aptitudÓptima = Aptitud(númerosTotales, 0)
mejor = genetic.obtener_mejor(fnObtenerAptitud, númerosTotales,
aptitudÓptima, geneSet, fnMostrar)
self.assertTrue(not aptitudÓptima > mejor.Aptitud)
def ejecutar_con(self, geneSet, anchura, altura, mínGenes, máxGenes,
númeroEsperadoDeInstrucciones, rondasMáximasDeMutación,
fnCrearCampo, númeroEsperadoDePasos):
ubicaciónInicialDelCortador = Ubicación(int(anchura / 2),
int(altura / 2))
direcciónInicialDelCortador = Direcciones.Sur.value
def fnCrear():
return crear(geneSet, 1, altura)
def fnEvaluar(instrucciones):
programa = Programa(instrucciones)
cortadora = Cortadora(ubicaciónInicialDelCortador,
direcciónInicialDelCortador)
campo = fnCrearCampo()
try:
programa.evaluar(cortadora, campo)
except RecursionError:
pass
return campo, cortadora, programa
def fnObtenerAptitud(genes):
return obtener_aptitud(genes, fnEvaluar)
horaInicio = datetime.datetime.now()
def fnMostrar(candidato):
mostrar(candidato, horaInicio, fnEvaluar)
def fnMudar(niño):
mudar(niño, geneSet, mínGenes, máxGenes, fnObtenerAptitud,
rondasMáximasDeMutación)
aptitudÓptima = Aptitud(anchura * altura,
númeroEsperadoDeInstrucciones,
númeroEsperadoDePasos)
mejor = genetic.obtener_mejor(fnObtenerAptitud,
None,
aptitudÓptima,
None,
fnMostrar,
fnMudar,
fnCrear,
edadMáxima=None,
tamañoDePiscina=10,
intercambiar=intercambiar)
self.assertTrue(not aptitudÓptima > mejor.Aptitud)
def encontrar_regex(self,
deseadas,
noDeseadas,
longitudEsperada,
operadoresPersonalizados=None):
horaInicio = datetime.datetime.now()
genesDeTexto = deseadas | set(c for w in deseadas for c in w)
geneSet = [i for i in todosMetacaracteres | genesDeTexto]
def fnMostrar(candidato):
mostrar(candidato, horaInicio)
def fnObtenerAptitud(genes):
return obtener_aptitud(genes, deseadas, noDeseadas)
recuentoDeMutaciones = [1]
operadoresDeMutación = [
partial(mudar_añadir, geneSet=geneSet),
partial(mudar_reemplazar, geneSet=geneSet),
mudar_remover,
mudar_intercambiar,
mudar_mover,
]
if operadoresPersonalizados is not None:
operadoresDeMutación.extend(operadoresPersonalizados)
def fnMudar(genes):
mudar(genes, fnObtenerAptitud, operadoresDeMutación,
recuentoDeMutaciones)
aptitudÓptima = Aptitud(len(deseadas), len(deseadas), 0,
longitudEsperada)
mejor = genetic.obtener_mejor(fnObtenerAptitud,
max(len(i) for i in genesDeTexto),
aptitudÓptima,
geneSet,
fnMostrar,
fnMudar,
tamañoDePiscina=10)
self.assertTrue(not aptitudÓptima > mejor.Aptitud)
for info in erroresEnRegexes.values():
print("")
print(info[0])
print(info[1])
print(info[2])
def test_conocimiento_perfecto(self):
mínGenes = 10
máxGenes = 20
geneSet = crear_geneSet()
horaInicio = datetime.datetime.now()
def fnMostrar(candidato):
mostrar(candidato, horaInicio)
def fnObtenerAptitud(genes):
return obtener_aptitud(genes)
recuentoDeMutaciones = [1]
operadoresDeMutación = [
partial(mudar_añadir, geneSet=geneSet),
partial(mudar_reemplazar, geneSet=geneSet),
mudar_remover,
mudar_intercambiar_adyacente,
mudar_mover,
]
def fnMudar(genes):
mudar(genes, fnObtenerAptitud, operadoresDeMutación,
recuentoDeMutaciones)
def fnIntercambio(padre, donante):
niño = padre[0:int(len(padre) / 2)] + \
donante[int(len(donante) / 2):]
fnMudar(niño)
return niño
def fnCrear():
return random.sample(geneSet, random.randrange(mínGenes, máxGenes))
aptitudÓptima = Aptitud(620, 120, 0, 11)
mejor = genetic.obtener_mejor(fnObtenerAptitud,
mínGenes,
aptitudÓptima,
None,
fnMostrar,
fnMudar,
fnCrear,
edadMáxima=500,
tamañoDePiscina=20,
intercambiar=fnIntercambio)
self.assertTrue(not aptitudÓptima > mejor.Aptitud)
def test(self):
geneSet = [i + 1 for i in range(10)]
horaInicio = datetime.datetime.now()
def fnMostrar(candidato):
mostrar(candidato, horaInicio)
def fnObtenerAptitud(genes):
return obtener_aptitud(genes)
def fnMutar(genes):
mutar(genes, geneSet)
aptitudÓptima = Aptitud(36, 360, 0)
mejor = genetic.obtener_mejor(fnObtenerAptitud,
10,
aptitudÓptima,
geneSet,
fnMostrar,
mutación_personalizada=fnMutar)
self.assertTrue(not aptitudÓptima > mejor.Aptitud)
def color(self, file, colores):
reglas, nodos = cargar_datos(file)
valorÓptimo = len(reglas)
búsquedaDeColor = {color[0]: color for color in colores}
geneSet = list(búsquedaDeColor.keys())
horaInicio = datetime.datetime.now()
búsquedaDeÍndiceDeNodo = {key: índice
for índice, key in enumerate(sorted(nodos))}
def fnMostrar(candidato):
mostrar(candidato, horaInicio)
def fnObtenerAptitud(genes):
return obtener_aptitud(genes, reglas, búsquedaDeÍndiceDeNodo)
mejor = genetic.obtener_mejor(fnObtenerAptitud, len(nodos),
valorÓptimo, geneSet, fnMostrar)
self.assertTrue(not valorÓptimo > mejor.Aptitud)
llaves = sorted(nodos)
for índice in range(len(nodos)):
print(
llaves[índice] + " es " + búsquedaDeColor[mejor.Genes[índice]])
