CENTRO DE CIECIAS BÁSICAS

DEPARTAMENTO DE SISTEMAS DE INFORMACIÓN

MAESTRIA EN INFORMÁTICA Y TECNOLOGÍAS COMPUTACIONALES

MATERIA:
SISTEMAS DECISIONALES DE OPTIMIZACIÓN INTELIGENTE

PROYECTO FINAL: Metaheurística de recocido simulado para la

instancia GR24 del problema de TSP.

PRESENTA:
LI. Cinthya Elizabeth Pedroza Mercado
II. Adrián Emilio Caldera Hermosillo
IC. Carlos Sandoval Medina

PROFESOR:
Dra. María Dolores Torres Soto
Contenido
Manual técnico ............................................................................................................................... 3
Algoritmo general implementado.................................................................................................. 5
Introducción ................................................................................................................................ 5
Recocido simulado ....................................................................................................................... 6
Requerimientos del sistema........................................................................................................... 9
Manual de Usuario ....................................................................................................................... 10
Conclusiones ................................................................................................................................. 10
Manual técnico

El siguiente manual nos presenta información técnica sobre la aplicación generada para la
metaheurística de recocido simulado para el problema de TSP instancia GR24, así como también las
instrucciones o manual de usuario para su ejecución.

El programa realizado esta desarrollado bajo el lenguaje de programación C++, donde se

utilizó la herramienta CLion 2020.2.4 x64 como IDE de desarrollo el cual se puede obtener en
https://www.jetbrains.com/clion.

La solución se desarrolló bajo la metaheurística de recocido simulado, la cual es una técnica

algorítmica de búsqueda aleatoria para encontrar una solución óptima o cercana a la óptima en
problemas de optimización combinatoria o problemas que contienen variables discretas. Esta
técnica está basada en el proceso de recocido en la metalurgia, que es un proceso utilizado para
endurecer los metales calentándose a una temperatura alta y dejándolos enfriar gradualmente.

Los parámetros de entrada que utiliza la solución para entregar una salida son:

● Instancia TSP, para este proyecto en particular se utilizó la instancia GR24, la instancia fue
declarada directamente en el código de la solución mediante una matriz, véase la ilustración
1.
● Temperatura inicial, es el valor de la temperatura máxima a disminuir gradualmente para
buscar/generar soluciones entre cada cambio de temperatura, declarada con la variable
temp.
● Temperatura final, valor de la temperatura mínima, donde termina el proceso de búsqueda
de soluciones, declara con la variable cong.
● Factor de enfriamiento, valor en que se va a ir disminuyendo la temperatura inicial (valor
entre 0 y 1), declarada con la variable enf.
● Cantidad de iteraciones por cambio de temperatura, las veces que se van a buscar/generar
soluciones por cada cambio de temperatura, declarada con la variable K.
● Cantidad de aceptaciones por cambio de temperatura, veces que se aceptan soluciones por
cada cambio de temperatura, declarada con la variable A.

A excepción de la instancia GR24 que está declarada directamente en el código de la solución,

todos los demás parámetros de entrada son solicitados al inicio de la ejecución al usuario, esto para
que el usuario pueda estar jugando/experimentando con dichos parámetros hasta obtener los
mejores resultados.
Ilustración 1. Declaración de la instancia GR24 del problema TSP directamente en el código de la
solución.

Los salida que entrega el programa es una posible solución con el costo de dicha solución y
como información adicional el número de veces que se cumplió el paso de metrópolis, al final de la
generación de la posible solución el programa pregunta si desea volver a ejecutar el algoritmo o salir
del programa, en caso de que se seleccione la opción de volver ejecutar en varias ocasiones al final
cuando seleccionamos la opción de salir, el programa nos arroja la mejor solución generada de todas
las veces que se ejecutó el algoritmo.

Ilustración 2. Ejemplo de salida que arroja la solución.

Algoritmo general implementado

Introducción
Recocido Simulado: es una técnica de búsqueda aleatoria dirigida para encontrar una solución
óptima o cercana a la óptima en problemas de optimización combinatoria o problemas que
contienen variables discretas. Fue propuesto por Kirkpatrick, Gelatt y Vecchi en 1983. El recocido es
un proceso térmico que sirve para obtener estados de baja energía para un sólido en un baño
caliente o en fundición. El proceso consta de dos pasos:

• Aumentar la temperatura hasta un valor máximo en el que el sólido se derrita.

• Decrementar suavemente la temperatura hasta que las partículas se agrupen en el estado
fundamental del sólido (estado estable). Proceso empleado para endurecer
metales, calentándolos a una temperatura alta y luego dejándolos enfriar gradualmente

