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]])