def prueba_temple_simulado(problema=ProblemaNreinas(8),calendarizador=None): """ Prueba el algoritmo de temple simulado """ solucion = blocales.temple_simulado(problema,calendarizador) print("Costo de la solución: ", problema.costo(solucion)) print("Y la solución es: ") print(solucion)
def main(): """ La función principal """ # Vamos a definir un grafo sencillo vertices_sencillo = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] aristas_sencillo = [('B', 'G'), ('E', 'F'), ('H', 'E'), ('D', 'B'), ('H', 'G'), ('A', 'E'), ('C', 'F'), ('H', 'B'), ('F', 'A'), ('C', 'B'), ('H', 'F')] dimension = 400 # Y vamos a hacer un dibujo del grafo sin decirle como hacer para # ajustarlo. grafo_sencillo = problema_grafica_grafo(vertices_sencillo, aristas_sencillo, dimension) estado_aleatorio = grafo_sencillo.estado_aleatorio() costo_inicial = grafo_sencillo.costo(estado_aleatorio) grafo_sencillo.dibuja_grafo(estado_aleatorio, "prueba_inicial.gif") print("Costo del estado aleatorio: {}".format(costo_inicial)) # Ahora vamos a encontrar donde deben de estar los puntos t_inicial = time.time() solucion = blocales.temple_simulado(grafo_sencillo) t_final = time.time() costo_final = grafo_sencillo.costo(solucion) grafo_sencillo.dibuja_grafo(solucion, "prueba_final.gif") print("\nUtilizando la calendarización por default") print("Costo de la solución encontrada: {}".format(costo_final)) print("Tiempo de ejecución en segundos: {}".format(t_final - t_inicial))
def prueba_temple_simulado(problema=ProblemaNreinas(8), eleccion=0): """ Prueba el algoritmo de temple simulado """ def calendarizador(): costos = [ problema.costo(problema.estado_aleatorio()) for _ in range(10 * len(problema.estado_aleatorio())) ] minimo, maximo = min(costos), max(costos) To = 2 * (maximo - minimo) return (((To * exp(-i / (problema.n * To))) for i in range(int(1e10))) if eleccion == 1 else ((To * exp(-i / ((problema.n**(1 / 2)) * To))) for i in range(int(1e10))) if eleccion == 2 else None) t_inicial = time() solucion = blocales.temple_simulado(problema, calendarizador=calendarizador()) print("\n\nTemple simulado con calendarización " + ("To * exp(-i/(n*To))" if eleccion == 1 else "To * exp(-i/(((n^(1/2))*To)))" if eleccion == 2 else "To/(i+1)")) print("Costo de la solución: ", problema.costo(solucion)) print("Y la solución es: ") print(solucion) print(f"Tiempo = {time() - t_inicial} seg")
def main(): """ La función principal """ # Vamos a definir un grafo sencillo vertices_sencillo = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] aristas_sencillo = [('B', 'G'), ('E', 'F'), ('H', 'E'), ('D', 'B'), ('H', 'G'), ('A', 'E'), ('C', 'F'), ('H', 'B'), ('F', 'A'), ('C', 'B'), ('H', 'F')] dimension = 400 # Y vamos a hacer un dibujo del grafo sin decirle como hacer para # ajustarlo. grafo_sencillo = problema_grafica_grafo(vertices_sencillo, aristas_sencillo, dimension) estado_aleatorio = grafo_sencillo.estado_aleatorio() grafo_sencillo.dibuja_grafo(estado_aleatorio) print "Costo del estado aleatorio: ", grafo_sencillo.costo( estado_aleatorio) # Ahora vamos a encontrar donde deben de estar los puntos tiempo_inicial = time.time() solucion = blocales.temple_simulado(grafo_sencillo, lambda i: 1000 * math.exp(-0.0001 * i)) tiempo_final = time.time() grafo_sencillo.dibuja_grafo(solucion) print "\nUtilizando una calendarización exponencial con K = 1000 y delta = 0.0001" print "Costo de la solución encontrada: ", grafo_sencillo.costo(solucion) print "Tiempo de ejecución en segundos: ", tiempo_final - tiempo_inicial
def main(): """ La función principal """ # Vamos a definir un grafo sencillo vertices_sencillo = ['A', 'B', 'C', 'D', 'E', 'F'] aristas_sencillo = [ ('A', 'B'), ('A', 'C'), ('A', 'D'), ('A', 'E'), ('A', 'F'), ('B', 'C'), ('B', 'D'), ('B', 'E'), ('B', 'F'), ('C', 'D'), ('C', 'E'), ('C', 'F'), ('D', 'E'), ('D', 'F'), ('E', 'F'), ] dimension = 400 # Y vamos a hacer un dibujo del grafo sin decirle como hacer para # ajustarlo. def calendarizador_logaritmico(Temp, k=.05): while True: Temp = Temp / math.log(k + 1) yield Temp def calendarizador_kirkpatrick(temp, alpha=0.9999): T = temp while True: yield T T = alpha * T grafo_sencillo = problema_grafica_grafo(vertices_sencillo, aristas_sencillo, dimension) estado_aleatorio = grafo_sencillo.estado_aleatorio() costo_inicial = grafo_sencillo.costo(estado_aleatorio) grafo_sencillo.dibuja_grafo(estado_aleatorio, "prueba_inicial.gif") print("Costo del estado aleatorio: {}".format(costo_inicial)) # Ahora vamos a encontrar donde deben de estar los puntos t_inicial = time.time() solucion = blocales.temple_simulado(grafo_sencillo, calendarizador_kirkpatrick(10), .001) t_final = time.time() costo_final = grafo_sencillo.costo(solucion) grafo_sencillo.dibuja_grafo(solucion, "prueba_final.gif") print("\nUtilizando la calendarización por default") print("Costo de la solución encontrada: {}".format(costo_final)) print("Tiempo de ejecución en segundos: {}".format(t_final - t_inicial))
def prueba_temple_simulado(problema=ProblemaNreinas(8), i=0): """ Prueba el algoritmo de temple simulado """ if i == 0: solucion = blocales.temple_simulado(problema) print("\n\nTemple simulado con calendarización To/(1 + i).") elif i == 1: solucion = blocales.temple_simulado(problema, calendarizacion1(problema)) print("\n\nTemple simulado con calendarización To*enfriador.") else: solucion = blocales.temple_simulado(problema, calendarizacion2(problema)) print("\n\nTemple simulado con calendarización To*e(-cambio*i).") print("Costo de la solución: ", problema.costo(solucion)) print("Y la solución es: ") print(solucion)
def prueba_temple_simulado(problema=ProblemaNreinas(8), calendarizador=None, cadCal="To/(1 + i)"): """ Prueba el algoritmo de temple simulado """ solucion = blocales.temple_simulado(problema, calendarizador) print("\n\nTemple simulado con calendarización " + cadCal+ ".") print("Costo de la solución: ", problema.costo(solucion)) print("Y la solución es: ") print(solucion)
def prueba_temple_simulado(problema=ProblemaNreinas(8)): """ Prueba el algoritmo de temple simulado """ solucion = blocales.temple_simulado(problema,calendarizador_kirkpatrick(10)) print("\n\nTemple simulado con calendarización To/(1 + i).") print("Costo de la solución: ", problema.costo(solucion)) print("Y la solución es: ") print(solucion)
def prueba_temple_simulado(problema=ProblemaNreinas(8)): """ Prueba el algoritmo de temple simulado """ solucion = blocales.temple_simulado(problema) print("\n\nTemple simulado con calendarización To/(1 + i).") print("Costo de la solución: ", problema.costo(solucion)) print("Y la solución es: ") print(solucion)
def prueba_temple_simulado(problema=ProblemaNreinas(8), K=100, delta=0.01): """ Prueba el algoritmo de temple simulado con calendarizador exponencial """ solucion = blocales.temple_simulado(problema, lambda i: K * exp(-delta * i)) print u"\n\nUtilizando temple simulado con calendarización exponencial" print "K= ", K, " y delta= ", delta print u"\nEl costo de la solución utilizando temple simulado es ", problema.costo(solucion) print u"Y la solución es: " print solucion
def prueba_temple_simulado(problema=ProblemaNreinas(8)): costos = [ problema.costo(problema.estado_aleatorio()) for _ in range(10 * len(problema.estado_aleatorio())) ] minimo, maximo = min(costos), max(costos) T_ini = 2 * (maximo - minimo) calendarizador1 = (T_ini * math.exp(.0005 * -i) for i in range(int(1e10))) calendarizador2 = (T_ini / (i * math.log10(1 + i) + 1) for i in range(int(1e10))) print("T_ini = {} \n".format(T_ini)) """ Prueba el algoritmo de temple simulado calendarizador None """ inicio_de_tiempo = time.time() solucion = blocales.temple_simulado(problema, tol=.01) print("\n\nTemple simulado con calendarización To/(1 + i).") print("Costo de la solución: ", problema.costo(solucion)) print("Y la solución es: ") print(solucion) tiempo_final = time.time() tiempo_transcurrido = tiempo_final - inicio_de_tiempo print("\nTomo {} segundos.".format(tiempo_transcurrido)) """ Prueba el algoritmo de temple simulado calendarizador exp(-i) """ inicio_de_tiempo = time.time() solucion = blocales.temple_simulado(problema, calendarizador=calendarizador1) print("\n\nTemple simulado con calendarización To * exp.") print("Costo de la solución: ", problema.costo(solucion)) print("Y la solución es: ") print(solucion) tiempo_final = time.time() tiempo_transcurrido = tiempo_final - inicio_de_tiempo print("\nTomo {} segundos.".format(tiempo_transcurrido)) """ Prueba el algoritmo de temple simulado calendarizador log( i+1 ) """ inicio_de_tiempo = time.time() solucion = blocales.temple_simulado(problema, calendarizador=calendarizador2) print("\n\nTemple simulado con calendarización To/(i*(log(1 + i)+1) .") print("Costo de la solución: ", problema.costo(solucion)) print("Y la solución es: ") print(solucion) tiempo_final = time.time() tiempo_transcurrido = tiempo_final - inicio_de_tiempo print("\nTomo {} segundos.".format(tiempo_transcurrido))
def main(): """ La función principal """ # Vamos a definir un grafo sencillo vertices_sencillo = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] aristas_sencillo = [('B', 'G'), ('E', 'F'), ('H', 'E'), ('D', 'B'), ('H', 'G'), ('A', 'E'), ('C', 'F'), ('H', 'B'), ('F', 'A'), ('C', 'B'), ('H', 'F')] dimension = 400 # Y vamos a hacer un dibujo del grafo sin decirle como hacer para # ajustarlo. grafo_sencillo = problema_grafica_grafo(vertices_sencillo, aristas_sencillo, dimension) estado_aleatorio = grafo_sencillo.estado_aleatorio() costo_inicial = grafo_sencillo.costo(estado_aleatorio) grafo_sencillo.dibuja_grafo(estado_aleatorio, "prueba_inicial.gif") print("Costo del estado aleatorio: {}".format(costo_inicial)) # Ahora vamos a encontrar donde deben de estar los puntos t_inicial = time.time() solucion = blocales.temple_simulado(grafo_sencillo) t_final = time.time() costo_final = grafo_sencillo.costo(solucion) grafo_sencillo.dibuja_grafo(solucion, "prueba_final.gif") print("\nUtilizando la calendarización por default") print("Costo de la solución encontrada: {}".format(costo_final)) print("Tiempo de ejecución en segundos: {}".format(t_final - t_inicial)) ########################################################################## # 20 PUNTOS ########################################################################## # ¿Que valores para ajustar el temple simulado son los que mejor # resultado dan? # # ¿Que encuentras en los resultados?, ¿Cual es el criterio mas importante? # # En general para obtener mejores resultados del temple simulado, # es necesario utilizar una función de calendarización acorde con # el metodo en que se genera el vecino aleatorio. Existen en la # literatura varias combinaciones. Busca en la literatura # diferentes métodos de calendarización (al menos uno más # diferente al que se encuentra programado) y ajusta los # parámetros para que obtenga la mejor solución posible en el # menor tiempo posible. # # Escribe aqui tus conclusiones # # ------ IMPLEMENTA AQUI TU CÓDIGO --------------------------------------- # """
def prueba_temple_simulado(problema=ProblemaNreinas(8),calendarizacion=None): """ Prueba el algoritmo de temple simulado """ start = time.time() solucion = blocales.temple_simulado(problema,calendarizacion) #print("\n\nTemple simulado con calendarización To/(1 + i).") print("Costo de la solución: ", problema.costo(solucion)) print("Y la solución es: ") print(solucion) end = time.time() print("Tiempo que tarda: Segundos..: " + str(end - start))
def prueba_temple_simulado_lineal(problema=ProblemaNreinas(8)): """ Prueba el algoritmo de temple simulado """ solucion = blocales.temple_simulado( problema, calendarizador=(problema.n - i / 3 for i in range(int(1e10)))) print("\n\nTemple simulado con calendarización (To - i).") print("Costo de la solución: ", problema.costo(solucion)) print("Y la solución es: ") print(solucion)
def main(): """ La función principal """ # Vamos a definir un grafo sencillo vertices_sencillo = ['A', 'B', 'C', 'D', 'E', 'F'] aristas_sencillo = [('A', 'B'), ('A', 'C'), ('A', 'D'), ('A', 'E'), ('A', 'F'), ('B', 'C'), ('B', 'D'), ('B', 'E'), ('B', 'F'), ('C', 'D'), ('C', 'E'), ('C', 'F'), ('D', 'E'), ('D', 'F'), ('E', 'F'),] dimension = 400 # Y vamos a hacer un dibujo del grafo sin decirle como hacer para # ajustarlo. def calendarizador_logaritmico(Temp,k=.05): while True: Temp=Temp/math.log(k+1); yield Temp; def calendarizador_kirkpatrick(temp,alpha=0.9999): T=temp while True: yield T T=alpha*T grafo_sencillo = problema_grafica_grafo(vertices_sencillo, aristas_sencillo, dimension) estado_aleatorio = grafo_sencillo.estado_aleatorio() costo_inicial = grafo_sencillo.costo(estado_aleatorio) grafo_sencillo.dibuja_grafo(estado_aleatorio, "prueba_inicial.gif") print("Costo del estado aleatorio: {}".format(costo_inicial)) # Ahora vamos a encontrar donde deben de estar los puntos t_inicial = time.time() solucion = blocales.temple_simulado(grafo_sencillo,calendarizador_kirkpatrick(10),.001) t_final = time.time() costo_final = grafo_sencillo.costo(solucion) grafo_sencillo.dibuja_grafo(solucion, "prueba_final.gif") print("\nUtilizando la calendarización por default") print("Costo de la solución encontrada: {}".format(costo_final)) print("Tiempo de ejecución en segundos: {}".format(t_final - t_inicial))
def prueba_temple_simulado(problema=ProblemaNreinas(8), K=100, delta=0.01): """ Prueba el algoritmo de temple simulado con calendarizador exponencial """ solucion = blocales.temple_simulado(problema, lambda i: K * exp(-delta * i)) print u"\n\nUtilizando temple simulado con calendarización exponencial" print "K= ", K, " y delta= ", delta print u"\nEl costo de la solución utilizando temple simulado es ", problema.costo( solucion) print u"Y la solución es: " print solucion
def main(): """ La función principal """ # Vamos a definir un grafo sencillo vertices_sencillo = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] aristas_sencillo = [('B', 'G'), ('E', 'F'), ('H', 'E'), ('D', 'B'), ('H', 'G'), ('A', 'E'), ('C', 'F'), ('H', 'B'), ('F', 'A'), ('C', 'B'), ('H', 'F') ] # vertices_sencillo = ['A', 'B', 'C'] # aristas_sencillo = [('A', 'B'), ('A', 'C'), ('B', 'C')] dimension = 400 # Y vamos a hacer un dibujo del grafo sin decirle como hacer para # ajustarlo. grafo_sencillo = problema_grafica_grafo( vertices_sencillo, aristas_sencillo, dimension) estado_aleatorio = grafo_sencillo.estado_aleatorio() grafo_sencillo.dibuja_grafo(estado_aleatorio) print "Costo del estado aleatorio: ", grafo_sencillo.costo(estado_aleatorio) # Ahora vamos a encontrar donde deben de estar los puntos tiempo_inicial = time.time() solucion = blocales.temple_simulado( grafo_sencillo, lambda i: 1000 * math.exp(-0.0001 * i)) tiempo_final = time.time() grafo_sencillo.dibuja_grafo(solucion) print "\nUtilizando una calendarización exponencial con K = 1000 y delta = 0.0001" print "Costo de la solución encontrada: ", grafo_sencillo.costo(solucion) print "Tiempo de ejecución en segundos: ", tiempo_final - tiempo_inicial ########################################################################## # 20 PUNTOS ########################################################################## # ¿Que valores para ajustar el temple simulado (T0 y K) son los que mejor resultado dan? # # ¿Que encuentras en los resultados?, ¿Cual es el criterio mas importante? # """
def prueba_temple_simulado_2( problema=ProblemaNreinas(8), calendarización=None): """ Prueba el algoritmo de temple simulado """ solucion = blocales.temple_simulado(problema, calendarización) if calendarización is None: print("\n\nTemple simulado con calendarización To/(1 + i).") elif calendarización is "Logaritmo": print("\n\nTemple simulado con calendarización T_ini/(1 + i*log(i)).") elif calendarización is "Exponencial": print("\n\nTemple simulado con calendarización T_ini * exp(-tol*i).") print("Costo de la solución: ", problema.costo(solucion)) print("Y la solución es: ") print(solucion)
def main(): """ La función principal """ # Vamos a definir un grafo sencillo vertices_sencillo = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] aristas_sencillo = [('B', 'G'), ('E', 'F'), ('H', 'E'), ('D', 'B'), ('H', 'G'), ('A', 'E'), ('C', 'F'), ('H', 'B'), ('F', 'A'), ('C', 'B'), ('H', 'F')] """ vertices_sencillo = ['A','B','C'] aristas_sencillo = [('A','B'),('A','C')] """ dimension = 400 # Y vamos a hacer un dibujo del grafo sin decirle como hacer para # ajustarlo. grafo_sencillo = problema_grafica_grafo( vertices_sencillo, aristas_sencillo, dimension) estado_aleatorio = grafo_sencillo.estado_aleatorio() grafo_sencillo.dibuja_grafo(estado_aleatorio) print "Costo del estado aleatorio: ", grafo_sencillo.costo(estado_aleatorio) # Ahora vamos a encontrar donde deben de estar los puntos tiempo_inicial = time.time() solucion = blocales.temple_simulado( # k = 100, d = .0001 grafo_sencillo, lambda i: (100*abs(math.sin(i)))/(i+1) + 0.001) #lambda i: 1000 * math.exp(-0.0001 * i)) tiempo_final = time.time() grafo_sencillo.dibuja_grafo(solucion) print "\nUtilizando una calendarización senoidal con K = 100 y delta = 0.001" print "Costo de la solución encontrada: ", grafo_sencillo.costo(solucion) print "Tiempo de ejecución en segundos: ", tiempo_final - tiempo_inicial
def main(): """ La función principal """ # Vamos a definir un grafo sencillo vertices_sencillo = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] aristas_sencillo = [('B', 'G'), ('E', 'F'), ('H', 'E'), ('D', 'B'), ('H', 'G'), ('A', 'E'), ('C', 'F'), ('H', 'B'), ('F', 'A'), ('C', 'B'), ('H', 'F'), ('D', 'F')] dimension = 400 # Y vamos a hacer un dibujo del grafo sin decirle como hacer para # ajustarlo. grafo_sencillo = problema_grafica_grafo(vertices_sencillo, aristas_sencillo, dimension) estado_aleatorio = grafo_sencillo.estado_aleatorio() costo_inicial = grafo_sencillo.costo(estado_aleatorio) grafo_sencillo.dibuja_grafo(estado_aleatorio, "prueba_inicial.gif") print("Costo del estado aleatorio: {}".format(costo_inicial)) costos = [ grafo_sencillo.costo(grafo_sencillo.estado_aleatorio()) for _ in range(10 * len(grafo_sencillo.estado_aleatorio())) ] minimo, maximo = min(costos), max(costos) T_ini = 2 * (maximo - minimo) #calendarizador1 = (T_ini * math.exp(.0005 * -i) for i in range(int(1e10))) calendarizador2 = (T_ini / (i * math.log10(1 + i) + 1) for i in range(int(1e10))) print("T_ini = {} \n".format(T_ini)) # Ahora vamos a encontrar donde deben de estar los puntos t_inicial = time.time() solucion = blocales.temple_simulado(grafo_sencillo, calendarizador=calendarizador2, tol=.00001) t_final = time.time() costo_final = grafo_sencillo.costo(solucion) grafo_sencillo.dibuja_grafo(solucion, "prueba_final.gif") print("\nUtilizando la calendarización por default") print("Costo de la solución encontrada: {}".format(costo_final)) print("Tiempo de ejecución en segundos: {}".format(t_final - t_inicial))
def main(): """ La función principal """ # Vamos a definir un grafo sencillo vertices_sencillo = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] aristas_sencillo = [('B', 'G'), ('E', 'F'), ('H', 'E'), ('D', 'B'), ('H', 'G'), ('A', 'E'), ('C', 'F'), ('H', 'B'), ('F', 'A'), ('C', 'B'), ('H', 'F')] dimension = 400 # Y vamos a hacer un dibujo del grafo sin decirle como hacer para # ajustarlo. grafo_sencillo = problema_grafica_grafo( vertices_sencillo, aristas_sencillo, dimension) estado_aleatorio = grafo_sencillo.estado_aleatorio() grafo_sencillo.dibuja_grafo(estado_aleatorio) print "Costo del estado aleatorio: " grafo_sencillo.costo(estado_aleatorio, True) # Ahora vamos a encontrar donde deben de estar los puntos tiempo_inicial = time.time() K, delta = 1000, 0.01 print "\nUtilizando una calendarización lineal con K = ", K, " y delta = ", delta solucion = blocales.temple_simulado( grafo_sencillo, lambda i: calen_lineal(K, delta, i)) tiempo_final = time.time() grafo_sencillo.dibuja_grafo(solucion) print "Costo de la solución encontrada: " grafo_sencillo.costo(solucion, True) print "Tiempo de ejecución en segundos: ", tiempo_final - tiempo_inicial
for n in (8, 16, 32, 50, 64, 70, 80, 85, 90): print("Prueba de descenso de colinas para: " + str(n) + " reinas.") prueba_descenso_colinas(ProblemaNreinas(n), 10) n = 150 problema = ProblemaNreinas(n) prueba_temple_simulado(problema) costos = [ problema.costo(problema.estado_aleatorio()) for _ in range(10 * len(problema.estado_aleatorio())) ] minimo, maximo = min(costos), max(costos) T_ini = 20 * (maximo - minimo) cal1 = (T_ini / (0.01 * x**2) for x in range(1, int(1e10))) cal2 = (T_ini * (0.99**x) for x in range(1, int(1e10))) for cal, texto in zip((cal1, cal2), ("To/(0.01x^2)", "To * 0.99^x")): t_inicial = time() solucion = blocales.temple_simulado(problema, cal) t_final = time() print("\n\nTemple simulado con calendarización: " + texto + ".") print("Costo de la solución: ", problema.costo(solucion)) print("La solución es: ") print(solucion) print("Calculada en: " + str(t_final - t_inicial))
def main(): """ La función principal """ # Vamos a definir un grafo sencillo vertices_sencillo = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] aristas_sencillo = [('B', 'G'), ('E', 'F'), ('H', 'E'), ('D', 'B'), ('H', 'G'), ('A', 'E'), ('C', 'F'), ('H', 'B'), ('F', 'A'), ('C', 'B'), ('H', 'F')] dimension = 400 # Y vamos a hacer un dibujo del grafo sin decirle como hacer para # ajustarlo. grafo_sencillo = problema_grafica_grafo( vertices_sencillo, aristas_sencillo, dimension) estado_aleatorio = grafo_sencillo.estado_aleatorio() grafo_sencillo.dibuja_grafo(estado_aleatorio) print "Costo del estado aleatorio: ", grafo_sencillo.costo(estado_aleatorio) # Ahora vamos a encontrar donde deben de estar los puntos """ tiempo_inicial = time.time() solucion = blocales.temple_simulado( grafo_sencillo, lambda i: 1000 * math.exp(-0.0010 * i)) tiempo_final = time.time() grafo_sencillo.dibuja_grafo(solucion) print "\nUtilizando una calendarización exponencial con K = 1000 y delta = 0.0001" print "Costo de la solución encontrada: ", grafo_sencillo.costo(solucion) print "Tiempo de ejecución en segundos: ", tiempo_final - tiempo_inicial """ ########################################################################## # 20 PUNTOS ########################################################################## # ¿Que valores para ajustar el temple simulado (T0 y K) son los que mejor resultado dan? # # Pues en cuanto a resultados las variaciones que hice me arrojan buenos grafos la diferencia importante # se noto en el tiempo. Aumente el T0 y tardaba demasiado tiempo. al delta lo reduje y me arrojaba grafos # con costo mayor a cero pero "bonitos". El ajuste que me gusto fue el original con una variacion en el delta # al cual le puse el valor de 0.0010. El ajuste inicial tardaba mas de un minuto y en todas las corridas que hice # me dio un costo de cero. Pero en el nuevo ajuste se hacen los grafos con costo cero y en un tiempo menor a diez segundos. # # ¿Que encuentras en los resultados?, ¿Cual es el criterio mas importante? # # Me gustan los resultados, el criterio mas importante a mi parecer es el angulo entre aristas se me hace que se ven # muy mal los grafos sin este criterio. ########################################################################## # 20 PUNTOS ########################################################################## # En general para obtener mejores resultados del temple simulado, es necesario utilizar una # función de calendarización acorde con el metodo en que se genera el vecino aleatorio. # Existen en la literatura varias combinaciones. Busca en la literatura diferentes métodos de # calendarización (al menos uno más diferente al exponencial) y ajusta los parámetros # para que obtenga la mejor solución posible en el menor tiempo posible. # # Escribe aqui tus comentarios y prueba otro metodo de claendarización para compararlo con el # exponencial. # # Pues no me gustaron los resultados con el calendarizador de boltzmann me arroja # grafos con costo cero pero no tan "bonitos" que con el temple simulado se nota bastante la forma # en como se forman los vecinos. Estuve probando varios ajustes # para reducir el tiempo. Probe aumentar el delta pero al aumentarlo me daba grafos con costos mayor a cero. # el mejor delta que pude encontrar es con valor de 0.15 en el cual me da grafos con costo cero pero con tiempo # entre treinta y cuarenta segundos. igual adjunto dos imagenes de los grafos obtenidos. El de boltzmann # con costo cero tardo 37 segundos y el exponencial con costo cero tardo 8 segundos. # # ------ IMPLEMENTA AQUI TU CÓDIGO --------------------------------------- # #""" #""" tiempo_inicial = time.time() solucion = blocales.temple_simulado( grafo_sencillo, lambda i: cal_boltzmann(i, 1000, 0.15)) tiempo_final = time.time() grafo_sencillo.dibuja_grafo(solucion) print "\nUtilizando una calendarización boltzmann con K = 1000 y delta = 0.15" print "Costo de la solución encontrada: ", grafo_sencillo.costo(solucion) print "Tiempo de ejecución en segundos: ", tiempo_final - tiempo_inicial
def main(): """ La función principal """ # Vamos a definir un grafo sencillo vertices_sencillo = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] aristas_sencillo = [('B', 'G'), ('E', 'F'), ('H', 'E'), ('D', 'B'), ('H', 'G'), ('A', 'E'), ('C', 'F'), ('H', 'B'), ('F', 'A'), ('C', 'B'), ('H', 'F')] # Y uno completo vertices_K5 = ['1', '2', '3', '4', '5'] aristas_K5 = [('1', '2'), ('1', '3'), ('1', '4'), ('1', '5'), ('2', '3'), ('2', '4'), ('2', '5'), ('3', '4'), ('3', '5'), ('4', '5')] ################################## ####### Definir grafica ######## ################################## #G_vertices = vertices_sencillo #G_aristas = aristas_sencillo G_vertices = vertices_K5 G_aristas = aristas_K5 dimension = 400 # Y vamos a hacer un dibujo del grafo sin decirle como hacer para ajustarlo. grafo_sencillo = problema_grafica_grafo(G_vertices, G_aristas, dimension) estado_aleatorio = grafo_sencillo.estado_aleatorio() grafo_sencillo.dibuja_grafo(estado_aleatorio) print "Costo del estado aleatorio: ", grafo_sencillo.costo( estado_aleatorio) # Ahora vamos a encontrar donde deben de estar los puntos tiempo_inicial = time.time() K = 1500 delta = 0.001 solucion = blocales.temple_simulado( grafo_sencillo, lambda i: 1000 / math.log( i + 2)) #lambda i: blocales.cal_expon(i, K, delta)) tiempo_final = time.time() grafo_sencillo.dibuja_grafo(solucion) print "\nUtilizando una calendarización exponencial con K = " + str( K) + " y delta = " + str(delta) print "Costo de la solución encontrada: ", grafo_sencillo.costo(solucion) print "Tiempo de ejecución en segundos: ", tiempo_final - tiempo_inicial ################################################################################################# # 20 PUNTOS ################################################################################################# # ¿Que valores para ajustar el temple simulado (Temp inicial y vel de enfriamiento) son los que mejor resultado dan? # # En clase vimos que dada una temperatura inicial dada lo suficientemente alta y una # calendarización suave se garantizaba la convergencia al óptimo. # A pesar de ello, me parece que a partir de dicha temperatura 'alta' se deja de notar gran diferencia # al aumentarse más, y cambiar la velocidad de enfriamiento da más oportunidad para obtener mejoras # ¿Que encuentras en los resultados?, ¿Cual es el criterio mas importante? # ¿De las 4 heuristicas incluidas? # Mi parecer era que la de procurar evitar ángulos chicos, pero al moverle me parecio que # obtenia mejores resultados con el que minimiza cruces ################################################################################################# # 20 PUNTOS ################################################################################################# # En general para obtener mejores resultados del temple simulado, es necesario utilizar una # función de calendarización acorde con el metodo en que se genera el vecino aleatorio. # Existen en la literatura varias combinaciones. Busca en la literatura diferentes métodos de # calendarización (al menos uno más diferente al exponencial) y ajusta los parámetros de cada # metodo para que obtenga la mejor solución posible en el menor tiempo posible. # # Escribe aqui tus comentarios y prueba otro metodo de claendarización para compararlo con el # exponencial. # Se me pide que la impemente aquí abajo, pero si lo pongo acá abajo no me corre, asi que # en mis pruebas lo puse como una lambda arriba (en la llamada de la funcion temple_simulado) # # Usé como alternativa el boltzman, pero me dio (significativamente mucho) # menor rendimiento que la calendarización exponencial # # ------ IMPLEMENTA AQUI TU CÓDIGO ------------------------------------------------------------------------ # def boltzman(iteracion): Tmax = 1000 return Tmax / math.log(iteracion + 2)
def main(): """ La función principal """ # Vamos a definir un grafo sencillo vertices_sencillo = [ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M' ] aristas_sencillo = [('B', 'G'), ('E', 'F'), ('H', 'E'), ('D', 'B'), ('H', 'G'), ('A', 'E'), ('C', 'F'), ('H', 'B'), ('F', 'A'), ('C', 'B'), ('H', 'F'), ('H', 'I'), ('H', 'J'), ('H', 'K'), ('H', 'L'), ('H', 'M'), ('I', 'J'), ('I', 'K'), ('I', 'L'), ('I', 'M'), ('J', 'K'), ('J', 'L'), ('J', 'M'), ('K', 'L'), ('K', 'M'), ('L', 'M'), ('M', 'A')] dimension = 400 # Y vamos a hacer un dibujo del grafo sin decirle como hacer para # ajustarlo. grafo_sencillo = problema_grafica_grafo(vertices_sencillo, aristas_sencillo, dimension) estado_aleatorio = grafo_sencillo.estado_aleatorio() costo_inicial = grafo_sencillo.costo(estado_aleatorio) grafo_sencillo.dibuja_grafo(estado_aleatorio, "prueba_inicial.gif") print("Costo del estado aleatorio: {}".format(costo_inicial)) # Utilizando la calendarización default t_inicial = time.time() solucion = blocales.temple_simulado(grafo_sencillo) t_final = time.time() costo_final = grafo_sencillo.costo(solucion) grafo_sencillo.dibuja_grafo(solucion, "prueba_final.gif") print("\nUtilizando la calendarización por default") print("Costo de la solución encontrada: {}".format(costo_final)) print("Tiempo de ejecución en segundos: {}".format(t_final - t_inicial)) #Utilizando calendarización logaritmica t_inicial = time.time() solucion = blocales.temple_simulado( grafo_sencillo, calendarizacionLogartmica(grafo_sencillo)) t_final = time.time() costo_final_log = grafo_sencillo.costo(solucion) grafo_sencillo.dibuja_grafo(solucion, "prueba_log.gif") print("\nUtilizando la calendarización logaritmica") print("Costo de la solución encontrada: {}".format(costo_final_log)) print("Tiempo de ejecución en segundos: {}".format(t_final - t_inicial)) #Utilizando calendarización cuadratica t_inicial = time.time() solucion = blocales.temple_simulado( grafo_sencillo, calendarizacionCuadratica(grafo_sencillo)) t_final = time.time() costo_final_cuad = grafo_sencillo.costo(solucion) grafo_sencillo.dibuja_grafo(solucion, "prueba_cuad.gif") print("\nUtilizando la calendarización cuadrática") print("Costo de la solución encontrada: {}".format(costo_final_cuad)) print("Tiempo de ejecución en segundos: {}".format(t_final - t_inicial))
def main(): """ La función principal """ # Vamos a definir un grafo sencillo vertices_completo = ['A', 'B', 'C', 'D', 'E'] aristas_completo = [ ('A', 'B'), ('A', 'C'), ('A', 'D'), ('A', 'E'), ('B', 'C'), ('B', 'D'), ('B', 'E'), ('C', 'D'), ('C', 'E'), ('D', 'E'), ] vertices_sencillo = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] aristas_sencillo = [('B', 'G'), ('E', 'F'), ('H', 'E'), ('D', 'B'), ('H', 'G'), ('A', 'E'), ('C', 'F'), ('H', 'B'), ('F', 'A'), ('C', 'B'), ('H', 'F')] dimension = 400 # Y vamos a hacer un dibujo del grafo sin decirle como hacer para # ajustarlo. grafo_sencillo = problema_grafica_grafo(vertices_sencillo, aristas_sencillo, dimension) #grafo_sencillo = problema_grafica_grafo(vertices_completo, # aristas_completo, # dimension) estado_aleatorio = grafo_sencillo.estado_aleatorio() costo_inicial = grafo_sencillo.costo(estado_aleatorio) grafo_sencillo.dibuja_grafo(estado_aleatorio, "prueba_inicial.gif") print("Costo del estado aleatorio: {}".format(costo_inicial)) # Ahora vamos a encontrar donde deben de estar los puntos """t_inicial = time.time() solucion = blocales.temple_simulado(grafo_sencillo) t_final = time.time() costo_final = grafo_sencillo.costo(solucion) """ t_inicial = time.time() solucion = blocales.temple_simulado(grafo_sencillo, calendarizadorExp()) t_final = time.time() costo_final = grafo_sencillo.costo(solucion) grafo_sencillo.dibuja_grafo(solucion, "prueba_final.gif") print("\nUtilizando la calendarización exponencial") print("Costo de la solucion encontrada: {}".format(costo_final)) print("Tiempo de ejecucion en segundos: {}".format(t_final - t_inicial)) ########################################################################## # 20 PUNTOS ########################################################################## # ¿Que valores para ajustar el temple simulado son los que mejor # resultado dan? """ Cambiar de calendarizador por defaul por uno exponencial, en promedio tardaba al rededor de 15-20 minutos para poder terminar de encontrar la solucion del grafo. Ahora con la calendarizacion exponencial no pasa de los 2 -3 minutos en promedio. Y al cambiar la funcion de vecino aleatorio se redujo a segundos!! """ # ¿Que encuentras en los resultados?, ¿Cual es el criterio mas importante? """
def main(): """ La función principal """ # Vamos a definir un grafo sencillo vertices_sencillo = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] aristas_sencillo = [('B', 'G'), ('E', 'F'), ('H', 'E'), ('D', 'B'), ('H', 'G'), ('A', 'E'), ('C', 'F'), ('H', 'B'), ('F', 'A'), ('C', 'B'), ('H', 'F')] # Y uno completo vertices_K5 = ['1','2','3','4','5'] aristas_K5 = [('1','2'), ('1','3'), ('1','4'), ('1','5'), ('2','3'), ('2','4'), ('2','5'), ('3','4'), ('3','5'), ('4','5')] ################################## ####### Definir grafica ######## ################################## #G_vertices = vertices_sencillo #G_aristas = aristas_sencillo G_vertices = vertices_K5 G_aristas = aristas_K5 dimension = 400 # Y vamos a hacer un dibujo del grafo sin decirle como hacer para ajustarlo. grafo_sencillo = problema_grafica_grafo(G_vertices, G_aristas, dimension) estado_aleatorio = grafo_sencillo.estado_aleatorio() grafo_sencillo.dibuja_grafo(estado_aleatorio) print "Costo del estado aleatorio: ", grafo_sencillo.costo(estado_aleatorio) # Ahora vamos a encontrar donde deben de estar los puntos tiempo_inicial = time.time() K = 1500 delta = 0.001 solucion = blocales.temple_simulado(grafo_sencillo, lambda i: 1000/math.log(i+2))#lambda i: blocales.cal_expon(i, K, delta)) tiempo_final = time.time() grafo_sencillo.dibuja_grafo(solucion) print "\nUtilizando una calendarización exponencial con K = " + str(K) + " y delta = " + str(delta) print "Costo de la solución encontrada: ", grafo_sencillo.costo(solucion) print "Tiempo de ejecución en segundos: ", tiempo_final - tiempo_inicial ################################################################################################# # 20 PUNTOS ################################################################################################# # ¿Que valores para ajustar el temple simulado (Temp inicial y vel de enfriamiento) son los que mejor resultado dan? # # En clase vimos que dada una temperatura inicial dada lo suficientemente alta y una # calendarización suave se garantizaba la convergencia al óptimo. # A pesar de ello, me parece que a partir de dicha temperatura 'alta' se deja de notar gran diferencia # al aumentarse más, y cambiar la velocidad de enfriamiento da más oportunidad para obtener mejoras # ¿Que encuentras en los resultados?, ¿Cual es el criterio mas importante? # ¿De las 4 heuristicas incluidas? # Mi parecer era que la de procurar evitar ángulos chicos, pero al moverle me parecio que # obtenia mejores resultados con el que minimiza cruces ################################################################################################# # 20 PUNTOS ################################################################################################# # En general para obtener mejores resultados del temple simulado, es necesario utilizar una # función de calendarización acorde con el metodo en que se genera el vecino aleatorio. # Existen en la literatura varias combinaciones. Busca en la literatura diferentes métodos de # calendarización (al menos uno más diferente al exponencial) y ajusta los parámetros de cada # metodo para que obtenga la mejor solución posible en el menor tiempo posible. # # Escribe aqui tus comentarios y prueba otro metodo de claendarización para compararlo con el # exponencial. # Se me pide que la impemente aquí abajo, pero si lo pongo acá abajo no me corre, asi que # en mis pruebas lo puse como una lambda arriba (en la llamada de la funcion temple_simulado) # # Usé como alternativa el boltzman, pero me dio (significativamente mucho) # menor rendimiento que la calendarización exponencial # # ------ IMPLEMENTA AQUI TU CÓDIGO ------------------------------------------------------------------------ # def boltzman(iteracion): Tmax = 1000 return Tmax/math.log(iteracion+2)
# ------ IMPLEMENTA AQUI TU CÓDIGO --------------------------------------- # #Pruebas originales propuesta por Julio Waissman #prueba_descenso_colinas(ProblemaNreinas(32), 10) #prueba_temple_simulado(ProblemaNreinas(32)) n = 64 # cantidad de reinas a resolver problema_reinas = ProblemaNreinas(n) prueba_temple_simulado(problema_reinas) costos = [ problema_reinas.costo(problema_reinas.estado_aleatorio()) for _ in range(10 * len(problema_reinas.estado_aleatorio())) ] # aumentamos la cantidad de costos generados minimo, maximo = min(costos), max(costos) t_inicial = 2 * (maximo - minimo) # generadores cal_1 = (t_inicial / (0.01 * i) for i in range(1, int(1e10))) cal_2 = (t_inicial * (0.9 * i) for i in range(1, int(1e10))) for cal in (cal_1, cal_2): resultado = blocales.temple_simulado(problema_reinas, cal) print("Costo del resultado: ", problema_reinas.costo(resultado)) print("Resultado: ") print(resultado)
def main(): """ La función principal """ # Vamos a definir un grafo sencillo vertices_sencillo = [ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M' ] aristas_sencillo = [('B', 'G'), ('E', 'F'), ('H', 'E'), ('D', 'B'), ('H', 'G'), ('A', 'E'), ('C', 'F'), ('H', 'B'), ('F', 'A'), ('C', 'B'), ('H', 'F'), ('H', 'I'), ('H', 'J'), ('H', 'K'), ('H', 'L'), ('H', 'M'), ('I', 'J'), ('I', 'K'), ('I', 'L'), ('I', 'M'), ('J', 'K'), ('J', 'L'), ('J', 'M'), ('K', 'L'), ('K', 'M'), ('L', 'M'), ('M', 'A')] dimension = 400 # Y vamos a hacer un dibujo del grafo sin decirle como hacer para # ajustarlo. grafo_sencillo = problema_grafica_grafo(vertices_sencillo, aristas_sencillo, dimension) estado_aleatorio = grafo_sencillo.estado_aleatorio() costo_inicial = grafo_sencillo.costo(estado_aleatorio) grafo_sencillo.dibuja_grafo(estado_aleatorio, "prueba_inicial.gif") print("Costo del estado aleatorio: {}".format(costo_inicial)) # Ahora vamos a encontrar donde deben de estar los puntos ## t_inicial = time.time() ## solucion = blocales.temple_simulado(grafo_sencillo, calen) ## t_final = time.time() ## costo_final = grafo_sencillo.costo(solucion) ## ## grafo_sencillo.dibuja_grafo(solucion, "prueba_final.gif") ## print("\nUtilizando la calendarización por default") ## print("Costo de la solución encontrada: {}".format(costo_final)) ## print("Tiempo de ejecución en segundos: {}".format(t_final - t_inicial)) ########################################################################## # 20 PUNTOS ########################################################################## # ¿Que valores para ajustar el temple simulado son los que mejor # resultado dan? # # ¿Que encuentras en los resultados?, ¿Cual es el criterio mas importante? # # En general para obtener mejores resultados del temple simulado, # es necesario utilizar una función de calendarización acorde con # el metodo en que se genera el vecino aleatorio. Existen en la # literatura varias combinaciones. Busca en la literatura # diferentes métodos de calendarización (al menos uno más # diferente al que se encuentra programado) y ajusta los # parámetros para que obtenga la mejor solución posible en el # menor tiempo posible. # # Escribe aqui tus conclusiones # # RESPUESTA: # La calendarización exponential_multiplicative_cooling fue la que mejor # funcionó. Se tuvo que establecer una temperatura inicial de 40 para # que el programa obtuviera un resultado aceptable en un tiempo razonable. # # En el resultado de la imagen final se puede apreciar una diferencia # importante en cuanto a la estética del grafo. Tal vez no sea perfecto # pero se ve mucho mejor que la imagen inicial. # # El criterio más importante probablemente sea la separación entre # vértices, ya que influye de alguna manera en todos los demás. Al # estar los vértices separados, las aristas se pueden distinguir mejor. # # ------ IMPLEMENTA AQUI TU CÓDIGO --------------------------------------- # calen = blocales.exponential_multiplicative_cooling(40, 0.999, 1e10) #calen = blocales.calendarizador_uno(0.7, 0.001, 1e6) t_inicial = time.time() solucion = blocales.temple_simulado(grafo_sencillo, calen) t_final = time.time() costo_final = grafo_sencillo.costo(solucion) grafo_sencillo.dibuja_grafo(solucion, "prueba_final.gif") print( "\nUtilizando la calendarización exponential_multiplicative_cooling.") #print("\nUtilizando la calendarización calendarizador_uno.") print("Costo de la solución encontrada: {}".format(costo_final)) print("Tiempo de ejecución en segundos: {}".format(t_final - t_inicial))
def main(): """ La función principal """ # Vamos a definir un grafo sencillo vertices_sencillo = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] aristas_sencillo = [('B', 'G'), ('E', 'F'), ('H', 'E'), ('D', 'B'), ('H', 'G'), ('A', 'E'), ('C', 'F'), ('H', 'B'), ('F', 'A'), ('C', 'B'), ('H', 'F')] dimension = 400 # Y vamos a hacer un dibujo del grafo sin decirle como hacer para # ajustarlo. grafo_sencillo = problema_grafica_grafo(vertices_sencillo, aristas_sencillo, dimension) estado_aleatorio = grafo_sencillo.estado_aleatorio() costo_inicial = grafo_sencillo.costo(estado_aleatorio) grafo_sencillo.dibuja_grafo(estado_aleatorio, "prueba_inicial.gif") print("Costo del estado aleatorio: {}".format(costo_inicial)) # Ahora vamos a encontrar donde deben de estar los puntos t_inicial = time.time() solucion = blocales.temple_simulado(grafo_sencillo) t_final = time.time() costo_final = grafo_sencillo.costo(solucion) grafo_sencillo.dibuja_grafo(solucion, "prueba_final.gif") print("\nUtilizando la calendarización por default") print("Costo de la solución encontrada: {}".format(costo_final)) print("Tiempo de ejecución en segundos: {}".format(t_final - t_inicial)) ########################################################################## # 20 PUNTOS ########################################################################## # ¿Que valores para ajustar el temple simulado son los que mejor # resultado dan? # la celnderizacion por default me da buenos resultados, dado un grafo aceptable # en un tiempo bastante corot ~20 segundos, un buen manejo de las restricciones # da como resultado que el calendarizador no importe tanto # # ¿Que encuentras en los resultados?, ¿Cual es el criterio mas importante? # Considero que el criterio mas importante son los valores K1,K2,K3,K4 porque # la solucion consiste de ellos, los grafos son afectados seriamente por estos valores # y mas que su costo en si, importa la relacion entre ellos, que caracteristicas consideras # mas "bonita". El conjunto de belleza es mas bello que sus partes. # # En general para obtener mejores resultados del temple simulado, # es necesario utilizar una función de calendarización acorde con # el metodo en que se genera el vecino aleatorio. Existen en la # literatura varias combinaciones. Busca en la literatura # diferentes métodos de calendarización (al menos uno más # diferente al que se encuentra programado) y ajusta los # parámetros para que obtenga la mejor solución posible en el # menor tiempo posible. # # Escribe aqui tus conclusiones """ Salidad de la calendarización Costo del estado aleatorio: 29.9707733174632 Utilizando la calendarización por default Costo de la solución encontrada: 1.6522095809127912 Tiempo de ejecución en segundos: 11.915760278701782 Calendarizacion propia Utilizando la calendarización propia Costo de la solución encontrada: 0.0 Tiempo de ejecución en segundos: 1634.9749228954315 El resultado sigue siendo estetico, la calendarización por default funciona bien. """ # # ------ IMPLEMENTA AQUI TU CÓDIGO --------------------------------------- # #Ahora vamos a encontrar donde deben de estar los puntos print("Calendarizacion propia") def calendarizador(): costos = [ grafo_sencillo.costo(grafo_sencillo.estado_aleatorio()) for _ in range(10 * len(grafo_sencillo.estado_aleatorio())) ] # aumentamos la cantidad de costos generados minimo, maximo = min(costos), max(costos) t_inicial = 2 * (maximo - minimo) # generadores return (t_inicial / (0.01 * i) for i in range(1, int(1e10))) t_inicial = time.time() solucion = blocales.temple_simulado(grafo_sencillo, calendarizador()) t_final = time.time() costo_final = grafo_sencillo.costo(solucion) grafo_sencillo.dibuja_grafo(solucion, "prueba_final_nuevoCal.gif") print("\nUtilizando la calendarización propia") print("Costo de la solución encontrada: {}".format(costo_final)) print("Tiempo de ejecución en segundos: {}".format(t_final - t_inicial))
def main(): """ La función principal """ # Vamos a definir un grafo sencillo vertices_sencillo = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] aristas_sencillo = [('B', 'G'), ('E', 'F'), ('H', 'E'), ('D', 'B'), ('H', 'G'), ('A', 'E'), ('C', 'F'), ('H', 'B'), ('F', 'A'), ('C', 'B'), ('H', 'F')] dimension = 400 # Y vamos a hacer un dibujo del grafo sin decirle como hacer para # ajustarlo. grafo_sencillo = problema_grafica_grafo(vertices_sencillo, aristas_sencillo, dimension) estado_aleatorio = grafo_sencillo.estado_aleatorio() costo_inicial = grafo_sencillo.costo(estado_aleatorio) grafo_sencillo.dibuja_grafo(estado_aleatorio, "prueba_inicial.gif") print("Costo del estado aleatorio: {}".format(costo_inicial)) ########################################################################## # 20 PUNTOS ########################################################################## # ¿Que valores para ajustar el temple simulado son los que mejor # resultado dan? # # ¿Que encuentras en los resultados?, ¿Cual es el criterio mas importante? # # En general para obtener mejores resultados del temple simulado, # es necesario utilizar una función de calendarización acorde con # el metodo en que se genera el vecino aleatorio. Existen en la # literatura varias combinaciones. Busca en la literatura # diferentes métodos de calendarización (al menos uno más # diferente al que se encuentra programado) y ajusta los # parámetros para que obtenga la mejor solución posible en el # menor tiempo posible. # # Escribe aqui tus conclusiones # # Si se utiliza una tolerancia más pequeña que la predeterminada, se # obtienen resultados parecidos. Al usar una tolerancia más grande, # ni se minimiza el tiempo ni se mejoran los resultados. # # La calendarización es el parámetro más importante para el temple # simulado, por que es el que dicta como realizará el movimiento # hacia arriba de la búsqueda. Con una calendarización exponencial # consigue resultados excelentes en menos de un segundo para el grafo # sencillo, claro, tomando en cuenta el resto de las modificaciones # hechas a los vecinos y al costo. # # ------ IMPLEMENTA AQUI TU CÓDIGO --------------------------------------- # costos = [grafo_sencillo.costo(grafo_sencillo.estado_aleatorio()) for _ in range(10 * len(grafo_sencillo.estado_aleatorio()))] minimo, maximo = min(costos), max(costos) T_ini = 15 * (maximo - minimo) calen_exp = ((T_ini * (0.99**x) for x in range(1, int(1e10)))) t_inicial = time.time() solucion = blocales.temple_simulado(grafo_sencillo, calen_exp) t_final = time.time() costo_final = grafo_sencillo.costo(solucion) grafo_sencillo.dibuja_grafo(solucion, "prueba_final.gif") print("\nUtilizando una calendarización exponencial.") print("Costo de la solución encontrada: {}".format(costo_final)) print("Tiempo de ejecución en segundos: {}".format(t_final - t_inicial))