Proceso heurístico que simula el comportamiento de un grupo de átomos expuestos a un

proceso de enfriamiento. (Paso de niveles de energía alta a estados de baja energía. Minimización).

Metropolis, Rosenbluth, Rosenbluth, Teller y Teller introdujeron un algoritmo simple para

simular la evolución de un sólido en un baño caliente en 1953. El algoritmo de Metropolis puede
aplicarse a la resolución de un problema combinatorio si se realiza la siguiente analogía:

• Las soluciones del problema son equivalentes a los estados del sistema físico.
• El costo de una solución es equivalente a la energía de un estado.
• Un parámetro de control juega el papel de la temperatura

Algoritmo de Metrópolis

Regla de aceptación:

Dado un estado i con energía Ei

Se genera un nuevo estado j mediante un mecanismo de perturbación

Se calcula la energía de j, Ej

Si Ej-Ei ≤O entonces se acepta el estado j

Si no, se acepta el estado j con probabilidad

𝑬𝒊 − 𝑬𝒋
𝑷 = 𝐞𝐱𝐩⁡ ( )
𝑲𝑩 ⁡𝑻
Donde: 𝐾𝐵 es la constante de Boltzman

T es la temperatura

𝐾𝐵 ⁡𝑇: C parámetro de control

Recocido simulado
Es una iteración de algoritmos de Metrópolis.

Bajando la temperatura lo suficientemente lento y generando suficientes transiciones en

cada temperatura se puede alcanzar la configuración óptima

Una transición consiste en:

• Aplicar el mecanismo de generación

• Aplicar el criterio de aceptación (la aceptación de estados es inicialmente alta y luego
se va reduciendo)

Mecanismo de enfriamiento

Una sucesión finita de valores del parámetro de control, es decir:

• Un valor inicial del parámetro, T0

• Una función para decrementar el parámetro de control T
• Un valor final del parámetro de control T

Ilustración 3. Proceso de enfriamiento con iteraciones de 0 hasta la final para Recocido simulado.

En la ilustración 3 se aprecia el diagrama de cómo se utiliza el mecanismo de en

enfriamiento, es importante definir el número de transiciones para cada valor del parámetro de
control.
Algoritmo (versión monótona)

1. i = 𝑖0
2. T = 𝑇0
3. K = 𝐾0
4. while (condición de STOP)
5. while (k < K && a < A)
6. generar j en N(i)
7. if (c(j) – c(i) < 0) (Minimizar)
8. i=j
9. a=a+1
10. else
11. generar un número r al azar
(pseudo-random number)
12. if (r < exp [(c(i) – c(j))/T])
13. i=j
14. a=a+1
15. k=k+1
16. T = αT
17 . K = pK
18. k=0
19. a=0
20. mostrar i, c(i)

Algoritmo (versión no monótona)

