def timed(*args, **kw):
ts = time.perf_counter()
result = method(*args, **kw)
te = time.perf_counter()
duration = timedelta(seconds=te - ts)
print(f"{method.__name__}: {duration}")
return result
def main_heuristicoB(tabla_distancias):
t0 = time.perf_counter()
menor_distancia = 99999999999
for i in range(len(tabla_distancias)):
recorrido_actual = []
recorrido_actual.append(i)
distancia_recorrida = 0
tabla_auxiliar = tabla_distancias[i].copy(
) #inicializar tabla auxiliar
while len(recorrido_actual) < len(
tabla_distancias): # len(tabla_distancias) -> 24
distancia_mas_cercana = tabla_auxiliar.min()
id_capital_sig = tabla_auxiliar.idxmin()
if id_capital_sig in recorrido_actual: # si verdadero, esa capital ya se visitó y por lo tanto se elimina de tabla auxiliar
tabla_auxiliar = tabla_auxiliar.drop(id_capital_sig)
else:
distancia_recorrida += distancia_mas_cercana
recorrido_actual.append(id_capital_sig)
tabla_auxiliar = tabla_distancias[id_capital_sig].copy(
) # reinicio la tabla auxiliar para que tenga todas las filas
recorrido_actual.append(i) #vuelvo a la ciudad de inicio
distancia_recorrida += tabla_distancias[recorrido_actual[-1]][
recorrido_actual[-2]] # sumo la distancia de vuelta a casa
if distancia_recorrida < menor_distancia:
menor_distancia = distancia_recorrida
menor_recorrido = recorrido_actual
tf = time.perf_counter()
tiempo_ejecucion = tf - t0
return menor_recorrido, menor_distancia, tiempo_ejecucion
def main_heuristicoA(tabla_distancias, nro_ciudad):
t0 = time.perf_counter()
recorrido = []
recorrido.append(nro_ciudad)
distancia_recorrida = 0
id_capital_sig = nro_ciudad #
tabla_auxiliar = tabla_distancias[id_capital_sig].copy(
) #inicializar tabla auxiliar
while len(recorrido) < len(
tabla_distancias): # len(tabla_distancias) -> 24
distancia_mas_cercana = tabla_auxiliar.min()
id_capital_sig = tabla_auxiliar.idxmin()
if id_capital_sig in recorrido: # si verdadero, esa capital ya se visitó y por lo tanto se elimina de tabla auxiliar
tabla_auxiliar = tabla_auxiliar.drop(id_capital_sig)
else:
distancia_recorrida += distancia_mas_cercana
recorrido.append(id_capital_sig)
tabla_auxiliar = tabla_distancias[id_capital_sig].copy(
) # reinicio la tabla auxiliar para que tenga todas las filas
recorrido.append(nro_ciudad) #vuelvo a la ciudad de inicio
distancia_recorrida += tabla_distancias[recorrido[-1]][
recorrido[-2]] # sumo la distancia de vuelta a casa
tf = time.perf_counter()
tiempo_ejecucion = tf - t0
return recorrido, distancia_recorrida, tiempo_ejecucion
def main_exhaustivo(tabla_distancias, cantidad_ciudades):
distancia_minima = 9999999999
t0 = time.perf_counter()
recorridos_posibles = generar_recorridos_posibles(cantidad_ciudades)
for recorrido in recorridos_posibles:
distancia_recorrida = funcion_objetivo(tabla_distancias, recorrido)
if distancia_recorrida < distancia_minima:
distancia_minima = distancia_recorrida
recorrido_minimo = recorrido
t1 = time.perf_counter()
tiempo_ejecucion = t1 - t0
return recorrido_minimo, distancia_minima, tiempo_ejecucion
def main_genetico(tabla_distancias,
p_crossover=0.9,
p_mutacion=0.2,
ciclos=3,
tamaño_poblacion=50,
longitud_cromosoma=25,
elitismo=True):
t0 = time.perf_counter()
poblacion_actual = inicializar(tamaño_poblacion, longitud_cromosoma)
poblaciones = []
poblaciones.append(poblacion_actual)
cantidad_selecciones = tamaño_poblacion // 2
for i in range(ciclos):
print(f'ciclo actual: {i}')
lista_poblacion = []
for id, individuo in enumerate(poblacion_actual):
lista_poblacion.append([
id, individuo,
fitness_v2(tabla_distancias, poblacion_actual, individuo)
])
lista_poblacion = sorted(lista_poblacion,
key=itemgetter(2),
reverse=True)
poblacion_nueva = []
if elitismo:
padre_1, padre_2 = seleccionar(lista_poblacion, tabla_distancias,
elitismo)
poblacion_nueva.append(padre_1)
poblacion_nueva.append(padre_2)
for j in range(cantidad_selecciones + 1):
if len(poblacion_nueva) == tamaño_poblacion:
continue
# SELECCIONAR
padre_1, padre_2 = seleccionar(lista_poblacion, tabla_distancias,
False)
# CRUZAR
if np.random.rand() <= p_crossover:
hijo_1, hijo_2 = crossover_ciclico(padre_1[:-1], padre_2[:-1])
hijo_1.append(hijo_1[0]) # para que el hijo vuelva a casa
hijo_2.append(hijo_2[0]) # para que el hijo vuelva a casa
else:
hijo_1 = padre_1
hijo_2 = padre_2
# MUTAR
if np.random.rand() <= p_mutacion:
hijo_1 = mutacion(hijo_1)
if np.random.rand() <= p_mutacion:
hijo_2 = mutacion(hijo_2)
# PASAR A PROXIMA GENERACION
poblacion_nueva.append(hijo_1)
if len(poblacion_nueva) != tamaño_poblacion:
poblacion_nueva.append(hijo_2)
poblacion_actual = poblacion_nueva
poblaciones.append(poblacion_nueva)
tf = time.perf_counter()
poblaciones_df = pd.DataFrame(poblaciones)
resultados = generar_estadisticos(poblaciones, tabla_distancias)
# generar_graficos(resultados)
tiempo_ejecucion = tf - t0
return resultados.iloc[-1, :], tiempo_ejecucion