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