1. i = 𝑖0
2. T = 𝑇0
3. K = 𝐾0
4. while (condición de STOP)
5. while (k < K && a < A)
6. generar j en N(i)
7. if (c(j) – c(i) < 0) (
8. i=j
9. a=a+1
10. else
11. generar un número r al azar
(pseudo-random number)
12. if (r < exp [(c(i) – c(j))/T])
13. i=j
14. a=a+1
15. k=k+1
16.if (a=A)
17. T = αT
18. else (k = K)
19. T=ηT
20. K = ρK
21. k=0
22. a=0
23. mostrar i, c(i)
Algoritmo recocido simulado implementado en la solución al problema TSP instancia gr24:

1. Inicio
2. Solicitar parámetros de entrada
3. Leer parámetros de entrada (temperatura inicial temp, temperatura final cong, factor de
enfriamiento enf, iteraciones por cambio de temperatura K y aceptaciones por cambio de
temperatura A)
4. Generar solución inicial aleatoria
5. Calcular costo solución inicial
6. a=0; k=0;
7. Hacer mientras temp > cong
8. Mientras a<A y k<K
9. Generar solución vecina aleatoria
10. Calcular costo solución vecina
11. Si costo solución vecina < costo solución inicial
12. solución inicial = solución vecina
13. costo solución inicial = costo solución vecina
14. a=a+1
15. Fin Si
16. Si costo solución vecina > costo solución inicial
17 . Ejecutar paso de Metrópolis (comparando el exponencial de la
diferencia de los costos divido entre la temperatura, con un
numero r generado al azar entre 0 y 1): r < exp [(costoi –
costop)/temp].
18. Si se cumple la condición del paso de Metrópolis
19. solución inicial = solución vecina
20. costo solución inicial = costo solución vecina
21. a=a+1
22. Fin Si
23. Fin Si
24. k++;
25. temp = temp * enf;
26. Mostrar solución y costo
27. Fin
 Ilustración 4. Representación Gráfica del Recocido Simulado.

En la Ilustración 4 se aprecia de manera gráfica cómo funciona el Algoritmo de Recocido

Simulado, donde debe ser formulado como un descenso a la colina en el que la función objetivo es
el nivel energético

Requerimientos del sistema

El archivo .exe está diseñado para ser ejecutado únicamente en un sistema operativo Windows.
Manual de Usuario

Documento Anexo

Conclusiones

Primeramente, haremos énfasis en los conceptos de Heurística y Metaheurística:

Una heurística es un método que intenta esquivar la búsqueda exhaustiva del espacio, utilizando
herramientas que aseguren la exploración de las zonas más promisorias y obtener así soluciones
cercanas al óptimo.

Una metaheurística es un método heurístico para resolver un tipo de problema computacional

general, usando los parámetros dados por el usuario sobre unos procedimientos genéricos y
abstractos de una manera que se espera sea eficiente (normalmente, estos procedimientos son
heurísticos).

Como ya se mencionó en la sección del Algoritmo general implementado, se utilizó el de recocido

simulado el cual es un algoritmo de búsqueda global metaheurística para problemas de
optimización; el objetivo general de este tipo de algoritmos es encontrar el valor óptimo o un valor
subóptimo de una función en un espacio de búsqueda grande.

En el caso del proyecto realizado, al llevar a la práctica el algoritmo en un inicio se tomaron

diferentes valores entre diferentes rangos para los parámetros de entrada, considerando
temperatura inicial con rangos de 50 hasta 10000, así como temperatura final desde 1 hasta 0.0001,
iteraciones de 50 a 200 y aceptaciones de 50 a 200, después estar ejecutando el programa un gran
número de veces con diferentes valores para los parámetros de entrada dentro de los rangos
establecidos, de acuerdo a los resultados obtenidos en las pruebas realizadas se disminuyó el rango
de valores para los parámetros de entrada con los que se generaron soluciones subóptimas. A
continuación, se presentan solo unas pocas imágenes de las muchas pruebas realizadas.
 Ilustración 5. Ejemplos de pruebas del algoritmo.

De acuerdo con los resultados obtenidos, para el algoritmo implementado para este proyecto, los
mejores valores, que generaron soluciones más cercanas a la óptima, para los parámetros de
entrada están en los siguientes rangos:

• Temperatura inicial: 100 a 200

• Temperatura final: 0.001 0.009
• Factor de enfriamiento: 0.999 a 0.9999
 • Iteraciones: 100 a 200
• Aceptaciones: 100 a 200

Con base en lo anterior se concluye, primero, que el factor o parámetro más importante/influyente
en el resultado es el factor de enfriamiento, lo que demuestra que bajando suficientemente lento
el valor del parámetro de enfriamiento en conjunto con suficientes transiciones en cada cambio de
temperatura, llegando a una temperatura final adecuada, se puede alcanzar soluciones subóptimas,
así como la posibilidad de la solución óptima. Segundo, encontrar valores adecuados para los
parámetros requiere de estar jugando con distintos rangos de valores hasta encontrar los que
arrojan los mejores resultados. Tercero, el diseño y la implementación del algoritmo fue bueno,
puesto que se obtuvieron soluciones subóptimas muy cercanas a la óptima, como se muestra en el
siguiente ejemplo:

NAME : gr24.opt.tour
COMMENT : Optimal solution for gr24 (1272)
TYPE : TOUR
DIMENSION : 24
TOUR_SECTION
16 11 3 7 6 24 8 21 5 10 17 22 18 19 15 2 20 14 13 9 23 4 12 1
-1
EOF
Se puede observar en la parte superior resaltado en amarillo la solución optima a la instancia en
cuestión que atacó el algoritmo desarrollado y en la parte de abajo la imagen de una solución
subóptima muy cercana obtenida por el programa.

Ilustración 6. Solución subóptima obtenida por el algoritmo implementado.

En base a la experiencia se concluye, que el algoritmo es sencillo y fácil de diseñar e implementar

para ser aplicado una gran cantidad de problemas, donde los resultados obtenidos dependen en
gran medida del diseño de como se generan las soluciones, en este caso se aplicó una estructura de
vecindad para generar las soluciones, y del mecanismo de enfriamiento en conjunto con lo demás
parámetros asociados.