aplicaciÓn del algoritmo de colonia de hormigas...
TRANSCRIPT
APLICACIÓN DEL ALGORITMO DE
COLONIA DE HORMIGAS AL
PROBLEMA DE RUTAS DE REPARTO
CON DESTINOS MÓVILES
ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA. UNIVERSIDAD DE SEVILLA.
INGENIERÍA INDUSTRIAL
Autor: Jesús Vázquez Solís
Tutor: Jesús Muñuzuri Sanz
2
3
A mis padres y a mi tío Manuel.
4
5
Índice de contenido 1. Introducción y objeto del proyecto ....................................................................................... 9
2. Descripción del problema ................................................................................................... 11
2.1. TSPMD: Problema del Viajante de Comercio con Destinos Móviles ........................... 11
2.1.1. Modelo del TSPMD .............................................................................................. 12
2.2. VRPMD: Problema de Rutas de Vehículos con Destinos Móviles ............................... 13
2.2.1. Modelo del VRPMD ............................................................................................. 14
3. Descripción del algoritmo ................................................................................................... 16
3.1. Optimización combinatoria ......................................................................................... 16
3.2. Heurísticas ................................................................................................................... 17
3.3. Metaheurísticas ........................................................................................................... 18
3.3.1. Búsqueda Tabú .................................................................................................... 18
3.3.2. Algoritmos Genéticos .......................................................................................... 20
3.3.3. Algoritmos GRASP ............................................................................................... 22
3.3.4. Templado Simulado (“Simulated Annealing”) ..................................................... 23
3.3.5. Búsqueda Local Iterada ....................................................................................... 25
3.3.6. Optimización mediante Colonia de Hormigas (“Ant Colony Optimization”) ...... 26
3.4. Algoritmos de Colonias de Hormigas .......................................................................... 27
3.4.1. Introducción ........................................................................................................ 28
3.4.2. El Algoritmo AS .................................................................................................... 31
3.4.3. Algoritmos derivados del AS ............................................................................... 35
3.5. Aplicación al Problema VRPMD ................................................................................... 39
3.5.1. Descripción del general algoritmo ...................................................................... 39
3.5.2. Pseudo-código y descripción de las fases de resolución ..................................... 40
4. Problemas y resultados ....................................................................................................... 44
4.1. Comprobaciones ......................................................................................................... 44
4.1.1. Problema 1 .......................................................................................................... 44
4.1.2. Problema 2 .......................................................................................................... 46
4.1.3. Problema 3 .......................................................................................................... 48
4.1.4. Problema 4 .......................................................................................................... 50
4.1.5. Problema 5 .......................................................................................................... 52
4.2. Calibración ................................................................................................................... 54
4.3. Resolución de problemas ............................................................................................ 58
4.3.1. Problema 7 .......................................................................................................... 58
4.3.2. Problema 8 .......................................................................................................... 60
4.3.3. Problema 9 .......................................................................................................... 62
6
4.3.4. Problema 10 ........................................................................................................ 64
4.3.5. Problema 11 ........................................................................................................ 66
4.3.6. Problema 12 ........................................................................................................ 68
4.3.7. Problema 13 ........................................................................................................ 70
4.3.8. Resumen de los problemas resueltos ................................................................. 73
5. Conclusiones........................................................................................................................ 74
6. Anexos ................................................................................................................................. 76
6.1. Códigos ........................................................................................................................ 76
6.1.1. AlgoVRPMD: Función principal ............................................................................ 76
6.1.2. PFIH: Algoritmo Push Forward Insertion Heuristic ............................................. 79
6.1.3. InicializarFeromona ............................................................................................. 82
6.1.4. ConstrucciónSoluciones ...................................................................................... 83
6.1.5. ActualizaciónFeromona ....................................................................................... 87
6.1.6. Admisible ............................................................................................................. 88
7. Referencias .......................................................................................................................... 91
Índice de Ilustraciones Ilustración 1. Solución del Problema 1. ...................................................................................... 45
Ilustración 2. Solución del Problema 2. ...................................................................................... 47
Ilustración 3. Solución del Problema 3. ...................................................................................... 49
Ilustración 4. Solución del Problema 4. ...................................................................................... 50
Ilustración 5. Solución del Problema 5. ...................................................................................... 53
Ilustración 6. Costes de las soluciones obtenidas según los parámetros de calibración. .......... 56
Ilustración 7. Tiempo de ejecución de las soluciones obtenidas según los parámetros de
calibración. .................................................................................................................................. 56
Ilustración 8. Solución del Problema 7. ...................................................................................... 59
Ilustración 9. Solución del Problema 8. ...................................................................................... 61
Ilustración 10. Solución del Problema 9. .................................................................................... 63
Ilustración 11. Solución del Problema 10. .................................................................................. 65
Ilustración 12. Solución del Problema 11. .................................................................................. 67
Ilustración 13. Solución del Problema 12. .................................................................................. 69
Ilustración 14. Solución del Problema 13. .................................................................................. 72
7
Índice de Tablas Tabla 1. Datos del Problema 1. ................................................................................................... 44
Tabla 2. Datos del Problema 2. ................................................................................................... 46
Tabla 3. Datos del Problema 3. ................................................................................................... 48
Tabla 4. Datos del Problema 4. ................................................................................................... 50
Tabla 5. Soluciones admisibles para el Problema 4. ................................................................... 51
Tabla 6. Datos del Problema 5. ................................................................................................... 52
Tabla 7. Datos del Problema 6. ................................................................................................... 55
Tabla 8. Parámetros y resultados de las pruebas de calibración. ............................................... 55
Tabla 9. Datos del Problema 7. ................................................................................................... 59
Tabla 10. Datos del Problema 8. ................................................................................................. 60
Tabla 11. Datos del Problema 9. ................................................................................................. 62
Tabla 12. Datos del Problema 10. ............................................................................................... 64
Tabla 13. Datos del Problema 11. ............................................................................................... 66
Tabla 14. Datos del Problema 12. ............................................................................................... 68
Tabla 15. Datos del Problema 13. ............................................................................................... 71
Tabla 16. Resultados de los problemas resueltos ....................................................................... 73
Índice de Cuadros Cuadro 1. Pseudo-código de la metaheurística Búsqueda Tabú. ............................................... 19
Cuadro 2. Pseudo-código del algoritmo genético. ...................................................................... 21
Cuadro 3. Pseudo-código de las metaheurísticas voraces. ......................................................... 23
Cuadro 4. Pseudo-código de las metaheurísticas de templado simulado. ................................. 24
Cuadro 5. Pseudo-código de las metaheurísticas de colonia de hormigas. ............................... 31
Cuadro 6. Pseudo-código del algoritmo “AlgoVRPMD”. ............................................................. 40
8
9
1. Introducción y objeto del proyecto
Los problemas de optimización de rutas en todas sus múltiples variantes han sido
objetos de estudio del campo de la Investigación Operativa durante décadas. Con la
expansión del comercio internacional gracias a la globalización, fomentada en parte por
la aparición y consolidación de Internet y por el fomento de acuerdos comerciales entre
los distintos bloques económicos del planeta, la mejora y optimización de las redes de
transporte de mercancías es esencial para la disminución de costes de transporte y el
incremento de la satisfacción del cliente.
Uno de los problemas más conocidos es el denominado “Vehicle Routing Problem”
(VRP), o Problema de Ruta de Vehículos en castellano. Este problema consiste en el
reparto de un producto a varios clientes disponiendo de una flota de vehículos y el
objetivo consiste en realizar las entregas con el menor coste posible.
Una particularización al problema anterior es el conocido como “Travelling Salesman
Problem” (TSP), o Problema del Viajante de Comercio en español. En él, se trata de lograr
repartir los productos con el menor coste posible cuando solo se dispone de un vehículo
en la flota.
Dichos problemas se engloban dentro de la categoría de problemas NP-Hard, lo que
implica que no pueden ser resueltos en tiempo polinómico por algoritmos conocidos.
Así, estos problemas tienen una gran dificultad computacional.
Así mismo, dichos problemas pueden particularizarse para muchas y variadas
aplicaciones, no solo en problemas logísticos sino de otros muchos campos.
El objetivo del presente Proyecto es abordar la resolución de una variante de estos
problemas, conocido como TSPMD y VRPMD (“Travelling Salesman Problem with
Moving Destinations”y “Vehicle Routing Problem with Moving Destinations”,
respectivamente) en el que los clientes tienen localizaciones geográficas distintas
durante el tiempo en el que se realiza el reparto. Cada cliente permanece en una
localización durante un cierto tiempo conocido como ventana temporal, para situarse
posteriormente en otro lugar.
La resolución del problema deberá, por lo tanto, tener en cuenta esta nueva
restricción suplementaria que resulta en una mejora obvia en el servicio al cliente, pues
permite flexibilizar la entrega de productos y adaptarse mejor a las necesidades de los
clientes.
Como se ha comentado anteriormente, este problema es computacionalmente
complejo (NP-Hard), por lo que a partir de un cierto tamaño es muy difícil de resolver
con programas de optimización básicos. Por lo tanto, se aplicará un algoritmo del tipo
“Colonia de hormigas” para buscar la mejor solución posible.
10
En los siguientes apartados, se hace una descripción del problema a resolver, se
describe el algoritmo utilizado, se presenta una batería de problemas resueltos con
dicho algoritmo y se presentan las conclusiones finales.
11
2. Descripción del problema
2.1. TSPMD: Problema del Viajante de Comercio con Destinos Móviles
El problema del viajante de comercio (TSP) trata de, dada una lista de ciudades,
buscar cuál es el camino más corto para visitar cada una de dichas posiciones
exactamente una vez y volver al punto de origen.
Este problema se categoriza como NP-hard y ha sido profusamente estudiado en el
campo de la investigación operativa, existiendo multitud de métodos y heurísticas
exactas. No obstante, al pertenecer a la clase de problemas NP-completos, es probable
que el tiempo de funcionamiento para cualquier algoritmo aumente exponencialmente
con el número de ciudades.
El problema del TSP tiene amplias aplicaciones más allá de la logística y además
múltiples variantes al aplicarse limitaciones adiciones como es el caso del TSPMD
considerado en este Proyecto.
El problema del TSPMD (“Travelling Salesman Problem with Moving Destinations”),
consiste en encontrar el camino más corto para visitar cada una de los clientes
exactamente una vez y volver al punto de origen, cuando cada cliente puede situarse en
posiciones geográficas distintas en el tiempo.
En el apartado siguiente se describe el modelo matemático del TSPMD.
12
2.1.1. Modelo del TSPMD
La modelización de este problema fue realizada anteriormente en otro Proyecto Final
de Grado (i), y se presenta a continuación:
𝑀𝑖𝑛𝑖𝑚𝑖𝑧𝑎𝑟: ∑ ∑ 𝑑𝑣𝑖𝑣𝑗𝑥𝑣𝑖𝑣𝑗
𝑣𝑗∈𝐽𝑣𝑖∈𝐼
𝑆𝑢𝑗𝑒𝑡𝑜 𝑎: ∑ ∑ ∑ 𝑥𝑣𝑖𝑣𝑗
𝑣𝑗∈𝐽
= 1 ∀ J [1]
𝑣𝑖∈𝐼𝐼
∑ ∑ ∑ 𝑥𝑣𝑖𝑣𝑗
𝑣𝑗∈𝐽
= 1 ∀ I [2]
𝐽𝑣𝑖∈𝐼
∑ ∑ 𝑥𝑣𝑖𝑣𝑗= ∑ ∑ 𝑥𝑣𝑗𝑣𝑖
𝑣𝑖∈𝐼𝐼
∀ J, 𝑣𝑗 [3]
𝑣𝑖∈𝐼𝐼
𝑡𝑖 + 𝑑𝑣𝑖𝑣𝑗𝑥𝑣𝑖𝑣𝑗
≤ 𝑡𝑗 + 𝐴 (1 − 𝑥𝑣𝑖𝑣𝑗) ∀ I, 𝑣𝑖, 𝐽, 𝑣𝑗 [4]
𝑒𝑣𝑗− 𝐴 (1 − ∑ ∑ 𝑥𝑣𝑖𝑣𝑗
𝑣𝑖∈𝐼𝐼
) ≤ 𝑡𝑗 ≤ 𝑙𝑣𝑗+ 𝐴 (1 − ∑ ∑ 𝑥𝑣𝑖𝑣𝑗
𝑣𝑖∈𝐼𝐼
) ∀ 𝐽, 𝑣𝑗 [5]
𝑥𝑣𝑖𝑣𝑗∈ {0,1}; 𝑡𝑗 ≥ 0
Como variables del modelo, se definen las siguientes:
Las variables 𝑥𝑣𝑖𝑣𝑗, que son variables dicotómicas que toman el valor 1 si el
vehículo viaja desde el cliente i durante la ventana temporal 𝑣𝑖 al cliente j
durante la ventana temporal 𝑣𝑗 y 0 en caso contrario.
Las variables 𝑡𝑗, que representan el tiempo de llegada al cliente j.
En cuanto a los datos necesarios para describir el modelo, son los siguientes:
𝑑𝑣𝑖𝑣𝑗, que son las distancias entre la localización del cliente durante la ventana
temporal 𝑣𝑖 y el cliente j durante la ventana temporal 𝑣𝑗 .
𝑒𝑣𝑗, el tiempo más temprano de la ventana temporal del cliente de destino 𝑣𝑗 .
𝑙𝑣𝑗, el tiempo más tardío de la ventana temporal del cliente de destino 𝑣𝑗 .
La función objetivo del modelo minimiza la distancia total recorrida.
Los cinco conjuntos de restricciones del modelo son las siguientes:
El conjunto de restricciones [1] y [2] fuerzan al vehículo a llegar y salir desde
cada uno de los clientes, en cualquiera de las localizaciones en las distintas
ventanas temporales existentes.
13
Las restricciones [3] son restricciones de flujo que obligan al vehículo a llegar
y salir de cada nodo en la misma ventana temporal.
Las restricciones [4] obligan a que el tiempo de llegada al cliente j visitado
después del cliente i, no pueda ser superior al tiempo de llegada al cliente i.
Las restricciones [5] marcan los límites del tiempo de llegada a cada uno de
los clientes según sus ventanas temporales asignadas.
2.2. VRPMD: Problema de Rutas de Vehículos con Destinos Móviles
El problema de Rutas de Vehículos (VRP) es una generalización del problema del
Viajante de Comercio (TSP) descrito anteriormente. Este problema trata de visitar un
número de nodos mediante una determinada flota de vehículos disponibles. El objetivo,
al igual que en el problema de TSP, es visitar cada nodo recorriendo el camino total más
corto que sea posible.
Al problema VRP básico explicado en el párrafo anterior, pueden añadirse múltiples
y variadas restricciones adicionales como una limitación a la distancia que puede
recorrer cada vehículo o a la capacidad de cada vehículo.
Un particularización del problema VRP, es el Problema de Rutas de Vehículos con
Ventanas Temporales. En este problema, al igual que en el problema VRP genérico, se
trata de visitar todos los nodos utilizando una flota de vehículos, con la particularidad
de que los clientes o nodos, pueden situarse en distintos puntos geográficos en el
tiempo en el que dura el reparto de la mercancía.
En el apartado siguiente se procede a presentar el modelo matemático de este
problema junto a una descripción de sus variables y restricciones.
14
2.2.1. Modelo del VRPMD
La modelización de este problema, tal como se comentó en el caso del problema
TSPMD, fue abordada en otro Proyecto con anterioridad y se expone a continuación.
𝑀𝑖𝑛𝑖𝑚𝑖𝑧𝑎𝑟: ∑ ∑ ∑ 𝑑𝑣𝑖𝑣𝑗𝑥𝑣𝑖𝑣𝑗
𝑘
𝑣𝑗∈𝐽𝑣𝑖∈𝐼𝑘
𝑆𝑢𝑗𝑒𝑡𝑜 𝑎: ∑ ∑ ∑ ∑ 𝑥𝑣𝑖𝑣𝑗𝑘
𝑣𝑗∈𝐽
= 1 ∀ J [1]
𝑣𝑖∈𝐼𝐼𝑘
∑ ∑ ∑ ∑ 𝑥𝑣𝑖𝑣𝑗𝑘
𝑣𝑗∈𝐽
= 1 ∀ I [2]
𝐽𝑣𝑖∈𝐼𝑘
∑ ∑ 𝑥𝑣𝑖𝑣𝑗𝑘 = ∑ ∑ 𝑥𝑣𝑗𝑣𝑖
𝑘
𝑣𝑖∈𝐼𝐼
∀ J, 𝑣𝑗 , 𝑘 [3]
𝑣𝑖∈𝐼𝐼
𝑡𝑖 + 𝑑𝑣𝑖𝑣𝑗∑ 𝑥𝑣𝑖𝑣𝑗
𝑘 ≤ 𝑡𝑗 + 𝐴 (1 − ∑ 𝑥𝑣𝑖𝑣𝑗𝑘
𝑘
) ∀ I, 𝑣𝑖, 𝐽, 𝑣𝑗
𝑘
[4]
𝑒𝑣𝑗− 𝐴 (1 − ∑ ∑ ∑ 𝑥𝑣𝑖𝑣𝑗
𝑘
𝑣𝑖∈𝐼𝐼𝑘
) ≤ 𝑡𝑗 ≤ 𝑙𝑣𝑗+ 𝐴 (1 − ∑ ∑ ∑ 𝑥𝑣𝑖𝑣𝑗
𝑘
𝑣𝑖∈𝐼𝐼𝑘
) ∀ 𝐽, 𝑣𝑗 [5]
𝑥𝑣𝑖𝑣𝑗𝑘 ∈ {0,1}; 𝑡𝑗 ≥ 0
Como variables del modelo, al igual que en el caso del TSPMD, se definen las
siguientes:
Las variables 𝑥𝑣𝑖𝑣𝑗
𝑘, que son variables dicotómicas que toman el valor 1 si el
vehículo k viaja desde el cliente i durante la ventana temporal 𝑣𝑖 al cliente j
durante la ventana temporal 𝑣𝑗 y 0 en caso contrario.
Las variables 𝑡𝑗, que representan el tiempo de llegada al cliente j.
En cuanto a los datos necesarios para describir el modelo, son los siguientes:
𝑑𝑣𝑖𝑣𝑗, que son las distancias entre la localización del cliente durante la ventana
temporal 𝑣𝑖 y el cliente j durante la ventana temporal 𝑣𝑗 .
𝑒𝑣𝑗, el tiempo más temprano de la ventana temporal del cliente de destino 𝑣𝑗 .
𝑙𝑣𝑗, el tiempo más tardío de la ventana temporal del cliente de destino 𝑣𝑗 .
La función objetivo del modelo minimiza la distancia total recorrida por la suma de
todos los k vehículos de la flota.
15
Los cinco conjuntos de restricciones del modelo son las siguientes:
El conjunto de restricciones [1] y [2] fuerzan a que al menos un vehículo de
los k vehículos de la flota llegue y salga a cada uno de los clientes, en
cualquiera de las localizaciones en las distintas ventanas temporales
existentes.
Las restricciones [3] son restricciones de flujo que obligan al vehículo a llegar
y salir de cada nodo en la misma ventana temporal.
Las restricciones [4] obligan a que el tiempo de llegada al cliente j visitado
después del cliente i, no pueda ser superior al tiempo de llegada al cliente i.
Las restricciones [5] marcan los límites del tiempo de llegada a cada uno de
los clientes según sus ventanas temporales asignadas.
16
3. Descripción del algoritmo
3.1. Optimización combinatoria
El problema que se considera en este Proyecto, tal como se mencionó anteriormente,
es un problema NP-Hard, lo que significa que no se conoce y quizás no exista algoritmo
alguno que lo resuelva en un tiempo polinomial.
Por tal motivo, para esta clase de problemas solo podemos aspirar a encontrar la
mejor solución de entre el gran número de soluciones posibles. De esta cuestión se
encarga la optimización combinatoria. Precisamente el problema objeto de este
Proyecto es uno de los ejemplos clásicos de estudio de la optimización combinatoria.
En los problemas de complejidad NP-Hard, el número de soluciones factibles
aumenta exponencialmente con respecto al número de elementos que componen
dichas soluciones. Tal circunstancia hace inviable probar todas las soluciones posibles
por mucha capacidad que tenga el computador con el que pretendamos probar cada
una de las soluciones, cuando el problema alcanza cierta dimensión.
Ante la inexistencia de un procedimiento para resolver el problema y la imposibilidad
de probar todas las soluciones para hallar la mejor de ellas, se hace necesario recurrir a
algoritmos de métodos aproximados, también conocidos como heurísticas.
17
3.2. Heurísticas
Las heurísticas permiten obtener soluciones utilizando información del problema, por
lo que la información utilizada es el factor más importante para que el algoritmo sea
eficiente y dirigir la búsqueda de forma adecuada. Dentro de los métodos aproximados,
o heurísticas, existen dos tipos de métodos:
Algoritmos de búsqueda local
Este tipo de algoritmos pretenden mejorar una solución dada explorando soluciones
parecidas a dicha solución y aplicando pequeñas modificaciones.
La estructura típica de búsqueda de soluciones de este tipo de algoritmos consiste en
mejorar la solución actual realizando pequeñas modificaciones a dicha solución
(soluciones vecinas). En el caso de encontrar una solución mejor, se reemplaza la
solución inicial por la nueva y se procede a repetir la búsqueda. Tras realizar sucesivas
iteraciones, se logra encontrar un óptimo local dentro de la región donde se realiza la
búsqueda.
El inconveniente de este tipo de algoritmos es que tienden a obtener óptimos locales
y estancarse en soluciones muy alejadas del óptimo global, al limitar la búsqueda de
nuevas soluciones a una región acotada del espacio de soluciones posibles del problema.
Algoritmos constructivos
Este tipo de algoritmos consisten en generar soluciones desde una solución vacía o
pequeña. Iterativamente, se van añadiendo elementos a la solución hasta construir una
solución completa. Un ejemplo de este tipo de algoritmos son las heurísticas voraces o
glotonas (“greedy algorithms”). Estos algoritmos suelen ser rápidos y consisten en elegir
en cada paso local la opción óptima, también llamado a veces el elemento más
prometedor. Una vez añadido este elemento a la solución parcial, se comprueba que la
solución es factible. Se procede del mismo modo sucesivamente hasta obtener una
solución completa, con la esperanza de llegar así a una solución óptima general.
Un inconveniente es que este tipo de algoritmos no pueden garantizar que las
soluciones encontradas sean óptimos respecto a su vecindario de soluciones posibles.
Es decir, pequeñas variaciones en la solución encontrada, podrían provocar una mejora
significativa en la función objetivo.
Para solventar los inconvenientes de ambos métodos y aprovechar sus ventajas, la
investigación en el campo de la optimización combinatoria se ha centrado en un nuevo
tipo de heurísticas conocidas como metaheurísticas.
18
3.3. Metaheurísticas
Los algoritmos metaheurísticos, cuya denominación fue introducida por Fred Glover
(ii) tienen tal nombre por la composición de dos palabras griegas: “meta” (“más allá”) y
“heuriskein” (“encontrar”). Este tipo de algoritmos tratan, mediante unos parámetros
dados por el usuario, de guiar una heurística subordinada mediante un proceso de
generación iterativa de soluciones para explorar todo el espacio de soluciones posibles,
con la intención de centrarse en el espacio de soluciones con mayor probabilidad de
contener el óptimo, reduciendo el tiempo de búsqueda al no tener que probar todas y
cada una de las soluciones posibles (iii).
Por lo tanto, las metaheurísticas permiten definir una estrategia de alto nivel para
poder explorar de una forma amplia el espacio de soluciones, escapando de óptimos
locales, y realizar una búsqueda más detallada en aquellas zonas del espacio de
soluciones apropiadas.
Dos conceptos importantes en este tipo de algoritmos son la intensificación y
diversificación. El concepto de intensificación se refiere a la característica de búsqueda
local del algoritmo, también conocida como explotación. En cambio, el concepto de
diversificación hace referencia a la característica de búsqueda global del algoritmo.
Para que el algoritmo sea efectivo en la búsqueda de buenas soluciones, debe existir
un equilibrio correcto entre diversificación e intensificación
Los métodos utilizados por las metaheurísticas son variados. A continuación se
repasan someramente algunos de los más destacados.
3.3.1. Búsqueda Tabú
Este tipo de metaheurísticas está basado en aumentar la eficiencia del método de
búsqueda local utilizando estrategias de memoria adaptativa. La forma más simple del
algoritmo de Búsqueda Tabú realiza una búsqueda local pero la combina con la
utilización de una memoria de corto plazo para evitar el mayor inconveniente de las
heurísticas de búsqueda local: quedar atrapados en óptimos locales.
La memoria de corto plazo utilizada en la Búsqueda Tabú funciona como una lista
tabú, de donde proviene su nombre, en el que se registran las soluciones visitadas en
las iteraciones más recientes del algoritmo y evita su evaluación de nuevo.
El pseudo-código de esta metaheurística se presenta a en el Cuadro 1.
19
procedure BúsquedaTabú{
s SoluciónInicial
InicializaciónEstructurasMemoria
while (not CriterioFin) {
ConstruccionSoluciones
s’ MejorSolución
ActualizaciónEstructurasMemoria
if ( f(s’) < f(s) ) {
s s’
}
return s
}
}
Cuadro 1. Pseudo-código de la metaheurística Búsqueda Tabú.
Como puede observarse en el pseudo-código del Cuadro 1, tras generarse una
solución de partida e inicializar las estructuras de memoria, se generan las soluciones
admisibles, aquéllas que no son tabú, y posteriormente se va iterando hasta cumplir el
criterio de finalización, actualizando las estructuras de memoria en cada iteración.
Una variante de este algoritmo consiste en utilizar listas tabú con atributos de las
soluciones en vez de las soluciones completas, haciendo el algoritmo más efectivo en
ciertos dominios. Algunos de los atributos de las soluciones que pueden almacenarse
en la lista tabú son movimientos, la diferencia entre dos soluciones evaluadas o guardar
solo algunas componentes de la solución.
No obstante, esto puede presentar inconvenientes. Al marcar un atributo como tabú,
puede darse el caso de impedir la evaluación de más de una solución, incluso de
soluciones mejores que las ya visitadas. Para solucionar este inconveniente, se utilizan
criterios de aspiración, que se definen para los movimientos considerados prohibidos y
que determinan cuándo pueden ser reemplazadas o eliminadas las restricciones tabú
sobre cierto elemento que se encuentra dentro de la lista tabú.
Además de utilizar la memoria a corto plazo, como se ha descrito anteriormente, hay
otras formas de utilizar la historia completa de la búsqueda realizada, pudiendo agregar
a la Búsqueda Tabú la utilización de la memoria a largo plazo, generalmente haciendo
uso de cuatro principios: iteración más reciente en que se visitó la solución, frecuencia,
calidad e influencia.
20
Si se utiliza el criterio de la última evaluación de la solución, se guarda en la memoria
la última iteración en que se visitó dicha solución. Al utilizar el criterio de frecuencia, se
guarda en la memoria el número de veces en que la solución ha sido visitada. Así, se
puede identificar el espacio de soluciones que donde se ha concentrado la búsqueda,
permitiendo diversificar la búsqueda hacia otras regiones.
Utilizando el criterio de calidad, se guardan en la memoria atributos que comparta
las mejores soluciones evaluadas. En cuanto al criterio de influencia, éste se refiere a
almacenar en memoria el impacto de las decisiones que se han ido tomando durante la
búsqueda.
3.3.2. Algoritmos Genéticos
Los algoritmos genéticos o evolutivos, como también son denominados, fueron
introducidos por Goldberg a finales de la década de 1980. Este tipo de algoritmo
metaheurístico replica el comportamiento de selección natural. Cada individuo de la
población representa una solución factible del problema, asignándose a cada individuo
un valor llamado fitness, relacionado con el grado de bondad de la solución. El valor
fitness representaría el grado de adaptación al medio de un individuo en la naturaleza.
Al igual que en el mundo natural los individuos capaces de adaptarse mejor al medio
sobreviven, los individuos del algoritmo genético con un mayor fitness tienen más
probabilidad de reproducirse junto a otro individuo.
Al combinar el material genético de ambos individuos, sus descendientes tendrán
algunas de las características de sus ancestros. En estos algoritmos, existen tres tipos de
operadores genéticos, que intervienen en la reproducción de nuevas soluciones. Estos
operadores son los de selección, recombinación y mutación, replicando el
comportamiento que se da en la naturaleza de seleccionar los individuos más aptos,
combinar su material genético y producir ciertas mutaciones aleatorias en el material
genético.
La estructura de este tipo de algoritmos puede examinarse en el Cuadro 2 mostrado
abajo.
21
procedure AlgoGenético{
pob GenerarPoblación
s EscogerMejor (pob)
while (not CriterioFin) {
pob’ SelecciónMejores (pob)
pob’’ Cruce (pob’)
pob’’’ Mutación (pob’’)
s’ EscogerMejor (pob’’’)
if ( f(s’) < f(s) ) {
s s’
}
pob NuevaPoblación (pob’’’)
}
return s
}
Cuadro 2. Pseudo-código del algoritmo genético.
El operador genético de mutación es crucial para diversificar el espacio de búsqueda
y quedar atrapado en un óptimo local, ya que genera cambios aleatorios en las
soluciones que se crean como descendientes de las soluciones antecesoras.
A través de generar nuevas poblaciones de soluciones, seleccionando las mejores
soluciones encontradas hasta ese momento, se va explorando con mayor intensidad las
áreas con mejores soluciones de todo el espacio de soluciones factibles.
22
3.3.3. Algoritmos GRASP
Los algoritmos GRASP, acrónimo de “Greedy Randomized Adaptive Search
Procedure”, utilizan en cada iteración del algoritmo dos fases bien diferenciadas: una
fase constructiva donde se construye una solución factible y una fase posterior de
exploración, en la que se mejora la solución construida mediante una heurística de
búsqueda local.
Durante la primera fase, o fase constructiva, se define en primer lugar una RCL, o
“Lista restringida de candidatos”, compuesta por los elementos candidatos a ser
incorporados a la solución que impliquen la mayor mejora de la función objetivo. El
número de candidatos que puede albergar la RCL puede ser definido según distintos
criterios: un número establecido a priori, estableciendo un número máximo de
elementos o según alguna medida de la calidad de los candidatos.
Una vez se tiene la lista de candidatos de elementos para incluir en la solución, se
elige de forma aleatoria una de ellas para su inclusión. La clave de que este algoritmo
sea una metaheurística reside en dicha aleatoriedad en la elección del candidato a elegir
para incluir en la solución.
Sucesivamente se van actualizando la lista de candidatos RCL, reevaluando la mejora
incremental que cada uno provoca en la función objetivo y seleccionando un nuevo
candidato para la solución. Finalmente, se repite dicho proceso tantas veces hasta tener
una solución completa.
El pseudo-código de esta metaheurística se muestra en la página siguiente (Cuadro
3).
23
procedure AlgoGRASP{
s SoluciónInicial
while (not CriterioFin) {
s’ SoluciónGlotonaAleatoria
if ( s’ no admisible ) {
s’’ RepararSolución (s’)
}
s’’’ BúsquedaLocal (s’’)
if ( f(s’’’) < f(s) ) {
s s’’’
}
return s
}
Cuadro 3. Pseudo-código de las metaheurísticas voraces.
Una vez se tiene una solución construida, puede darse el caso de que dicha solución
no sea una solución factible del problema al no cumplir las restricciones del mismo. Tras
comprobar su validez, y convertirla en una solución factible en caso de no serla, se pasa
a la última etapa del algoritmo GRASP: la fase de exploración.
En la fase de exploración, se utiliza una heurística de búsqueda local. Finalmente, el
algoritmo se detiene al cumplir el criterio de fin marcado.
3.3.4. Templado Simulado (“Simulated Annealing”)
Este tipo de algoritmos se basan en imitar el proceso de templado de un material
físico. En el proceso de enfriamiento de un material, cuando en las primeras etapas se
encuentra a altas temperaturas, su estructura es desordenada debido a la gran cantidad
de energía térmica. Sin embargo, el objetivo del enfriamiento es tener un material con
una estructura cristalina bien definida y ordenada y para ello, se debe realizar un
enfriamiento lento del material para que los átomos del mismo tengan suficiente tiempo
para reordenarse de la manera adecuada y que puedan formar una estructura
organizada.
A continuación se muestra el pseudo-código de este tipo de metaheurística en el
Cuadro 4.
24
procedure AlgoSimulatedAnnealing{
s SoluciónInicial
k 0
T 𝑡0
M 𝑀0
while (not CriterioFin) {
m 0
while ( m ≤ M ) {
s’ GeneraciónSolución (s)
s AceptaciónSolución (s, s’, T)
m m+1
}
k k+1
T 𝑡𝑘
M 𝑀𝑘
}
return s
}
Cuadro 4. Pseudo-código de las metaheurísticas de templado simulado.
El funcionamiento de este algoritmo intenta replicar dicho comportamiento físico. En
primer lugar, se parte de una solución inicial, obtenida por un método aleatorio o
mediante otro procedimiento, y se define el esquema de enfriamiento, esto es, los
parámetros que van a controlar el comportamiento del algoritmo: la temperatura y el
número de iteraciones que se permiten a cada temperatura.
Además de estos parámetros, se define un esquema de disminución de la
temperatura, partiendo de la temperatura inicial definida, ya sea mediante un esquema
estático (definiendo una ecuación de enfriamiento) o un esquema dinámico.
En cada iteración del algoritmo, se genera una nueva solución mediante una
búsqueda local cercana a la solución resultante de la iteración anterior. Sin embargo, si
la nueva solución encontrada es peor que la anterior, ésta no es automáticamente
25
rechazada. De hecho, se define la probabilidad de aceptar la solución encontrada en la
nueva iteración como se muestra en la Fórmula 3.3.1, siendo s’ la nueva solución
encontrada y s la solución encontrada en la iteración anterior, asumiendo una función
objetivo de minimización.
𝑝 = {𝑒−(𝑓(𝑠′)−𝑓(𝑠)
𝑡𝑘 , 𝑠𝑖 𝑓(𝑠′) − 𝑓(𝑠) > 0 (3.3.1)
1, 𝑠𝑖 𝑓(𝑠′) − 𝑓(𝑠) ≤ 0
A medida que se van ejecutando más iteraciones del algoritmo, la temperatura t
desciende (𝑡𝑘+1 < 𝑡𝑘; ∀k), por lo que la probabilidad de aceptar una solución peor,
disminuye. Este comportamiento del algoritmo se asemeja al comportamiento físico del
enfriamiento de un material.
Al principio, el material tiene más energía interna y la estructura es más
desorganizada. Igualmente, en el caso del algoritmo, este mayor desorden es replicado
mediante una mayor probabilidad de aceptación de una peor solución. Esto permite una
mayor exploración de todo el espacio factible de soluciones del problema.
No obstante, a medida que la temperatura desciende, el material va adoptando una
estructura más ordenada. De forma análoga, a medida que avanza la ejecución del
algoritmo, se permite una menor movilidad dentro del espacio de soluciones factibles,
disminuyendo la probabilidad de aceptación de soluciones peores y por lo tanto,
intensificando la búsqueda local.
3.3.5. Búsqueda Local Iterada
Los algoritmos de Búsqueda Local Iterada son una metaheurística que combinan una
heurística de búsqueda local junto a una modificación del punto de búsqueda que
permite una exploración más amplia del espacio de soluciones factibles.
El funcionamiento del algoritmo es bastante simple. Primero, se parte de una
solución inicial s y se le aplica alguna heurística de búsqueda local a dicha solución.
Posteriormente, se aplica un lazo que consiste en introducir modificaciones
aleatoriamente a la solución obtenida mediante la búsqueda local, obteniendo una
nueva solución 𝑠′.
A esta solución modificada 𝑠′, se le vuelve a aplicar la heurística de búsqueda inicial,
obteniendo una nueva solución 𝑠′′, a la que se le volverá a realizar una mutación
aleatoria y se continuará ejecutando el lazo hasta cumplir el criterio de parada definido
en el algoritmo.
26
Algunas variantes de este algoritmo modifican los criterios de parada o la forma en
que se realiza la mutación. Por ejemplo, una opción que puede resultar interesante es
realizar las mutaciones en las soluciones obtenidas mediante la búsqueda local
basándose en historial de búsqueda. También puede hacerse que el historial de
búsqueda de soluciones de las iteraciones realizadas anteriormente determine el
criterio de parada del algoritmo.
3.3.6. Optimización mediante Colonia de Hormigas (“Ant Colony Optimization”)
Este tipo de algoritmos son la base utilizada en el algoritmo propuesto en este
Proyecto, por lo que será desarrollado en más profundidad en el apartado siguiente.
27
3.4. Algoritmos de Colonias de Hormigas
En este apartado se presenta el Algoritmo de Colonias de Hormigas (“Ant Colony
Optimization” ACO según sus siglas en inglés), una metaheurística presentada por vez
primera en 1992 por Marco Dorigo. Este tipo de algoritmos están basados en el
comportamiento de las colonias de hormigas, tal como su nombre sugiere, y pertenecen
al campo de algoritmos basados en el comportamiento de enjambres (“swarm
intelligence”), un campo de estudio relativamente nuevo que ha derivado en el campo
de la robótica de enjambres, una nueva metodología para el estudio del
comportamiento colectivo y de la interacción entre grupos de robots entre ellos y con
el ambiente que les rodea.
Derivado del comportamiento de entes individuales que actúan en grupo aparece el
concepto de inteligencia de enjambre (“Swarm intelligence” en inglés), crucial en el
campo de la inteligencia artificial. La inteligencia de enjambre engloba el
comportamiento colectivo de sistemas descentralizados y que se organiza de forma
autónoma sin dirección por parte del exterior, ya sean estos naturales o artificiales.
Los sistemas basados en el concepto de inteligencia de enjambre consisten en una
población de individuos que interactúan de forma local entre ellos y con el ambiente sin
interferencia de agente externo alguno que les dirija. Dichos individuos siguen reglas
muy simples y no existe una estructura centraliza de control que dirija el
comportamiento de los individuos del grupo.
Los individuos del grupo actúan de forma aleatoria, pero las interacciones de unos
individuos miembros del grupo con otros y con el entorno, causan la aparición de un
fenómeno emergente de comportamiento inteligente colectivo, desconocido por parte
de los individuos del grupo pero provocado por ellos aunque de forma no intencionada.
Dicho concepto es el que se encuentra detrás del algoritmo basado en colonias de
hormigas, que se presenta con más detalle en este apartado.
28
3.4.1. Introducción
3.4.1.1. Comportamiento de las colonias de hormigas naturales
La hormiga es un animal eusocial. Este término procede de la combinación del
término griego “eu”, que significa bueno o real y de la palabra “social”. La eusocialidad
es el mayor nivel de organización social que se da en ciertas especies animales como las
hormigas o las abejas. Para los animales que presentan esta estructura social, la
supervivencia del grupo o colonia es más importante que la de un individuo. Así, a pesar
de la aparente simplicidad de los individuos, el modo de comportamiento colectivo es
altamente sofisticado.
Uno de los comportamientos más destacados de estos animales, entre los que se
incluyen las hormigas, es la reacción colectiva ante estímulos externos. El entomólogo
Pierre Paul Grassé publicó en 1944 que había ciertos estímulos en particular, que él
denominó como estímulos significantes, que provocan una reacción en estos animales
como respuesta. La reacción ante estos estímulos está codificada genéticamente y no
solo afecta a los individuos que directamente reciben el estímulo, sino que éstos son
capaces de transmitir dicho estímulo al resto de individuos de la colonia para provocar
una reacción colectiva.
Gracias a los experimentos realizados por Grassé y por otros científicos, pudo
determinarse que existía una comunicación entre los individuos de las colonias de
ciertos insectos, incluidas las hormigas. Dicha capacidad de comunicación y colaboración
a través del medio físico fue llamada estigmergia.
La estigmergia en el caso de las hormigas se produce a través de una sustancia
conocida como feromona. Esta sustancia deriva su nombre de las palabras griega “fero”
(llevar) y “ormona” (estímulo) y tiene una composición química distintiva en cada
especie animal.
En el caso que nos concierne de las hormigas, las feromonas se producen en varias
glándulas, existiendo un total de 50 glándulas en un individuo. Existe varios tipos de
feromonas que pueden segregar las hormigas, según el objetivo de comunicación que
persiga el individuo: hormonas de atracción sexual, de dispersión, de alarma o de rastro.
El tipo de feromona de rastro es utilizado por las hormigas para señalar el camino
hacia el lugar adecuado para construir un nido para la colonia o para indicar una fuente
de comida. Cuando un individuo encuentra un camino hacia una fuente de comida,
segrega feromona a lo largo del camino para que otros individuos puedan seguir dicha
ruta.
Sin embargo, la sustancia química de dicha feromona es volátil, así que después de
un cierto tiempo el resto de individuos son incapaces de detectar la feromona. No
obstante, cada vez que nuevos individuos toman dicha ruta, van segregando a su vez
29
más feromona que van reforzando el estímulo provocado por los individuos que pasaron
por ese mismo camino anteriormente.
El comportamiento descrito anteriormente fue observado experimentalmente por
Deneubourg. En el conocido como “experimento del puente binario”, se unió una
colonia de hormigas con una fuente de alimento mediante dos puentes que tenían
exactamente la misma longitud.
En un principio, los individuos de la colonia de hormigas escogían cada una
aleatoriamente uno de los dos puentes para cruzar hacia la fuente de alimento y
transportar la comida de vuelta al nido. Cada uno de los individuos segregaba feromona
y la depositaba en el camino.
A medida que el número de hormigas que elegían uno de los dos puentes superaba
a las que elegían el otro puente, la retroalimentación positiva provocada por la
segregación de feromonas de las hormigas, hacía que los individuos, al tener que decidir
por cuál de los dos puentes cruzar, se decantaran cada vez con más probabilidad por
cruzar a través del puente en el que el rastro de feromonas era más fuerte hasta que
llegaba el momento en el que todas las hormigas de la colonia cruzaban por el mismo
puente.
Otro experimento fue realizado por Goss, en el que se repetía la misma situación que
en el experimento de Deneubourg pero en este caso uno de los dos puentes era de una
longitud sensiblemente inferior. Al principio, los individuos hacia su elección de forma
aleatoria como en el experimento anterior. Sin embargo, los individuos que habían
elegido el camino más corto y volvían también por el camino más corto, llegaban más
rápido para realizar el camino una segunda vez. Como lo hacían de forma más rápida, el
rastro de feromona era más fuerte que en el otro camino al haber pasado menos tiempo
desde su segregación y por lo la cantidad que se había volatilizado era menor que la
depositada en el otro camino.
Finalmente, todas las hormigas cruzaban a través del puente más corto hacia la
fuente de alimento. De hecho, el tiempo en el que convergieron hasta usar el camino
más corto era inferior al tiempo que las hormigas del experimento con los dos puentes
de igual longitud tardaron en decidirse por uno de los puentes.
3.4.1.2. Utilización de hormigas artificiales
Los descubrimientos explicados en el apartado anterior, dieron lugar la idea de
diseñar hormigas artificiales que pudieran resolver problemas de optimización de una
forma semejante. En especial, estos algoritmos tratan de imitan los siguientes
comportamientos naturales:
Estigmergia. Al igual que las hormigas naturales depositan feromona como método
de comunicación por estigmergia entre ellas, las hormigas artificiales pueden imitar este
30
comportamiento al modificar de forma adecuada ciertas variables de feromona
asociadas con estados del problema que visitan al construir diferentes soluciones. Estas
hormigas artificiales solo tendrán acceso local a dichas variables de feromona.
Las hormigas virtuales irán modificando sucesivamente los valores numéricos de la
feromona artificial asociados a los distintos estados del problema, obteniéndose un
rastro de feromona artificial, siendo dicho rastro el medio de comunicación entre los
individuos de la colonia. Como en el caso de las hormigas reales, dicho rastro de
feromona virtual también se evaporará en el tiempo para que las hormigas virtuales
tengan incentivos a explorar nuevas direcciones y por lo tanto, otras regiones del
espacio de soluciones del problema.
Realimentación positiva. Como se explicó anteriormente, cuando una hormiga
recorre un camino más corto que el alternativo, dicho rastro de feromona se refuerza
con el paso de otras hormigas y al tardarse menos en cruzar que el otro, la evaporación
de la feromona es más lento, por lo que las hormigas siguientes tenderán a cruzar por
él. Este mecanismo es un poderoso aliado para fomentar la construcción de mejores
soluciones.
Los algoritmos de optimización por colonia de hormigas (conocidos como ACO por
sus siglas en inglés) intentan reflejar dicho comportamiento de las hormigas. Al igual que
en las colonias de hormigas naturales, en los algoritmos ACO se utiliza una colonia
compuesta por una cierta población de individuos que cooperan entre sí para obtener
la comida a través del mejor camino posible; siendo en el caso de las hormigas artificiales
el objetivo el de lograr encontrar una buena solución al problema-
Es importante señalar que una sola hormiga, tanto en la colonia real como en la
artificial, puede encontrar una solución independientemente del resto de individuos. Sin
embargo, a través de la estigmergia y de la realimentación positiva producida por la
feromona, son capaces de encontrar mejores soluciones como grupo que como
individuos.
31
3.4.2. El Algoritmo AS
En este apartado se explicarán las ideas básicas que se aplican al tipo de algoritmos
conocido como Algoritmos de Optimización por colonia de hormigas presentando el
algoritmo Ant System (AS), el primer algoritmo ACO propuesto Marco Dorigo.
Cada hormiga virtual construirá una solución añadiendo componentes a una solución
parcial hasta que obtenga una solución completa escogiendo cada vez entre las distintas
componentes de la solución a los que puede acceder. Por lo tanto, en los algoritmos
ACO se genera una gran cantidad de soluciones, tantas como hormigas exista en la
colonia. Además, en cada iteración del algoritmo, cada una de las hormigas vuelve a
construir una nueva solución. El algoritmo se detendrá cuando se cumpla cierta
condición de fin especificada.
La elección de la nueva solución por parte de cada hormiga en la siguiente iteración
es de tipo pseudo-aleatoria, basándose en el rastro de feromona actualizado al terminar
la anterior iteración. Con dicho rastro de feromona, se asigna una probabilidad a cada
componente de ser escogida mediante una fórmula que recoge toda esta información.
Una característica que no se deriva del comportamiento de las colonias de hormigas
naturales es la mejora de la solución encontrada por las hormigas virtuales mediante la
utilización de una heurística de búsqueda local, que permite refinar la obtención de una
buena solución al problema.
A continuación se muestra el pseudo-código del algoritmo AS presentado por Dorigo
en el Cuadro 5.
procedure AS{
InicializacionDatos
while (not CriterioFin) {
ConstruccionSoluciones
BusquedaLocal
ActualizacionFeromonas
}
}
Cuadro 5. Pseudo-código de las metaheurísticas de colonia de hormigas.
Las fases del algoritmo AS se describen con más detalle a continuación.
32
3.4.2.1. InicializacionDatos
En esta parte del algoritmo se especifican los datos del problema a resolver y se
inicializan los parámetros del algoritmo.
Respecto a los datos del problema, además de definirlos, pueden manipularse dichos
datos para obtener cierta información heurística que se pueda considerar útil para la
obtención de buenas soluciones del mismo.
Los parámetros a definir para el funcionamiento del algoritmo son los siguientes:
El número de hormigas de la colonia (m). Cuanto mayor sea el número de
hormigas, aumentará la capacidad del algoritmo de explorar un espacio
mayor de soluciones. No obstante, también aumentará el tiempo de
computación y la memoria necesaria para ejecutar el algoritmo.
El valor del rastro de feromonas (𝜏𝑖𝑗), inicializándose en un valor 𝜏0 igual para
todas las opciones de componentes de soluciones posibles.
El parámetro de evaporación (𝜌), que reduce la intensidad de los rastros de
feromona depositados por las hormigas.
Los parámetros de influencia relativa del rastro de feromonas (𝛼) y de la
información heurística derivada de los datos del problema (𝛽).
3.4.2.2. ConstruccionSoluciones
En esta fase del algoritmo, cada una de las m hormigas de la colonia virtual construirá
una solución 𝑠𝑘al problema.
Cuando una hormiga deba elegir el elemento a añadir a su solución, seguirá una regla
probabilística que tiene en cuenta tanto la información heurística de los datos del
problema en cuestión del que trata de encontrar una solución como el rastro de
feromona acumulado a lo largo de la ejecución del algoritmo en las iteraciones
anteriores.
Por lo tanto, se trata de llegar a un compromiso entre dos objetivos diferentes para
la construcción de una nueva solución por parte de cada hormiga: ampliar el espacio de
búsqueda de nuevas soluciones hacia zonas donde se presuma que existan soluciones
más prometedoras o insistir en buscar soluciones cercanas a las soluciones de calidad
visitadas anteriormente. Dicho compromiso debe establecerse mediante los parámetros
𝛼 y 𝛽.
33
La regla de probabilidad que sigue cada hormiga para elegir un nuevo elemento a
añadir es la siguiente:
𝑝𝑖𝑗ℎ = {
[𝜏𝑖𝑗]𝛼
[𝜂𝑖𝑗]𝛽
∑ [𝜏𝑖𝑙]𝛼[𝜂𝑖𝑙]𝛽𝑙∈𝑁𝑖
ℎ
, 𝑠𝑖 𝑗 ∈ 𝐶𝑖ℎ
0, 𝑠𝑖 𝑗 ∉ 𝐶𝑖ℎ
(3.4.1)
En esta regla, 𝑝𝑖𝑗ℎ es la probabilidad de que la hormiga h elija la componente j en la
decisión i. En cuanto a 𝐶𝑖ℎ, se trata del conjunto de componentes que es posible añadir
en la decisión i de la hormiga h.
El valor 𝜏𝑖𝑗 representa la intensidad del rastro de feromona en la componente j de la
decisión i. Respecto a 𝜂𝑖𝑗, es el parámetro que contiene la información heurística de la
componente j en la decisión i.
3.4.2.3. BusquedaLocal
Las heurísticas de Búsqueda Local resultan efectivas cuando se parte de una buena
solución y se pretende encontrar en su vecindad un óptimo local. Debido a que tras el
paso anterior se tiene una buena solución pero que no tiene por qué ser el óptimo local,
es usual añadir una fase en la que se realiza una búsqueda local alrededor de la solución
obtenida.
Pese a lo anterior, no siempre se incorpora un algoritmo de búsqueda local al aplicar
las metaheurísticas ACO, ya que a veces su aplicación incrementa excesivamente el
tiempo de computación o no logra obtener una solución mejor que la que ya se tiene.
Por lo tanto, su aplicación o no dependerá del tiempo de problema que se pretenda
resolver.
3.4.2.4. ActualizacionFeromonas
Tras aplicar o no la Búsqueda Local, que tal y como ya hemos comentado es opcional
según las necesidades del tipo de problema concreto a resolver, se deben actualizar los
valores del rastro de feromonas en base a las soluciones obtenidas.
La actualización del valor de las feromonas ocurre en dos pasos consecutivos:
Evaporación del rastro de feromona. Mediante la atenuación del valor de la
feromona, se pretende que las hormigas “olviden” progresivamente las
34
soluciones del pasado y se favorezca la formación de nuevas soluciones. Esta
actualización se realiza aplicando la siguiente fórmula:
𝜏𝑖𝑗 ← (1 − 𝜌) ∙ 𝜏𝑖𝑗; ∀ (i, j) (3.4.2)
Así, tal y como se explicó en apartados anteriores, cuanto mayor es el valor
de 𝜌, denominado “parámetro de evaporación”, más se atenuará el rastro de
feromona en cada iteración del algoritmo.
Deposición de feromona. Basándose en la solución encontrada durante la
presente iteración del algoritmo, cada hormiga depositará una cierta cantidad
de feromona según la bondad de la solución encontrada durante dicha
iteración.
Este valor de feromona depositada en el rastro de la solución obtenida es la
siguiente:
Δτ𝑖𝑗ℎ = {
𝑔(𝑠ℎ), 𝑠𝑖 𝑙𝑎 ℎ𝑜𝑟𝑚𝑖𝑔𝑎 ℎ 𝑟𝑒𝑐𝑜𝑟𝑟𝑒 (𝑖, 𝑗)0, 𝑒𝑛 𝑐𝑎𝑠𝑜 𝑐𝑜𝑛𝑡𝑟𝑎𝑟𝑖𝑜
(3.4.3)
La fórmula para evaluar la calidad de la solución, 𝑔(𝑠ℎ), puede tomar
diversas formas. Una función habitual utilizada es la siguiente:
𝑔(𝑠ℎ) = 𝑄
𝐿ℎ (3.4.4)
Q es una constante y 𝐿ℎ es la longitud del camino de la solución encontrada
por la hormiga h.
Finalmente, utilizando el valor de la feromona depositada en esta iteración,
se actualiza el valor de feromona que se utilizará en la siguiente iteración del
algoritmo:
𝜏𝑖𝑗 ← 𝜏𝑖𝑗 + ∑ Δτ𝑖𝑗ℎ
𝑚
ℎ=1
(3.4.5)
3.4.2.5. CriterioFin
El criterio para terminar de realizar iteraciones en el algoritmo es una decisión que se
debe tomar y en cualquier tipo de criterio sería utilizable, aunque en el Algoritmo AS
original se toma como criterio de finalización un cierto número de iteraciones límite.
35
3.4.3. Algoritmos derivados del AS
Basándose en el Algoritmo AS original, se han presentado muchas modificaciones que
intentan mejorar ciertos aspectos concretos de la metaheurística basada en colonia de
hormigas.
En este apartado se presentan solo los dos algoritmos sucesores directos del
Algoritmo AS pero existen muchas más variantes publicadas.
3.4.3.1. MAX-MIN Ant System (MMAS)
Este algoritmo fue presentado por Stützle y Hoods (iv) como una mejora del
Algoritmo AS original, introduciendo algunas modificaciones.
Actualización del rastro de feromona. En vez de permitir que todas las
hormigas actualicen el rastro de feromona, solo la hormiga con la mejor
solución puede hacerlo. Hay varias opciones a este respecto, ya sea escoger
la hormiga con la mejor solución en la última iteración o la hormiga que haya
generado la mejor solución en cualquiera de las iteraciones anteriores desde
el inicio.
Experimentalmente se ha comprobado que lo más eficiente es elegir al
comienzo la hormiga con mejor solución en la última iteración y a medida que
se ejecutan más iteraciones, comenzar a elegir para actualizar el rastro de
feromona a la hormiga con mejor solución desde el inicio.
Limitación del valor del rastro de feromona. El valor de la feromona solo
puede estar comprendido en un rango [ 𝜏𝑖𝑗 𝑚𝑖𝑛 , 𝜏𝑖𝑗 𝑚𝑎𝑥 ], de donde este
algoritmo toma su nombre. Como solo una hormiga va a actualizar el rastro
de feromona, imponiéndose esta restricción se evita que la búsqueda se
estanque, permitiendo que todos los arcos tengan una probabilidad, aunque
sea pequeña de ser elegidos como elementos de la solución.
De hecho, al limitar 𝜏𝑖𝑗 en un rango de valores, se limita también 𝑝𝑖𝑗, que es
la probabilidad de que una hormiga escoja avanzar hacia j estando en i.
Actualización del rastro de feromona. Además de limitar los valores de la
feromona, el valor de inicialización en este algoritmo del rastro de feromona
se toma como 𝜏𝑖𝑗 𝑚𝑎𝑥 con el objetivo incrementar la exploración al comienzo
de la ejecución.
Otra modificación realizada en este algoritmo es la forma en que se actualiza
el valor de la feromona. Cuando el algoritmo detecta que la búsqueda de
nuevas soluciones se ha quedado estancada o no se ha logrado encontrar una
solución mejor durante un determinado número de iteraciones, se procede a
36
inicializar de nuevo el valor de la feromona para permitir explorar en otra
región de soluciones.
Por lo tanto, tras la evaporación de la feromona, se deposita nueva feromona
según la siguiente expresión:
Δτ𝑖𝑗𝑚𝑒𝑗𝑜𝑟
= {
1
𝐿𝑚𝑒𝑗𝑜𝑟, 𝑠𝑖 𝑙𝑎 𝑚𝑒𝑗𝑜𝑟 𝑠𝑜𝑙𝑢𝑐𝑖ó𝑛 𝑟𝑒𝑐𝑜𝑟𝑟𝑒 (𝑖, 𝑗)
0, 𝑒𝑛 𝑐𝑎𝑠𝑜 𝑐𝑜𝑛𝑡𝑟𝑎𝑟𝑖𝑜
(3.4.6)
Y por lo tanto, se actualiza el rastro de feromona del siguiente modo:
𝜏𝑖𝑗 ← 𝜏𝑖𝑗 + Δτ𝑖𝑗𝑚𝑒𝑗𝑜𝑟
∀ (i, j) (3.4.7)
En cuanto a los resultados de su utilización experimental, la característica típica de
estos algoritmos es que tienen una fase de exploración más largo al tener un valor inicial
de la feromona máximo y una tasa de evaporación menor. Por lo tanto, las diferencias
entre rastros de feromona son muy bajos al principio de la ejecución y la fase de
explotación tarda en aparecer más que en el resto de algoritmos basados en colonia de
hormigas. Sin embargo, a pesar de su lentitud en obtener buenas soluciones, al contar
con más peso la experiencia acumulada, logra obtener soluciones de gran calidad.
3.4.3.2. Ant Colony System (ACS)
El algoritmo de Ant Colony Sytem (ACS, según sus siglas en inglés), fue propuesto por
Dorigo y Gambardella (v) en 1997 como una modificación al algoritmo AS y fue uno de
los primeros sucesores de éste.
Los cambios principales introducidos en este algoritmo respecto al AS original son
tres:
Regla de elección más agresiva. En vez de utilizar la probabilidad 𝑝𝑖𝑗ℎ del
Algoritmo AS, se utiliza una regla proporcional pseudo-aleatoria. La regla es la
siguiente:
𝑗 = {𝑎𝑟𝑔𝑚𝑎𝑥
𝑙∈𝑁𝑖ℎ { 𝜏𝑖𝑙[𝜂𝑖𝑗]
𝛽} , 𝑠𝑖 𝑞 ≤ 𝑞0
𝐽, 𝑠𝑖 𝑞 > 𝑞0
(3.4.8)
En la regla anterior, q es una variable distribuida uniformemente en [0,1]. El
parámetro 𝑞0 puede tomar los valores 0 ≤ 𝑞0 ≤ 1. En cuanto a J, se trata de
la decisión seleccionada según la Fórmula 3.4.1 con una valor de 𝛼 = 1.
37
Cuando 𝑞 ≤ 𝑞0 se utiliza la información heurística y el rastro de feromona en
la toma de decisión. Por el contrario, cuando 𝑞 > 𝑞0 se aplica la regla de
exploración controlada que se utilizaba en el algoritmo AS.
Ajustando el valor del parámetro 𝑞0 se puede concentrar la búsqueda
alrededor de la mejor solución encontrada hasta el momento si se aproxima
hacia 𝑞0 = 1 y si, por el contrario, su valor se hace descender hacia 𝑞0 = 0 se
dispersa la búsqueda y se promueve una mayor exploración del espacio de
soluciones.
Cambio en la actualización de feromona. La actualización de la feromona se
hace en el algoritmo ACS de una forma diferente.
En primer lugar, en este algoritmo solo evapora deposita feromona la hormiga
con la mejor solución encontrada hasta el momento desde el principio de la
ejecución. Como consecuencia, en cada iteración solo se actualiza el rastro de
feromona de los arcos de la mejor solución.
La actualización del valor de la feromona, sigue la siguiente regla:
𝜏𝑖𝑗 ← (1 − ρ) ∙ 𝜏𝑖𝑗 + ρ ∙ Δτ𝑖𝑗𝑚𝑒𝑗𝑜𝑟
; ∀ (i, j) ∈ 𝑠𝑚𝑒𝑗𝑜𝑟 (3.4.9)
Como puede observarse, en la Fórmula 3.4.9 se utiliza el factor ρ para
ponderar el nuevo valor del rastro de feromona entre el de la iteración
anterior y la cantidad de feromona depositada
Sin embargo, además de la actualización de feromona a nivel global, en el
algoritmo ACS se aplica una actualización local cada vez que una hormiga hace
una elección. La regla de actualización es la siguiente:
𝜏𝑖𝑗 ← (1 − ξ) ∙ 𝜏𝑖𝑗 + 𝜉 ∙ 𝜏0 (3.4.10)
El parámetro ξ puede tomar los valores 0 < ξ < 1 y 𝜏0 es el valor de
inicialización del rastro de feromonas.
La utilización de la actualización local permite hacer disminuir el valor de
feromona sobre la elección de la hormiga, permitiendo que el resto de
hormigas construyan soluciones diferentes y diversificar la búsqueda en el
espacio de soluciones.
En cuanto a la aplicación del algoritmo ACS, cabe destacar que los mejores resultados
se han obtenido para valores elevados de 𝑞0, por lo que no tiene fase de exploración
sino que desde las primeras iteraciones entre en fase de explotación de soluciones, a
partir de la mejor solución encontrada hasta el momento y buscando en los alrededores
de la solución haciendo pequeñas variaciones a ésta.
38
Por esta razón, los algoritmos ACS convergen rápidamente y son más rápidos, pero
realizan una menor exploración del espacio de soluciones que el resto de algoritmos.
39
3.5. Aplicación al Problema VRPMD
En este Proyecto, se va a proponer un algoritmo basado en la metaheurístca ACO
para resolver el problema VRPMD ya descrito en apartados anteriores. Pese a que en la
descripción del problema se hizo un repaso al modelo de los problemas TSPMD y
VRPMD, en adelante solo se hará referencia al problema VRPMD y se formulará un solo
algoritmo de resolución. De hecho, como puede observarse claramente en la
formulación del modelo, el problema TSPMD es una particularización del VRPMD con un
solo vehículo.
El algoritmo propuesto para resolver el problema VRPMD está basado en un
algoritmo para resolver la variante del problema del ruteo de vehículos con ventanas
temporales (conocido como VRPTW, “Vehicle Routing Problem with Time Windows”, en
inglés). Dicho problema es un problema VRP donde cada cliente tiene una ventana
temporal en el cual puede ser visitado. Sin embargo, cada cliente solo tiene una posición
geográfica en todo el problema.
Partiendo del algoritmo propuesto para la resolución del problema VRPTW en (vi), (vii)
y (viii), se han realizado las modificaciones oportunas para permitir que cada uno de los
clientes pueda tener dos posiciones geográficas distintas, cada una de ellas con distintas
ventanas temporales en las cuales pueda ser visitado.
3.5.1. Descripción del general algoritmo
El problema a resolver trata de proponer las rutas que deben recorrer un conjunto
de vehículos para visitar a todos los clientes en al menos una de las dos localizaciones
geográficas donde pueden estar, partiendo todos los vehículos de un depósito y
volviendo a él tras realizar las visitas a los clientes. El objetivo es que las rutas propuestas
tengan el menor coste posible, medido en términos de distancia global recorrida.
El algoritmo propuesto tomado como base para la resolución del problema VRPTW,
tiene un enfoque capacitivo. Esto es, los vehículos tienen una capacidad de carga y los
clientes tienen una demanda de productos. Estas características sobrepasan la
descripción del problema definido para ser resuelto y por lo tanto, no se tomarán en
consideración.
El problema se representa a través de un grafo G = (V, A), donde los vértices V son las
localizaciones de los clientes y la localización del depósito y las aristas A son los caminos
que existen entre los distintos clientes y con el depósito. Los costes asociados a atravesar
cada arista del problema son las distancias entre los nodos.
En el apartado siguiente se describe de forma detallada el algoritmo propuesto. El
código del algoritmo escrito para ser ejecutado en Matlab se presenta en los Anexos.
40
3.5.2. Pseudo-código y descripción de las fases de resolución
Las fases principales del algoritmo propuesto se describen en el Cuadro 6 mostrado
abajo y serán desarrolladas en sucesivos sub-apartados.
procedure AlgoVRPMD{
InicializacionDatos
SolucionInicial
while (not CriterioFin) {
InicializarFeromona
ConstruccionSoluciones
ActualizacionFeromona
}
Admisible
}
Cuadro 6. Pseudo-código del algoritmo “AlgoVRPMD”.
3.5.2.1. InicializacionDatos
En esta fase del algoritmo, se inicializa la variable de evaporación del rastro de
feromona (𝜌), se calcula el tamaño de la matriz A y se calculan las distancias entre todos
los nodos del problema. La matriz A contiene los datos del problema que se va a resolver.
La estructura de la matriz A es la siguiente, teniendo en cuenta que cada fila
representa un nodo del problema, a excepción del nodo de depósito, que en todo el
problema se considerará situado en el punto (0, 0):
[x y demanda inicio final tiempo]
Los valores x e y representan las coordenadas de posición del nodo en el plano
bidimensional. La demanda no se tendrá en cuenta para la resolución de este problema
y será de 1 para todos los nodos. Los valores inicio y final se utilizan para representar la
ventana temporal en que el nodo es accesible y tiempo es una variable que mide la
duración de dicha ventana temporal.
Es importante notar que los dos nodos posibles de cada cliente están agrupados por
pares en la matriz A. Esto es, el primer cliente tendrá como nodos las filas 1 y 2 de la
matriz A, el segundo cliente tendrá como nodos las filas 3 y 4 y así sucesivamente.
41
3.5.2.2. SolucionInicial
Como se mencionó en la descripción de la metaheurística ACO en apartados
anteriores, estos algoritmos necesitan partir de una solución inicial y si tal solución inicial
es buena, la metaheurística ACO dará un mejor resultado.
Por lo tanto, en esta fase del algoritmo, se va a obtener una solución inicial. Puede
usarse una heurística cualquiera, pero en este caso se ha utilizado la heurística conocida
como “Push Forward Insertion Heuristic” (PFIH, en sus siglas en inglés), introducido por
Solomon para resolver el problema VRPTW (ix). Este algoritmo es recomendado en
diversas publicaciones como una buena opción para encontrar una solución inicial, entre
ellos en (x), ya que en general es una buena solución pero fácilmente mejorable
mediante otras heurísticas.
El algoritmo PFIH es una heurística de construcción de soluciones. La forma de
construir una solución por parte del PFIH es elegir un nodo inicial e ir añadiendo los
nodos restantes a la ruta, buscando el menor coste entre los nodos ya incluidos en la
ruta. Cuando ya no se pueden añadir nodos a la ruta porque o hay disponible ningún
compatible con las restricciones de las ventanas temporales, se crea una nueva ruta y
se repite el mismo proceso, creando las rutas necesarias para llegar a todos los nodos.
El método de elección del primer nodo utilizado es una regla para determinar el coste
de cada, eligiéndose el nodo con el menor coste:
𝐶𝑜𝑠𝑡𝑒𝑖 = −𝛼 ∙ 𝑑0𝑖 + 𝛽 ∙ 𝑙𝑖 + 𝛾 ∙ (𝜋
360∙ 𝑑0𝑖) (3.5.1)
En la Fórmula (3.5.1), 𝑑0𝑖 es la distancia desde el depósito (nodo 0) hasta el cliente i.
El valor 𝑙𝑖 es el tiempo final de la ventana temporal del cliente i. Los pesos aplicados a
los factores de dicha Fórmula se han tomado con los siguientes valores:
𝛼 = 0.7 ; 𝛽 = 0.1; 𝛾 = 0.2
Por lo tanto, la elección del primer nodo es determinada por la distancia, el tiempo
final de la ventana temporal y la coordenada polar entre ambos nodos.
Tras insertar el nodo inicial, sucesivamente va añadiendo a la ruta el nodo que
minimiza el coste total de la ruta, cumpliendo las restricciones de tiempo.
Tras ejecutar la heurística PFIH, se procede a calcular el coste de la solución hallada.
Hay que notar, que dicha solución incluye todos los nodos del problema, dos por cada
cliente. Por lo tanto, no se trata de una solución factible para el problema VRPMD, pero
sí lo es para el VRPTW. No obstante, servirá como solución inicial para orientar las fases
siguientes del algoritmo.
42
3.5.2.3. ConstruccionSoluciones
Esta es la parte central del algoritmo, donde se aplica la metaheurística basada en
colonia de hormigas propiamente dicha, en este caso se hace uso de un algoritmo ACO.
El funcionamiento de la metaheurística y sus parámetros se han explicado
convenientemente en apartados anteriores.
La principal particularidad de esta aplicación es el criterio de decisión que utilizan las
hormigas para escoger un nodo es el siguiente:
𝑗 = {𝑎𝑟𝑔𝑚𝑎𝑥
𝑗∈𝑁𝑖ℎ {[𝜏𝑖𝑗][𝜂𝑖𝑗(𝑡)]
𝛽} , 𝑠𝑖 𝑞 ≤ 𝑞0
𝐽, 𝑠𝑖 𝑞 > 𝑞0
(3.5.2)
En la regla anterior, q es una variable distribuida uniformemente en [0,1]. El
parámetro 𝑞0 puede tomar los valores 0 ≤ 𝑞0 ≤ 1. En cuanto a J, se trata de la decisión
seleccionada según la Fórmula 3.4.1 con una valor de 𝛼 = 1.
Cuando 𝑞 ≤ 𝑞0 se utiliza la información heurística y el rastro de feromona en la toma
de decisión. Por el contrario, cuando 𝑞 > 𝑞0 se aplica la regla de exploración controlada
que se utilizaba en el algoritmo AS, Fórmula (3.4.1).
A través del parámetro 𝛽 se puede controlar la importancia relativa del historia del
búsqueda respecto a la intensidad del rastro de feromona, que se toma como 𝛼 = 1.
Este criterio de decisión es característico de los algoritmos “Ant Colony System”, tal
como se explicó en el apartado correspondiente.
Además de esta característica, el resto de características de los algoritmos ACS han
sido aplicadas, incluyendo la actualización local del rastro de feromona dentro de la fase
de construcción de soluciones, utilizando la Fórmula (3.4.10).
3.5.2.4. ActualizacionFeromona
Tras finalizar la fase anterior, se procede a realizar la actualización del rastro de
feromona, en este caso tratándose de un algoritmo ACO, solo de los arcos de la mejor
solución, aplicando la Fórmula (3.4.9) ya comentada en el apartado referido a los
algoritmos ACO.
43
3.5.2.5. Admisible
Esta función se utiliza para garantizar que la solución es admisible y que la restricción
de visitar un solo nodo por cada cliente se cumple
3.5.2.6. CriterioFin
El criterio utilizado para finalizar la ejecución del algoritmo es el número de
iteraciones, “a”.
44
4. Problemas y resultados
En este capítulo, en primer lugar comprobaremos la validez del algoritmo propuesto
y realizaremos un conjunto de problemas en el que se modificarán algunos parámetros
del algoritmo para comprobar cómo afectan a la obtención de soluciones y al tiempo de
ejecución.
4.1. Comprobaciones
4.1.1. Problema 1
En este primer problema, se trata de comprobar que el algoritmo solo visita uno de
los dos nodos de un solo cliente.
El problema tiene los datos mostrados en la Tabla 1.
Cliente Nodo X Y Demanda T inicial T final Tiempo
1 1 2 0 1 0 15 15
1 2 4 0 1 16 31 15
Tabla 1. Datos del Problema 1.
La solución presentada por el algoritmo se muestra en la Ilustración 1.
45
Ilustración 1. Solución del Problema 1.
El coste de la mejor solución encontrada por el algoritmo es de 4 unidades.
46
4.1.2. Problema 2
En este problema, veremos cómo responde el algoritmo cuando hay 5 clientes. En
este caso, dejaremos muy laxas las restricciones temporales para comprobar si el
algoritmo funciona correctamente para varios clientes y seleccionando las localizaciones
más cercanas al depósito cuando las ventanas temporales no juegan ningún papel.
El problema tiene los siguientes datos mostrados en la Tabla 2.
Cliente Nodo X Y Demanda T inicial T final Tiempo
1 1 0 2 1 0 200 200
1 2 0 4 1 0 200 200
2 3 2 0 1 0 200 200
2 4 4 0 1 0 200 200
3 5 -2 0 1 0 200 200
3 6 -4 0 1 0 200 200
4 7 0 -2 1 0 200 200
4 8 0 -4 1 0 200 200
5 9 3 3 1 0 200 200
5 10 4 4 1 0 200 200
Tabla 2. Datos del Problema 2.
El coste de la solución es de 15.98 unidades y el tiempo de ejecución de 4.45
segundos. A continuación se muestra un gráfico con la solución propuesta:
47
Ilustración 2. Solución del Problema 2.
48
4.1.3. Problema 3
Este problema es igual al anterior pero con un mayor número de clientes, en este
caso 10 clientes, lo que totalizan 20 nodos en la resolución.
Los datos del problema están en la siguiente tabla, Tabla 3.
Cliente Nodo X Y Demanda T inicial T final Tiempo
1 1 0 2 1 0 200 200
1 2 0 4 1 0 200 200
2 3 2 0 1 0 200 200
2 4 4 0 1 0 200 200
3 5 -2 0 1 0 200 200
3 6 -4 0 1 0 200 200
4 7 0 -2 1 0 200 200
4 8 0 -4 1 0 200 200
5 9 3 3 1 0 200 200
5 10 4 4 1 0 200 200
6 11 -7 -6 1 0 200 200
6 12 -9 -7 1 0 200 200
7 13 8 9 1 0 200 200
7 14 11 10 1 0 200 200
8 15 -5 8 1 0 200 200
8 16 -7 9 1 0 200 200
9 17 -13 12 1 0 200 200
9 18 -14 14 1 0 200 200
10 19 -10 0 1 0 200 200
10 20 -11 0 1 0 200 200
Tabla 3. Datos del Problema 3.
El coste es de 87.60 y el tiempo de ejecución es de 23.36 segundos. En comparación
con el Problema 2, éste tiene el doble de clientes pero el tiempo de ejecución es cinco
veces mayor, por lo que puede comprobarse que el problema, efectivamente es NP-
hard.
El gráfico con la solución mostrada de forma visual se encuentra en la página
siguiente.
49
Ilustración 3. Solución del Problema 3.
50
4.1.4. Problema 4
En este problema comprobaremos con 2 clientes, si el algoritmo cumple las dos
restricciones principales adicionales del VRPMD respecto a los problemas VRP usuales,
esto es: que solo visite un nodo por cada cliente y que respete las ventanas temporales
de visita.
Los datos de este problema son los siguientes:
Cliente Nodo X Y Demanda T inicial T final Tiempo
1 1 3 2 1 0 10 10
1 2 4 5 1 15 25 10
2 3 -3 7 1 0 10 10
2 4 -2 5 1 15 25 10
Tabla 4. Datos del Problema 4.
La solución se muestra a continuación:
Ilustración 4. Solución del Problema 4.
51
Puede observarse que la solución es una única ruta [0 2 4]. El coste de esta solución
es de 17.79 unidades y el tiempo de ejecución fue de 2.15 segundos.
Examinemos cuáles serían todas las soluciones admisibles a este problema:
Ruta Coste
0-1-3-0 19.03
0-1-0; 0-4-0 17.98
0-2-0; 0-3-0 28.04
0-2-4 17.79
Tabla 5. Soluciones admisibles para el Problema 4.
Se puede observar que la solución encontrada por el algoritmo, la cuarta de la tabla,
es efectivamente la de menor coste.
Viendo el grafo del problema, podría pensarse en que la solución que incluye los
nodos 1-4 podría ser la de mínimo coste, pero si se observa las restricciones en cuanto
a ventanas temporales, vemos que sería necesario hacer dos rutas distintas, saliendo y
regresando al depósito en cada una de ellas.
52
4.1.5. Problema 5
Ahora resolvemos un problema con los mismos clientes y localizaciones que en el
Problema 3 pero haremos que cada cliente tenga en sus dos nodos, ventanas
temporales distintas. De esta forma, podemos modelar la situación real de reparto de
mercancía a distintos clientes y que cada uno de ellos esté en un lugar geográfico
distinto según el tramo del día.
Los datos del problema son los siguientes:
Cliente Nodo X Y Demanda T inicial T final Tiempo
1 1 0 2 1 0 10 10
1 2 0 4 1 15 90 75
2 3 2 0 1 0 10 10
2 4 4 0 1 15 90 75
3 5 -2 0 1 15 25 10
3 6 -4 0 1 30 90 50
4 7 0 -2 1 0 10 10
4 8 0 -4 1 15 90 75
5 9 3 3 1 0 10 10
5 10 4 4 1 15 25 10
6 11 -7 -6 1 0 35 35
6 12 -9 -7 1 40 90 50
7 13 8 9 1 0 35 35
7 14 11 10 1 40 90 50
8 15 -5 8 1 0 35 35
8 16 -7 9 1 40 90 50
9 17 -13 12 1 0 35 35
9 18 -14 14 1 40 90 50
10 19 -10 0 1 0 35 35
10 20 -11 0 1 40 90 50
Tabla 6. Datos del Problema 5.
El coste de la solución es de 119.24 unidades y es superior al coste del Problema 3, al
ser el Problema 5 más restrictivo en cuanto a las ventanas temporales.
A causa de las restricciones en las ventanas temporales de los clientes, no es posible
visitarlos a todos en una sola ruta, tenido que realizar tres salidas, tal como se muestra
en el gráfico a continuación, donde cada ruta se dibuja de un color distinto.
53
Ilustración 5. Solución del Problema 5.
El tiempo de ejecución fue de 10.26 segundos. Las rutas y los correspondientes nodos
son los siguientes:
Ruta 1: 12 – 20 – 16 – 18 – 4
Ruta 2: 8 – 14 – 2 – 6
Ruta 3: 10
54
4.2. Calibración
Ahora se realizará un ejercicio de calibración para determinar qué valor de los
parámetros del problema logran obtener una solución mejor.
Los parámetros que se estudiarán son el número de hormigas (m) y el coeficiente de
evaporación de la feromona (𝜌).
El problema sobre el que se va a realizar la calibración (Problema 6) es una
modificación de los datos del Problema 5 donde se han añadido más clientes. Los datos
se encuentran en la tabla siguiente.
Cliente Nodo X Y Demanda T inicial T final Tiempo
1 1 0 2 1 0 10 10
1 2 0 4 1 15 90 75
2 3 2 0 1 0 10 10
2 4 4 0 1 15 90 75
3 5 -2 0 1 15 25 10
3 6 -4 0 1 30 90 50
4 7 0 -2 1 0 10 10
4 8 0 -4 1 15 90 75
5 9 3 3 1 0 10 10
5 10 4 4 1 15 25 10
6 11 -7 -6 1 0 35 35
6 12 -9 -7 1 40 90 50
7 13 8 9 1 0 35 35
7 14 11 10 1 40 90 50
8 15 -5 8 1 0 35 35
8 16 -7 9 1 40 90 50
9 17 -13 12 1 0 35 35
9 18 -14 14 1 40 90 50
10 19 -10 0 1 0 35 35
10 20 -11 0 1 40 90 50
11 21 0 10 0 0 90 90
11 22 1 11 0 100 200 100
12 23 9 -5 0 0 90 90
12 24 10 -6 0 100 200 100
13 25 0 -9 0 0 90 90
13 26 1 -10 0 100 200 100
14 27 -3 -7 0 0 90 90
14 28 -3 -9 0 100 200 100
15 29 -3 10 0 0 90 90
15 30 -3 11 0 100 200 100
16 31 -4 17 0 0 90 90
16 32 -4 16 0 100 200 100
55
17 33 -8 12 0 0 90 90
17 34 -9 14 0 100 200 100
18 35 -12 3 0 0 90 90
18 36 -11 4 0 100 200 100
19 37 7 15 0 0 90 90
19 38 8 16 0 100 200 100
20 39 -15 -16 0 0 90 90
20 40 -17 -15 0 100 200 100
Tabla 7. Datos del Problema 6.
En la tabla a continuación se muestran los valores de los parámetros, el valor del
coste de la mejor solución obtenida y el tiempo de ejecución del algoritmo.
m 𝝆 Coste Tiempo ejecución
30 0.05 325.91 4.323
40 0.05 338.25 5.766
50 0.05 301.67 7.424
100 0.05 315.71 13.985
150 0.05 316.54 20.443
200 0.05 318.55 27.456
250 0.05 328.85 35.932
300 0.05 342.02 41.011
30 0.10 322.55 7.584
40 0.10 327.03 5.679
50 0.10 299.46 7.204
100 0.10 309.62 18.903
150 0.10 319.80 20.630
200 0.10 327.77 27.325
250 0.10 299.41 67.341
300 0.10 326.21 45.334
30 0.20 333.15 4.983
40 0.20 305.36 8.711
50 0.20 301.90 16.778
100 0.20 320.97 25.284
150 0.20 301.54 20.864
200 0.20 305.67 27.251
250 0.20 323.42 34.355
300 0.20 304.04 41.041
Tabla 8. Parámetros y resultados de las pruebas de calibración.
Los resultados de estas pruebas pueden observarse en los siguientes gráficos.
56
En el primer gráfico, Ilustración 6, se muestra el coste de la solución encontrada por
el algoritmo según el valor del coeficiente de evaporación y del número de hormigas.
Ilustración 6. Costes de las soluciones obtenidas según los parámetros de calibración.
En este otro gráfico, Ilustración 7, se observan los diferentes tiempos de ejecución
del algoritmo.
Ilustración 7. Tiempo de ejecución de las soluciones obtenidas según los parámetros de calibración.
290
300
310
320
330
340
350
30 40 50 100 150 200 250 300
Número de hormigas (m)
Coste de la Función Objetivo
ro=0.05
ro=0.10
ro=0.20
0
10
20
30
40
50
60
70
80
30 40 50 100 150 200 250 300
Número de hormigas (m)
Tiempo de Ejecución
ro=0.05
ro=0.10
ro=0.20
57
Puede observarse, que según las pruebas realizadas, el número de hormigas con el
que se obtiene mejores soluciones es m=50. En cuanto al valor del coeficiente de
evaporación de feromona, su valor más eficiente es 𝝆 = 0.10.
58
4.3. Resolución de problemas
Se resolverá una batería de 7 problemas, todos ellos con los valores de los
parámetros obtenidos en el apartado anterior. Los detalles de cada uno de estos
problemas se especifican a continuación y al final se aportará una tabla resumen con los
costes de la solución obtenida en cada problema y el tiempo de ejecución.
4.3.1. Problema 7
Datos
Cliente Nodo X Y Demanda T inicial T final Tiempo
1 1 4 6 1 0 10 10
1 2 3 4 1 15 90 75
2 3 -5 -6 1 0 10 10
2 4 -7 -11 1 15 90 75
3 5 3 9 1 15 25 10
3 6 -4 0 1 30 90 50
4 7 14 12 1 0 10 10
4 8 -9 8 1 15 90 75
5 9 5 3 1 0 10 10
5 10 2 0 1 15 25 10
6 11 -4 6 1 0 35 35
6 12 7 -2 1 40 90 50
7 13 5 11 1 0 35 35
7 14 16 15 1 40 90 50
8 15 10 9 1 0 35 35
8 16 7 2 1 40 90 50
9 17 2 18 1 0 35 35
9 18 5 24 1 40 90 50
10 19 -14 35 1 0 35 35
10 20 -22 -10 1 40 90 50
11 21 11 -18 1 0 90 90
11 22 19 -28 1 100 200 100
12 23 -37 -41 1 0 90 90
12 24 -19 -35 1 100 200 100
13 25 22 29 1 0 90 90
13 26 28 35 1 100 200 100
14 27 -5 -14 1 0 90 90
14 28 5 12 1 100 200 100
15 29 15 11 1 0 90 90
15 30 6 19 1 100 200 100
16 31 18 11 1 0 90 90
16 32 25 20 1 100 200 100
59
17 33 0 9 1 0 90 90
17 34 3 5 1 100 200 100
18 35 -11 -18 1 0 90 90
18 36 -12 -8 1 100 200 100
19 37 14 20 1 0 90 90
19 38 -11 25 1 100 200 100
20 39 4 7 1 0 90 90
20 40 5 -6 1 100 200 100
Tabla 9. Datos del Problema 7.
Resultados (una ruta en cada fila)
22 24 36 0 0 0 0
39 26 38 34 32 30 28
20 0 0 0 0 0 0
14 4 0 0 0 0 0
18 6 16 8 0 0 0
11 10 0 0 0 0 0
1 0 0 0 0 0 0
Gráfico
Ilustración 8. Solución del Problema 7.
60
4.3.2. Problema 8
Datos
Cliente Nodo X Y Demanda T inicial T final Tiempo
1 1 9 -5 1 0 30 10
1 2 -5 3 1 15 90 75
2 3 -3 9 1 0 30 10
2 4 -15 8 1 15 90 75
3 5 -8 8 1 15 45 10
3 6 8 5 1 50 90 50
4 7 6 10 1 0 50 10
4 8 7 25 1 60 110 75
5 9 15 15 1 0 50 10
5 10 31 1 1 60 110 10
6 11 -28 8 1 0 50 35
6 12 -14 6 1 60 110 50
7 13 -6 -6 1 0 50 35
7 14 0 -8 1 60 110 50
Tabla 10. Datos del Problema 8.
Resultados (una ruta en cada fila)
8 14 0
12 10 0
5 2 4
0 0 0
61
Gráfico
Ilustración 9. Solución del Problema 8.
62
4.3.3. Problema 9
Datos
Cliente Nodo X Y Demanda T inicial T final Tiempo
1 1 8 7 1 0 75 75
1 2 5 5 1 90 250 160
2 3 3 -3 1 0 75 75
2 4 -5 2 1 90 250 160
3 5 -15 0 1 0 75 75
3 6 25 1 1 90 250 160
4 7 -6 18 1 0 75 75
4 8 9 -12 1 90 250 160
5 9 19 -11 1 0 75 75
5 10 -25 -5 1 90 250 160
6 11 21 8 1 0 75 75
6 12 9 3 1 90 250 160
7 13 14 2 1 0 75 75
7 14 11 8 1 90 250 160
8 15 -13 10 1 0 75 75
8 16 -15 12 1 90 250 160
9 17 18 -15 1 0 75 75
9 18 -25 -7 1 90 250 160
10 19 2 -6 1 0 75 75
10 20 23 -4 1 90 250 160
11 21 0 28 1 0 75 75
11 22 14 18 1 90 250 160
12 23 6 12 1 0 75 75
12 24 7 31 1 90 250 160
13 25 -8 3 1 0 75 75
13 26 -9 0 1 90 250 160
14 27 -15 -8 1 0 75 75
14 28 12 -4 1 90 250 160
15 29 10 18 1 0 75 75
15 30 4 2 1 90 250 160
16 31 3 8 1 0 75 75
16 32 0 9 1 90 250 160
Tabla 11. Datos del Problema 9.
63
Resultados (una ruta en cada fila)
2 32 28 30 24 0 0
4 18 26 20 6 16 10
8 22 14 12 0 0 0
0 0 0 0 0 0 0
Gráfico
Ilustración 10. Solución del Problema 9.
64
4.3.4. Problema 10
Datos
Cliente Nodo X Y Demanda T inicial T final Tiempo
1 1 -6 -2 1 0 45 45
1 2 -9 10 1 50 180 130
2 3 -4 14 1 0 45 45
2 4 4 17 1 50 180 130
3 5 12 31 1 0 45 45
3 6 10 13 1 50 180 130
4 7 -10 16 1 0 45 45
4 8 13 -18 1 50 180 130
5 9 3 -15 1 0 45 45
5 10 2 -5 1 50 180 130
6 11 8 -4 1 0 45 45
6 12 -9 -9 1 50 180 130
7 13 -5 9 1 0 45 45
7 14 -2 6 1 50 180 130
8 15 -12 31 1 0 45 45
8 16 -3 5 1 50 180 130
9 17 -30 9 1 0 45 45
9 18 -12 6 1 50 180 130
10 19 12 30 1 0 45 45
10 20 -17 20 1 50 180 130
11 21 4 28 1 0 45 45
11 22 6 2 1 50 180 130
12 23 -7 0 1 0 45 45
12 24 8 -10 1 50 180 130
13 25 -9 -11 1 0 45 45
13 26 1 -13 1 50 180 130
14 27 18 -14 1 0 45 45
14 28 2 -9 1 50 180 130
15 29 5 9 1 0 45 45
15 30 -17 6 1 50 180 130
16 31 -15 5 1 0 45 45
16 32 5 -12 1 50 180 130
17 33 6 12 1 0 45 45
17 34 7 8 1 50 180 130
18 35 2 0 1 0 45 45
18 36 5 4 1 50 180 130
Tabla 12. Datos del Problema 10.
65
Resultados (una ruta en cada fila)
36 18 30 34 28 24 8
32 26 22 14 10 0 0
4 6 20 12 16 0 0
1 0 0 0 0 0 0
Gráfico
Ilustración 11. Solución del Problema 10.
66
4.3.5. Problema 11
Datos
Cliente Nodo X Y Demanda T inicial T final Tiempo
1 1 8 -3 1 0 25 25
1 2 9 2 1 30 80 50
2 3 4 8 1 0 60 60
2 4 21 -17 1 70 150 80
3 5 26 -15 1 0 25 25
3 6 -2 -6 1 30 80 50
4 7 -5 -5 1 0 60 60
4 8 -8 10 1 70 150 80
5 9 -9 1 1 0 25 25
5 10 -12 12 1 30 80 50
6 11 20 9 1 0 60 60
6 12 10 5 1 70 150 80
7 13 16 2 1 0 25 25
7 14 6 2 1 30 80 50
8 15 3 -1 1 0 60 60
8 16 8 -8 1 70 150 80
9 17 -9 -6 1 0 25 25
9 18 -14 3 1 30 80 50
10 19 -12 4 1 0 60 60
10 20 7 8 1 70 150 80
11 21 15 2 1 0 25 25
11 22 21 10 1 30 80 50
12 23 14 13 1 0 60 60
12 24 17 14 1 70 150 80
13 25 -17 -14 1 0 25 25
13 26 -13 -9 1 30 80 50
14 27 3 8 1 0 60 60
14 28 5 5 1 70 150 80
Tabla 13. Datos del Problema 11.
Resultados (una ruta en cada fila)
4 12 24 28 16
22 18 0 0 0
10 26 6 8 0
14 20 2 0 0
0 0 0 0 0
67
Gráfico
Ilustración 12. Solución del Problema 11.
68
4.3.6. Problema 12
Datos
Cliente Nodo X Y Demanda T inicial T final Tiempo
1 1 5 -3 1 0 30 30
1 2 9 1 1 40 80 40
2 3 2 25 1 0 30 30
2 4 6 11 1 40 80 40
3 5 4 -8 1 0 30 30
3 6 -9 7 1 40 80 40
4 7 15 -8 1 0 30 30
4 8 -14 9 1 40 80 40
5 9 2 6 1 0 30 30
5 10 3 3 1 40 80 40
6 11 6 9 1 0 30 30
6 12 2 2 1 40 80 40
7 13 -15 6 1 0 30 30
7 14 8 2 1 40 80 40
8 15 -15 17 1 0 30 30
8 16 -2 -8 1 40 80 40
9 17 7 4 1 0 30 30
9 18 -8 2 1 40 80 40
10 19 3 3 1 0 30 30
10 20 1 5 1 40 80 40
11 21 8 2 1 0 30 30
11 22 -14 5 1 40 80 40
12 23 2 5 1 0 30 30
12 24 3 6 1 40 80 40
13 25 -2 1 1 0 30 30
13 26 -5 10 1 40 80 40
Tabla 14. Datos del Problema 12.
Resultados (una ruta en cada fila)
26 8 6 0 0
2 24 22 18 0
4 14 20 12 10
16 0 0 0 0
0 0 0 0 0
69
Gráfico
Ilustración 13. Solución del Problema 12.
70
4.3.7. Problema 13
Datos
Cliente Nodo X Y Demanda T inicial T final Tiempo
1 1 8 -3 1 0 25 25
1 2 9 2 1 30 80 50
2 3 4 8 1 0 60 60
2 4 21 -17 1 70 150 80
3 5 26 -15 1 0 25 25
3 6 -2 -6 1 30 80 50
4 7 -5 -5 1 0 60 60
4 8 -8 10 1 70 150 80
5 9 -9 1 1 0 25 25
5 10 -12 12 1 30 80 50
6 11 20 9 1 0 60 60
6 12 10 5 1 70 150 80
7 13 16 2 1 0 25 25
7 14 6 2 1 30 80 50
8 15 3 -1 1 0 60 60
8 16 8 -8 1 70 150 80
9 17 -9 -6 1 0 25 25
9 18 -14 3 1 30 80 50
10 19 -12 4 1 0 60 60
10 20 7 8 1 70 150 80
11 21 15 2 1 0 25 25
11 22 21 10 1 30 80 50
12 23 14 13 1 0 60 60
12 24 17 14 1 70 150 80
13 25 -17 -14 1 0 25 25
13 26 -13 -9 1 30 80 50
14 27 3 8 1 0 60 60
14 28 5 5 1 70 150 80
15 29 8 5 0 0 25 25
15 30 0 3 0 30 80 50
16 31 12 2 0 0 60 60
16 32 -6 -5 0 70 150 80
17 33 -14 -6 0 0 25 25
17 34 -18 15 0 30 80 50
18 35 1 6 0 0 60 60
18 36 25 -3 0 70 150 80
19 37 1 -5 0 0 25 25
19 38 6 -14 0 30 80 50
20 39 17 -21 0 0 60 60
20 40 13 9 0 70 150 80
21 41 20 8 0 0 25 25
71
21 42 18 9 0 30 80 50
22 43 -9 6 0 0 60 60
22 44 4 1 0 70 150 80
23 45 -3 9 0 0 25 25
23 46 -8 8 0 30 80 50
24 47 15 8 0 0 60 60
24 48 13 4 0 70 150 80
25 49 -12 3 0 0 25 25
25 50 -5 12 0 30 80 50
26 51 -14 22 0 0 60 60
26 52 12 0 0 70 150 80
27 53 10 1 0 0 25 25
27 54 4 -14 0 30 80 50
28 55 -3 -18 0 0 60 60
28 56 -8 -11 0 70 150 80
29 57 9 -8 0 0 25 25
29 58 -6 9 0 30 80 50
30 59 3 -5 0 0 60 60
30 60 -2 -18 0 70 150 80
31 61 -7 -8 0 0 25 25
31 62 -8 5 0 30 80 50
32 63 12 3 0 0 60 60
32 64 10 4 0 70 150 80
33 65 2 5 0 0 25 25
33 66 0 15 0 30 80 50
34 67 3 -10 0 0 60 60
34 68 4 14 0 70 150 80
35 69 1 -2 0 0 25 25
35 70 0 19 0 30 80 50
36 71 -5 1 0 0 60 60
36 72 8 2 0 70 150 80
Tabla 15. Datos del Problema 13.
Resultados (una ruta en cada fila)
72 52 20 60 56 32
4 68 8 48 16 0
12 64 36 24 28 40
44 70 66 0 0 0
62 54 58 50 46 10
42 34 18 0 0 0
30 38 26 6 0 0
72
22 14 2 0 0 0
0 0 0 0 0 0
Gráfico
Ilustración 14. Solución del Problema 13.
73
4.3.8. Resumen de los problemas resueltos
A continuación se muestra, en la Tabla 16, un resumen de la batería de problemas
realizados en este apartado. En la Tabla se muestra para cada problema, el número de
clientes, el coste de la mejor solución obtenida y el tiempo de ejecución del algoritmo.
Ha de indicarse que todos los problemas se han ejecutado en el mismo ordenador y en
las mismas condiciones de ejecución.
Problema Clientes Coste Tiempo ejecución
Problema 7 20 530.72 12.127
Problema 8 7 204.54 2.003
Problema 9 16 341.94 5.924
Problema 10 18 283.37 6.849
Problema 11 14 283.18 4.483
Problema 12 14 140.54 3.764
Problema 13 36 605.28 30.359
Tabla 16. Resultados de los problemas resueltos
74
5. Conclusiones
En este Proyecto se ha realizado una descripción del problema de Rutas de Vehículos
con Destinos Móviles (VRPMD). Posteriormente, se ha realizado un repaso a los
métodos de resolución de problemas de tipo NP-Hard, en los que solo podemos aspirar
a encontrar la mejor solución posible, sin tener certeza de si existe o no otra solución
que cumpla las restricciones del problema y sea mejor que la encontrada.
En dicho repaso, se ha realizado especial hincapié en repasar las metaheurísticas más
comunes utilizadas en la resolución de este tipo de problemas para luego centrar el
análisis en las metaheurísticas basadas en las colonias de hormigas. Tras presentar el
principio sobre el que se basa esta metaheurística, se presentó el primer algoritmo de
este tipo, realizado por Dorigo en 1992 y conocido como “Ant System”.
En posteriores apartados, se hizo un repaso de los dos algoritmos sucesores del
anterior, el “MAX-MIN Ant System” y el “Ant Colony System”. Ambos están basados en
el “Ant System” pero con algunas diferencias que permiten encontrar mejores
soluciones.
Una vez hecha esta exposición sobre las diferentes metaheurísticas disponibles para
la resolución del problema y un repaso a la metaheurística basada en colonias de
hormigas, se propuso un algoritmo, “AlgoVRPMD”, que basado en la optimización por
colonias de hormigas, puede resolver el problema VRPMD.
Para programar el algoritmo, se usó como referencia un algoritmo ACS para la
resolución del problema de Rutas de Vehículos con Ventanas Temporales (VRPMD).
Tras presentar el algoritmo, se resolvió una primera serie de problemas en los que la
solución podía intuirse fácilmente para comprobar el correcto funcionamiento del
algoritmo.
Posteriormente, se resolvió un problema modificando los parámetros de evaporación
de la feromona y del número de hormigas. Tras comprobar los resultados y el tiempo de
ejecución, se obtuvo la conclusión que el número de hormigas de la colonia no debía ser
excesivamente grande, estableciéndose el número óptimo en 50 hormigas. De hecho,
se encontró que aumentar el número de hormigas no solo aumentaba
considerablemente el tiempo de ejecución, sino que además empeoraba la solución
obtenida.
Tras la calibración, se realizó una batería de problemas con un variado número de
clientes y restricciones respecto a las ventanas temporales para asegurar el buen
funcionamiento del algoritmo en problemas más exigentes.
Según se ha podido comprobar experimentalmente, el algoritmo presentado para el
problema VRPMD es capaz de encontrar soluciones factibles y evaluarlas de forma
adecuada, respetando las restricciones típicas de los problemas VRP, además de
respetar también las restricciones adicionales del problema VRPMD, como son:
75
Restricciones de tipo temporal para todos los nodos de posicionamiento.
Restricción de visitar solo un nodo por cada uno de los clientes.
Sin embargo, la estructura de resolución del problema VRPMD utilizada en algoritmo
presentado en este Proyecto tiene ciertas particularidades, como se explicó en el
apartado dedicado a presentar el algoritmo. La colonia de hormigas resuelve el
problema y devuelve una solución cuya admisibilidad no está garantizada.
Es posteriormente, mediante la función “Admisible”, cuando se garantiza la
admisibilidad de la solución y en caso de que la solución encontrada por la colonia de
hormigas no lo fuera, repararla.
La razón para haber optado por esta solución es doble:
1. Se ha perseguido intencionadamente combinar las características de los
algoritmos ACO con una característica importante de las metaheurísticas GRASP,
también conocidos como algoritmos voraces: la rapidez. Al crear soluciones cuya
admisibilidad no está garantizada y repararlas posteriormente, se incrementa la
rapidez del algoritmo.
2. El hecho de que cada cliente sea representado en el problema mediante dos
nodos implica que en la solución hay nodos que no aparecerán. Sin embargo, en
los algoritmos de optimización por colonia de hormigas, cuando las hormigas
deben elegir el camino a escoger desde un nodo hacia adelante, la regla de
decisión tiene un componente probabilístico. Aunque se actuara sobre el valor
del rastro de feromona para hacer tender a la búsqueda de soluciones admisibles,
siempre habría una posibilidad mayor que cero, por muy baja que fuere, de visitar
dos nodos de un mismo cliente. Al comprobar la admisibilidad y realizar la
reparación, se garantiza que la solución obtenida es compatible con dicha
restricción.
A partir del trabajo desarrollado en este Proyecto, debería compararse los resultados
obtenidos a través de la metaheurística basada en colonia de hormigas para la
resolución del problema VRPMD con su resolución con algoritmos que utilicen otras
metaheurísticas, tales como Búsqueda Tabú u otras, ya sean los descritos someramente
en este Proyecto u otros que se consideren adecuados.
El algoritmo propuesto en este Proyecto se ha programado para el caso en que un
cliente tenga dos nodos diferentes pero con una modificación en la función “Admisible”,
podría resolverse problemas con n nodos para cada cliente. El estudio del tiempo de
ejecución del algoritmo respecto al número de nodos por cliente podría ser interesante
para conocer los límites en la resolución del problema VRPMD.
Otro campo en el que seguir trabajando es enriquecer el problema VRPMD
añadiendo variables de capacidad.
76
6. Anexos
6.1. Códigos
6.1.1. AlgoVRPMD: Función principal
function rutas=AlgoVRPMD(A, capacity, numerohormigas)
tic
%InicializacionDatos
B=disttab(A);
ro=0.10;
feromona=[];
[m,n]=size(A);
for i=1:m
nodos(i)=i;
end
%SolucionInicial
pfih_sol=PFIH(A, B, capacity);
best_feasible = pfih_sol;
best_feasible_cost=totalCost(best_feasible, B, 0);
[best_rows, cols] = size(best_feasible);
truck_value = best_feasible_cost/best_rows;
first_cost = totalCost(best_feasible, B, truck_value);
best_feasible_cost = first_cost;
%ConstruccionSoluciones
feromona=phero_initialize(feromona, best_feasible_cost, m);
tauZero = 1/(best_feasible_cost*m);
a=0
[best_route, feromona]=colonia_hormigas(capacity, nodos, A,
B, feromona, tauZero);
k=1
while 1
k=k+1
77
for i=1:numerohormigas
ant=i;
[current_route,
feromona]=colonia_hormigas(capacity, nodos, A, B, feromona,
tauZero);
current_cost=totalCost(current_route, B,
truck_value);
if current_cost<best_feasible_cost
best_feasible=current_route;
best_feasible_cost=current_cost;
a=0;
end
end
%ActualizacionFeromona
feromona=actualizar_feromona_global(feromona,
best_route, B, ro);
feromona=actualizar_feromona_global(feromona,
best_route, B, ro);
a=a+1
if (a>50)
break
end
end
truck_value;
pfih_sol;
best_feasible;
%Admisible
best_route1=admisible(best_feasible, B);
best_route2=admisible(best_route1, B);
best_route3=admisible(best_route2, B);
best_route4=admisible(best_route3, B);
best_route5=admisible(best_route4, B);
best_route6=admisible(best_route5, B);
best_route7=admisible(best_route6, B);
best_route8=admisible(best_route7, B);
best_route9=admisible(best_route8, B);
best_route10=admisible(best_route9, B);
best_route11=admisible(best_route10, B);
best_route12=admisible(best_route11, B);
best_route13=admisible(best_route12, B);
best_route14=admisible(best_route13, B);
best_route15=admisible(best_route14, B);
best_route16=admisible(best_route15, B);
78
best_route17=admisible(best_route16, B);
best_route18=admisible(best_route17, B);
best_route19=admisible(best_route18, B);
best_route20=admisible(best_route19, B);
best_route21=admisible(best_route20, B);
best_route22=admisible(best_route21, B);
first_cost = totalCost(pfih_sol, B, 0);
best_feasible_cost = totalCost(best_route22, B, 0)
toc
rutas=best_route22;
79
6.1.2. PFIH: Algoritmo Push Forward Insertion Heuristic
function routes=PFIH(A, B, capacity)
r=0;
route=[];
routes=[];
costs=minimumCost(A,B);
sortedCosts=quicksort(costs);
sortedCustomers=sortedCosts(2,:);
reverseCustomers=0;
needNewRoute=0;
while not(isempty(sortedCustomers))
[u,v]=size(route);
for j=1:v
routes(r,j) = route(j);
end
r=r+1;
[n,m]=size(sortedCustomers);
firstCustomer=0;
routeCapacity=capacity;
for i=1:m
j=sortedCustomers(i);
if(B(1,j+1)<A(j,5))&&(A(j,3)<routeCapacity);
firstCustomer=j;
sortedCustomers =
removeElement(sortedCustomers,i,1);
break
end
end
if (firstCustomer == 0)
fprintf ('Problema incompatible');
routes=0;
return
end
80
route = firstCustomer;
routeCapacity = routeCapacity - A(j,3);
[n,m]=size(sortedCustomers);
i=m;
reverseCustomers = fliplr(sortedCustomers);
if (isempty(reverseCustomers))
[u,v]=size(route);
for j=1:v
routes(r,j) = route(j);
end
end
while i>0
j=reverseCustomers(i);
if (A(j,3)<routeCapacity);
routeCapacity = routeCapacity - A(j,3);
costs = costToAdd(route, j, B);
costs = quicksort(costs);
routePosition = costs(2,1);
if (isTimeFactible(A, B, route,
routePosition+1, j))
route = addAt(route, j, routePosition);
reverseCustomers =
removeElement(reverseCustomers, i, 1);
end
i = i-1;
if (i==0)
needNewRoute=1;
end
sortedCustomers= fliplr(reverseCustomers);
else
[n,m]=size(route);
for o=1:m
routes(r,o) = route(o);
end
i=i-1;
sortedCustomers= fliplr(reverseCustomers);
end
81
end
if(isempty(sortedCustomers)),
[n,m]=size(route);
for o=1:m
routes(r,o) = route(o);
end
end
end
82
6.1.3. InicializarFeromona
function phero=phero_initialize(phero, best_feasible_cost,
m)
for i=1:m+1 for j=1:m+1 phero(i,j)=1/(m*best_feasible_cost); phero(j,i)=phero(i,j); end end
83
6.1.4. ConstrucciónSoluciones
function [current_route, phero]=colonia_hormigas(capacity,
nodos, A, B, phero, tauZero)
q=0.9;
[m,n]=size(A);
not_visited=nodos;
current_route=[];
current_time=0;
current_weight=0;
current_client=0;
beta=1;
column=0;
row=1;
ro=0.1;
while not(isempty(not_visited))
for k=1:m
start_time=max(current_time+B(current_client+1, k),
A(k, 4));
delta_time=start_time-current_time;
urgency=A(k, 5)-current_time;
distance=delta_time*urgency;
distance=max(1,distance);
distance_table(k)=1/distance;
end
j=0;
[lin_not_vis, col_not_vis]=size(not_visited);
rand_num=rand(1);
if rand_num<q
newTruck=1;
for i=1:col_not_vis
if current_time+B(current_client+1,
not_visited(i)+1) <= A(not_visited(i), 5)
if current_client ~= 0
if A(current_client,
3)+current_weight<capacity;
j=not_visited(i);
pos=i;
newTruck = 0;
break;
end
84
else
j=not_visited(i);
pos=i;
newTruck = 0;
break;
end
end
end
if (newTruck == 0)
% comprobación si hay otro en esa ventana
temporal con mismo
% valor heurístico
for i=1:col_not_vis
if (phero(not_visited(i)+1,
current_client+1)*(distance_table(i))^beta)<(phero(j+1,
current_client+1)*(distance_table(j))^beta)
if (current_time+B(current_client+1,
not_visited(i)) <= A(not_visited(i), 5))
if current_client ~= 0
if A(current_client,
3)+current_weight<capacity
j=not_visited(i);
pos=i;
end
else
j=not_visited(i);
pos=i;
end
end
end
end
if j~=0
column=column+1;
current_time=max(current_time+B(current_client+1, j), A(j,
4));
current_weight=current_weight+A(j, 3);
not_visited = removeElement(not_visited,
pos, 1);
85
%Agregado para eliminar el otro punto del
mismo cliente
not_visited=removeElement(not_visited,pos,1);
%FIN---------------------------------------
----------
phero(current_client+1, j+1) = (1-
ro)*phero(current_client+1, j+1)+ro*tauZero;
current_client=j;
end
else
phero(current_client+1, 1) = (1-
ro)*phero(current_client+1, 1)+ro*tauZero;
current_weight=0;
row=row+1;
column=0;
current_time=0;
current_client = 0;
end
else
prob_sum=0;
[lin_not_vis, col_not_vis]=size(not_visited);
for i=1:col_not_vis
probability=[];
if (current_time+B(current_client+1,
not_visited(i)+1) <= A(not_visited(i), 5))
probability(i)=(phero(current_client+1,
not_visited(i)+1)*(distance_table(not_visited(i)))^beta);
prob_sum=prob_sum+probability(i);
else
probability(not_visited(i))=0;
end
end
ele=roulette(probability);
if (ele==0)
j=0;
current_weight=0;
row=row+1;
column=0;
current_time=0;
current_client=j;
else
j=not_visited(ele);
if A(j, 3)+current_weight>capacity;
86
j=0;
current_weight=0;
row=row+1;
column=0;
current_time=0;
current_client=j;
else
column=column+1;
current_time=max(current_time+B(current_client+1, j), A(j,
4));
current_weight=current_weight+A(j, 3);
not_visited = removeElement(not_visited,
ele, 1);
%Agregado para eliminar el otro punto del
mismo cliente
not_visited=removeElement(not_visited,ele,1);
%FIN---------------------------------------
----------
phero(current_client+1, j+1) = (1-
ro)*phero(current_client+1, j+1)+ro*tauZero;
current_client=j;
end
end
end
if j~=0
current_route(row, column)=j;
end
end
87
6.1.5. ActualizaciónFeromona
function feromona=actualizar_feromona_global(feromona,
route, B, ro)
[m,n]=size(route);
for i=1:m
for j=1:n-1
if route(i,j+1)==0;
feromona(route(i,j)+1, 1)=(1-
ro)*feromona(route(i,j)+1, 1)+ro*(1/B(route(i,j)+1, 1));
break;
else
feromona(route(i,j)+1, route(i, j+1)+1)=(1-
ro)*feromona(route(i,j)+1, route(i,
j+1)+1)+ro*(1/B(route(i,j)+1, route(i, j+1)+1));
end
if j+1==n&&route(i,j+1)~=0
feromona(route(i, j+1)+1, 1)=(1-
ro)*feromona(route(i, j+1)+1, 1)+ro*(1/B(route(i, j+1)+1,
1));
end
end
feromona(1, route(i, 1)+1)=(1-ro)*feromona(1, route(i,
1)+1)+ro*(1/B(route(i,1)+1, 1));
end
88
6.1.6. Admisible
function best_route1=admisible(best_feasible, B);
[m,n]=size(best_feasible);
comp1=0;
metodo1=best_feasible;
option1=metodo1;
for i=1:m
for j=1:n
elto=metodo1(i,j);
if rem(elto,2)==0
buscar=elto-1;
else
buscar=elto+1;
end
ind=0;
while ind==0;
for t=1:n
for v=1:m
arg=metodo1(v,t);
if arg==buscar
list=metodo1(v,:);
newList=removeElement(list, t, 1);
metodo1(v,:)=[newList 0];
comp1=1;
ind=1;
end
end
end
ind=1;
end
end
end
if comp1==1
89
option1=metodo1;
end
metodo2=best_feasible;
comp2=0;
option2=metodo2;
for i=m:-1:1
for j=n:-1:1
elto=metodo2(i,j);
if rem(elto,2)==0
buscar=elto-1;
else
buscar=elto+1;
end
if elto==0
buscar=9999999;
end
ind=0;
while ind==0;
for t=n:-1:1
for v=m:-1:1
arg=metodo2(v,t);
if arg==buscar
list=metodo2(v,:);
newList=removeElement(list, t, 1);
metodo2(v,:)=[newList 0];
comp2=1;
ind=1;
end
end
end
ind=1;
end
end
end
90
if comp2==1
option2=metodo2;
end
option1_cost = totalCost(metodo1, B, 0);
option2_cost = totalCost(option2, B, 0);
if option1_cost<=option2_cost
best_route1=option1;
else
best_route1=option2;
end
end
91
7. Referencias
i J. Távora Montero. Modelo de rutas de vehículos aplicado al E-commerce, Trabajo Fin de Grado, Universidad de Sevilla, 2014. ii F. Glover. Future paths for integer programming and links to artificial intelligence. Computers and Operations Research, 13(5):533–549, 1986. iii I.H. Osman and G. Laporte. Metaheuristics: A bibliography. Annals of Operations Research, 63:513–628, 1996. iv T. Stützle and H. Hoos. MAX −MIN ant system. Future Generation Computer Systems, 16(8):889–914, 2000. v M. Dorigo and L. M. Gambardella. Ant Colony System: A cooperative learning approach to the traveling salesman problem. IEEE Transactions on Evolutionary Computation, 1(1):53–66, 1997. vi L.M. Gambardella, E. Taillard and G. Agazzi. MACS-VRPTW: a multiple ant colony system for vehicle routing problems with time windows. New Ideas in Optimization, D. Corne, M. Dorigo e F. Glover, McGraw-Hill, 1999. p. 63-76. vii X. Tan, X. Luo, W.N. Chen and J. Zhang. Ant Colony System for Optimizing Vehicle Routing Problem with Time Windows. 2005 International Conference on Computational Intelligence for Modelling, Control and Automation, p. 1-6, 2005. viii T. Zhen, Q. Zhang, W. Zhang and Z. Ma. Hybrid Ant Colony Algorithm for the Vehicle Routing with Time Windows. Proceedings of the 2008 ISECS International Colloquium on Computing, Communication, Control, and Management. P. 8-12, 2008. ix M. Solomon. Algorithms for the Vehicle Routing and Scheduling Problems with Time Window Constraints. Operations Research, Vol. 35, No. 2 (Mar. - Apr., 1987), pp. 254-265. x Sam R. Thangiah. Genetic Algorithms Handbook, Chapter 9: A Hybrid Genetic Algorithm, Simulated Annealing and Tabu Search Heuristic for Vehicle Routing Problems with Time Windows, CRC Press LLC, 1998