desarrollo y aplicación del algoritmo pso al problema...

Desarrollo y Aplicación del PSO al problema ATSP TFG

Desarrollo y aplicación del

algoritmo PSO al

problema del

ATSP

Trabajo fin de grado

Morán Bermúdez, Noemi

Grado en Ingeniería de Organización Industrial

Escuela de Ingenierías Industriales

Universidad de Valladolid

Julio de 2015

UNIVERSIDAD DE VALLADOLID

ESCUELA DE INGENIERIAS INDUSTRIALES

GRADO EN INGENIERÍA DE ORGANIZACIÓN INDUSTRIAL

Desarrollo y aplicación del algoritmo PSO al

problema del TSP

Autor:

Morán Bermúdez, Noemi

Tutor:

Pérez Vázquez, María Elena

Dpto. de Organización de Empresas

Valladolid, Julio de 2015.


RESUMEN

En la vida cotidiana nos enfrentamos a varios problemas. Uno de los más comunes

se da cuando debemos realizar varias actividades o ir a varios lugares y tenemos

que decidir el orden para realizarlo, de manera que nos suponga el menor coste

posible ya sea en tiempo, energía, distancia, dinero… Esta situación se puede

representar mediante el problema de Optimización del Agente Viajero (TSP).

En este documento se va a desarrollar e implementar al TSP (práctica y

teóricamente mediante la programación del Algoritmo) un método aproximado de

optimización, basado en el comportamiento de los enjambres de abejas en la

naturaleza, para buscar una buena solución al problema. Este método es conocido

como Optimización por Enjambre de Partículas (PSO).

Palabras clave: Optimización por Enjambre de Partículas, Problema del Agente

Viajero, Métodos Metaheurísticos, problemas NP-Duros, operador de permutación.

ABSTRACT

In our quotidian life we deal with problems. One of the most common arrives when

we must do several activities and go to several places, and we have to decide which

order is the best one, when it comes to use as less time, energy, distance, money,

etc., as possible. This situation could be represented by the Travelling Salesman

Optimization problem (TSP).

In this document I’ll develop and implement to TSP (as theoretically as practically

with the algorithm programming) an approximated optimization system, based in

the behavior of swarms of bees in the nature, to look for a good problem solution.

This system is known as Particle System Optimization (PSO).

Keywords: Particle Swarm Optimization, Traveling Salesman Problem, Metaheuristic

Methods, NP-Hard problems, swap operator.


ÍNDICE

INTRODUCCIÓN Y OJETIVOS ..................................................................................... 1

1. PROBLEMA DEL AGENTE VIAJERO ...................................................................... 3

1.1 Problemas de Decisión ........................................................................................................ 3

1.1.1 Clasificación de los Problemas de Decisión ................................................... 4

1.2 Problema del Agente Viajero ............................................................................................. 7

1.2.1 Definición formal del problema ......................................................................... 9

1.2.2 Complejidad computacional del TSP ..............................................................12

1.2.3 Aplicaciones del TSP .............................................................................................13

1.2.4 Versiones del TSP ..................................................................................................16

1.2.5 Problema de Agente Viajero Asimétrico, ATSP ..........................................17

2. MÉTODOS DE RESOLUCIÓN DE PROBLEMAS .................................................... 19

2.1 Algoritmos exactos ..............................................................................................................21

2.2 Algoritmos de aproximación o heurísticos ................................................................22

2.2.1 Calidad de un algoritmo heurístico .................................................................24

2.2.2 Clasificación de los métodos heurísticos o aproximados .......................25

2.2.3 Métodos constructivos.........................................................................................26

2.2.4 Métodos de búsqueda local ................................................................................29

2.2.5 Métodos Metaheurísticos ...................................................................................34

2.2.5.1 Características de los métodos Metaheurísticos ......................35

2.2.5.2 Clasificación de los métodos Metaheurísticos ..........................37

3. OPTIMIZACIÓN POR ENJAMBRE DE PARTÍCULAS ............................................. 45

3.1 Origen .......................................................................................................................................46

3.2 Evolución del PSO ................................................................................................................47

3.3 Analogía con la naturaleza ...............................................................................................51

3.4 Descripción del método .....................................................................................................53

3.4.1 Pasos del algoritmo ...............................................................................................54


3.5 Versiones del PSO ................................................................................................................57

3.5.1 Modelo Lbest ...........................................................................................................57

3.5.2 Modelo Binario Discreto, DPSO ........................................................................58

4. IMPLEMENTACIÓN Y EXPERIMENTACIÓN ........................................................ 63

4.1 Aplicación de la metaheurística PSO al problema TSP ..........................................63

4.1.1 Pasos del algoritmo ...............................................................................................64

4.1.1.1 Operación de cruce ..............................................................................68

4.1.1.2 Operación de inyección u operación inversa ............................69

4.1.1.3 Operación de adaptación al ruido ..................................................71

4.2 Algoritmo desarrollado .....................................................................................................73

4.3 Resultados experimentales ..............................................................................................79

4.3.1 Parámetros utilizados ..........................................................................................80

4.3.2 Resultados ................................................................................................................81

4.4 Estudio estadístico de resultados ..................................................................................87

4.4.1 Resultados ................................................................................................................89

5. CONCLUSIÓN E INVESTIGACIÓN DE LÍNEAS FUTURAS ...................................... 91

6. BIBLIOGRAFÍA ................................................................................................. 92


1

INTRODUCCIÓN Y OJETIVOS

El algoritmo de optimización por enjambre de partículas (PSO), desarrollado

originalmente por Kennedy y Eberhart, es un método aproximado de optimización,

de tipo metaheurístico basado en la población, que simula el comportamiento

natural de los enjambres de abejas a la hora de buscar el polen, cuya característica

principal es que poseen memoria y que el enjambre esta interrelacionado.

Las abejas vuelan en el espacio en busca de flores y se van comunicando unas con

otras para saber cuál de ellas ha encontrado mayor densidad floral y dónde.

Después, cada abeja sigue su búsqueda, modificando su vuelo en función del

mejor lugar encontrado por el enjambre y del mejor lugar encontrado por ella

misma. De este modo el enjambre cada vez encuentra lugares con mayor densidad

de flores.

En el PSO, cada partícula es una solución potencial al problema, y posee una

posición actual y una velocidad. La población se inicializa de manera aleatoria y

después, de forma iterativa va evolucionando a mejores soluciones del problema

mediante la actualización de la velocidad y la posición de cada partícula. En primer

lugar se actualiza la velocidad teniendo en cuenta la mejor posición global

encontrada por la población y la mejor posición encontrada hasta el momento por

la propia partícula, y posteriormente se actualiza la posición aplicándole la

velocidad hallada.

La solución del algoritmo será la mejor posición encontrada por el conjunto del

enjambre, que al tratarse de una metaheurística, aunque no se puede asegurar

que sea el resultado óptimo, sí que será próximo a él.

Este método según está descrito, sirve para buscar soluciones en espacios de

búsqueda continuos, sin embargo, el problema al que nosotros nos enfrentamos es

un problema discreto llamado Problema del Agente Viajero (TSP). Este problema es

del tipo NP-Hard y es uno de los que más interés suscita en la comunidad científica

debido a la simplicidad con la que se enuncia y a la dificultad que supone su

resolución.

El TSP se puede describir de la siguiente forma: Un viajero debe visitar n ciudades

pasando por todas ellas, sin repetir ninguna, y volviendo a la ciudad de origen, de

manera que se genera un ciclo Hamiltoniano. El objetivo del problema es encontrar

el ciclo óptimo que debe realizar el viajante, es decir, encontrar la trayectoria que

menor distancia total suponga de entre todas las posibles.


2

La dificultad de su resolución está en que los posibles ciclos que se pueden llevar a

cabo aumentan de forma exponencial con el tamaño del problema, por lo que

probar cada una de las soluciones posibles no es una opción.

Este trabajo surge de la necesidad de adaptar la metaheurística PSO a un espacio

discreto, para así poderla implementar al problema TSP, y obtener así una buena

solución.

Para lograr ese objetivo, este trabajo se estructura de la siguiente manera:

En el primer capítulo se explicará en detalle en qué consiste el TSP para saber con

exactitud las características del problema al que nos enfrentamos.

El segundo y tercer capítulo están enfocados al desarrollo del PSO; en el segundo

se introducirán los diferentes métodos de optimización de problemas, mientras que

el tercero está centrado en el método PSO que nos concierne en este trabajo.

El cuarto capítulo es la parte práctica del trabajo. Está compuesto por tres partes

diferenciadas: en la primera se explica cómo vamos a aplicar el PSO al TSP, es

decir, cómo vamos a adaptar el PSO obteniendo una versión discreta del mismo.

Una vez que sabemos cómo queremos realizar la implementación, se lleva a la

práctica mediante la creación de un algoritmo en lenguaje C++ que será explicado

paso a paso en el segundo apartado. Para finalizar el capítulo, el algoritmo será

aplicado a una serie de ejemplos para poder hacer el estudio experimental que

compruebe la fiabilidad del algoritmo.


3

1. PROBLEMA DEL AGENTE VIAJERO

Dado que lo que buscamos resolver en este documento es una de las versiones del

Problema del Agente Viajero (TSP), en concreto la variante asimétrica, también

conocida como ATSP, y éste pertenece a los problemas NP-Hard de optimización

combinatoria, en este capítulo comenzamos introduciendo las características de los

problemas de decisión y la clasificación de los mismos, para así describir en qué

consiste un problema NP-Completo (al que pertenece la versión de decisión del

TSP) y posteriormente la clase NP-Hard, para con ello poder contextualizar el TSP.

Finalmente describiremos el TSP y la versión asimétrica del mismo, que es el

problema que realmente nos concierne en este trabajo.

Antes de comenzar exponemos una breve definición del TSP para hacernos una

idea de lo que pretendemos resolver:

El Problema del Agente Viajero consiste en hallar el mejor ciclo Hamiltoniano (el de

mínima distancia) que podría realizar un viajante que tiene que ir a n ciudades,

sabiendo las distancias entre ellas. Para que el ciclo sea Hamiltoniano tiene que

cumplir que: debe partir de una ciudad concreta, recorrer todas las demás ciudades

sin repetir ninguna, y regresar a la de partida.

Lo que el ATSP añade al TSP original es que la distancia de la ciudad i a la j no tiene

por qué ser la misma que la distancia de la ciudad j a la i.

1.1 Problemas de Decisión

Descrito de la manera más simple posible, un problema en términos

computacionales es un agregado de frases finitas, que tiene asociado otro conjunto

finito de frases como respuesta.

Un problema de optimización combinatoria es tanto un problema de minimización

como uno de maximización que tiene asociadas un conjunto de instancias. El

término problema se aplica a la cuestión general que debe ser contestada

(habitualmente formado por varios parámetros y variables sin valores específicos),

mientras que la palabra instancia se refiere a un problema al que ya se le han

asignado valores específicos para todos los parámetros, por ejemplo, el problema

TSP es un problema general que busca un ciclo Hamiltoniano de coste mínimo,

mientras que una instancia del TSP es un problema específico en el que ya se sabe

el número de ciudades que posee, sus conexiones y los costes de ir de unas a

otras.


4

Además todo problema de optimización, que lo que hace es buscar la mejor

solución posible del problema (recorrido mínimo en el caso del TSP), tiene varias

versiones [1], como por ejemplo: la versión de evaluación, la de localización, la de

decisión…

El caso concreto de los problemas de decisión es aquel donde las únicas

respuestas posibles son “si” o “no”, por ello la versión de decisión de un problema

de optimización tiene el siguiente aspecto: ¿Existe una solución posible del

problema menor o mayor (según sea de minimización o maximización) que un

número dado?, y más concretamente para el TSP sería: ¿Dado un número k, existe

un circuito Hamiltoniano del problema de longitud menor o igual que k?

De la clasificación de los problemas de decisión, según la complejidad

computacional que implica su resolución, se encargan las Ciencias de la

Computación. Para ello se consideran todos los posibles algoritmos que pueden

resolver el problema y se estudia los recursos que requieren (el tiempo y la

memoria que supone el problema en su ejecución).

1.1.1 Clasificación de los Problemas de Decisión

Los problemas de decisión se pueden clasificar en base a dos criterios, ambos

estudiados por áreas de la Teoría de la computación:

- Según la Teoría de la computabilidad, que estudia los lenguajes y los

cataloga en función de si son resolubles con diferentes máquinas y modelos

de computación o no lo son, los problemas de decisión pueden ser

clasificados como [2]:

Decidibles, resolubles o computables: Siempre que el problema

tenga solución es capaz resolverlo, al menos, mediante un

procedimiento mecánico o algoritmo (entendiendo por algoritmo una

sucesión ordenada y finita de pasos relacionados mediante los

cuales resolvemos el problema). Además cuando se le presenta un

problema que no tiene solución, es capaz de reconocerlo.

Parcialmente decidible, reconocibles o semicomputables: Existe al

menos un algoritmo capaz de resolver el problema, siempre que éste

tenga solución. Pero no es capaz de distinguir cuándo no existe

solución, de modo que en ese caso iteraría de forma infinita.

No Decidible: No existe ningún algoritmo que resuelva el problema,

independientemente de que posean o no solución. Puesto que no se


5

resuelven, se puede decir que su complejidad es infinita, por lo que

como veremos a continuación, este tipo de problemas no son

estudiados por la Teoría de la Complejidad Computacional.

- El segundo criterio es el que da la Teoría de la Complejidad Computacional,

área que mediante herramientas y mecanismos describe y analiza la

complejidad de los algoritmos y problemas. Éste área sólo estudia los

problemas decidibles, considerando el tiempo que implican y la memoria

que ocupan, debido a que carece de sentido estudiar la complejidad de los

problemas no decidibles cuando ya sabemos que es infinita.

Podemos ver en la clasificación que aunque un problema sea computable,

puede que de forma práctica no sea posible resolverlo debido al exceso de

recursos que requiere. Los principales problemas según esta consideración

son [3]:

Clase P.

Se trata de algoritmos de complejidad polinómica (P). Se pueden

resolver en un tiempo polinómico con una máquina de Turing

determinista (dadas unas variables de entrada y el estado en que se

encuentra la computadora, si hay varias acciones posibles, la

máquina sólo puede realizar una de ellas, en la no determinista la

máquina se replica y continúa cada una por una rama distinta) y

secuencial (realiza cada acción después de que la anterior haya

finalizado).

El tiempo polinómico es el tiempo ideal, lo cual significa que el

tiempo de ejecución del algoritmo es menor que cierto valor

calculado (con una fórmula polinómica, que tiene en cuenta los datos

de entrada, por lo que el tiempo polinómico es proporcional a los

mismos), por ello un algoritmo eficiente es aquel cuya complejidad es

polinómica.

Clase NP.

Son problemas de decisión que se resuelven en un tiempo

polinómico (P) con una máquina de Turing no determinista (N).

Podemos decir que la clase P es un tipo dentro de la clase NP.

De este grupo forman parte muchos problemas de optimización y de

búsqueda cuyo objetivo es averiguar si existe una determinada

solución, o si existe una mejor que la conocida hasta el momento.

Clase NP-Completo.

Para que un problema sea NP-Completo se tienen que cumplir dos

características: que sea un NP (los completos son los problemas más

difíciles de la clase NP), y que todos los problemas NP se puedan


6

reducir (relacionar dos problemas, de forma que si el primero se

puede resolver con un algoritmo, se garantiza que hay un algoritmo

que resuelve el segundo) en cada uno de los problemas NP-

Completos, es decir, que todo problema NP mediante la

transformación polinómica puede convertirse en NP-Completo.

Todos los problemas que cumplen la condición de la transformación

polinómica, aunque no cumplan la pertenencia a NP, son problemas

NP-Hard.

Clase NP-Hard, NP-Complejo o NP-Duro [4].

La clase NP-Hard no es exclusiva de los problemas de decisión ya

que no tienen que cumplir la condición de ser NP, de hecho, todos los

NP-Completos pertenecen a los NP-Hard, pero no se cumple la

afirmación en sentido contrario.

Los NP-Hard son aquellos problemas que cumplen que todos los

problemas de NP se pueden transformar polinómicamente en NP-

Hard.

Hasta el momento no se ha encontrado ningún algoritmo eficiente

(acotado polinómicamente) que proporcione la solución óptima, ni

para este tipo de problemas, ni para los anteriores. Por ello, la forma

de actuar ante estos problemas es realizar una búsqueda exhaustiva

(enumeración de todas las posibles soluciones y elección de la mejor)

si las entradas son “pequeñas”, o en caso contrario, buscar una

solución cercana al óptimo construyendo soluciones mediante

algoritmos polinómicos de aproximación.

Se trata de problemas, como mínimo tan difíciles como los NP, ya

que si encontrásemos un algoritmo que resolviese en tiempo

polinómico uno de los problemas NP-Hard (se cree que no existe

ningún algoritmo polinómico que los resuelva, pero nunca ha sido

demostrado), se podría construir un algoritmo polinómico para

cualquier problema NP, mediante la reducción del problema NP en

NP-Hard y la posterior ejecución del algoritmo que resuelve el NP-

Hard. Si existiese ese algoritmo, significaría que P=NP y esto sería un

descubrimiento muy importante para la teoría de la computación,

tanto, como que hay un premio del Instituto Clay que otorga un

millón de dólares a quién logre dicha demostración.

Teniendo en cuenta las características de la clase NP-Hard, lo que sí

que podemos asegurar a día de hoy es que los NP-Completos son la

intersección de los NP con los NP-Hard.

En la figura 1 se muestra mediante el diagrama de Euler la relación que

existe entre los tipos de problemas anteriormente explicados. Debido a la

cantidad de incógnitas que existen sobre el tema a día de hoy, vemos las


7

dos versiones principales: a la izquierda el caso en el que no se ha

demostrado la existencia de un algoritmo polinómico que resuelva un

problema NP-Hard y a la derecha el caso contrario, por lo que P es igual que

NP y que NP Completo, siendo además todos ellos NP-Hard.

Figura 1. Problemas según la complejidad computacional. [5].

1.2 Problema del Agente Viajero

El Problema del Agente Viajante o Vendedor Viajero, también conocido como TSP

por sus siglas del inglés “Traveling Salesman Problem”, fue definido en del siglo XIX

por el irlandés W.R. Hamilton y el británico Thomas Kirkman, ambos matemáticos. Y

fue durante los años 1930s cuando matemáticos de Viena y Harvard estudiaron

por primera vez la forma general del TSP, siendo muy importante para su desarrollo

Karl Menger.

El origen del nombre que se otorga hoy en día a este problema es un poco

misterioso (Applegate et al., 2011), puesto que se han encontrado documentos en

los que los autores utilizan esa nomenclatura, pero en ninguno de ellos se dan

indicios de que el autor del documento sea el creador del nombre “Traveling

Salesman Problem”, sino que se da a entender que el nombre ya estaba

establecido.

El primer documento en que tenemos constancia del término data de 1949 y es un

artículo de Julia Robinson, pero según el contenido del artículo ella no parece ser la

persona que introdujo el nombre. Varios autores creen que el término fue creado

durante los años 30 o 40 en la universidad de Princeton.

Este problema fue poco a poco haciéndose más popular entre los científicos

europeos y americanos y su estudio fue evolucionando de modo que cada vez se

podían resolver problemas de mayor dimensión. En la tabla 1 se muestra a grandes

NP


8

rasgos ese progreso en el tiempo, indicando el año en que se resuelve el TSP de la

dimensión indicada en la columna “Número de ciudades” y los autores

responsables de dicho estudio.

Tabla 1. Evolución de la dimensión del TSP. [6].

El TSP se puede formular de la siguiente manera (Lin, 1965): Un viajante o

vendedor debe visitar todas y cada una de las n ciudades dadas una sola vez,

comenzando por una de ellas y volviendo a la misma ciudad de origen al finalizar el

recorrido, de manera que se genera un ciclo. Dado que hay que hay que cumplir

que se va a cada ciudad exactamente una vez, el ciclo resultante es un ciclo

Hamiltoniano.

Lo que se busca en el TSP es elegir la ruta o tour (orden en que las ciudades son

visitadas) que optimiza el resultado, es decir, la que implique menos coste

(utilizamos coste de forma general y puede estar referido a la distancia, el tiempo,

el coste de traslado… eso depende del objetivo del problema. El más común en

este tipo de problemas es la distancia recorrida) de entre todas las posibles.

Una solución para una instancia del TSP puede ser representada como una

permutación de los índices de las ciudades (una ordenación de las ciudades). Dicha

permutación es cíclica por lo que la posición absoluta de una ciudad dentro del tour

no es relevante, lo que verdaderamente importa es la secuencia, es decir, el orden

relativo entre unas ciudades y otras. Lo que esto significa es que no es importante

que una ciudad se visite en primer o en segundo lugar, lo que afecta es qué

ciudades se han visitado antes y después de ella, dicho con otras palabras, la

ciudad de partida no afecta al resultado del problema.

Al tratarse de un problema tan sencillo de entender, a priori se suele pensar que la

complejidad de su resolución también lo es, pero cuando se indaga en la cantidad

de estudios que se han realizado durante toda la historia del problema y el hecho

Año Autores Número de ciudades

1954 Dantzig, Fulkerson, and Johnson 49

1971 Held and Karp 64

1975 Camerini, Fratta, and Maffioli 67

1977 Grötschel 120

1980 Crowder and Padberg 318

1987 Padberg and Rinaldi 532

1987 Grötschel and Holland 666

1987 Padberg and Rinaldi 2.392

1994 Applegate, Bixby, Chvátal, and Cook 7.397



2004 Applegate, Bixby, Chvátal, Cook, and Helsgaun 24.9782005 Cook, Espinoza and Goycoolea 33.810


9

de que hasta el momento nadie ha conseguido encontrar un método efectivo para

su resolución, aun siendo uno de los problemas de optimización combinatoria más

estudiados, se cae en la cuenta de la complejidad computacional que envuelve al

problema.

Es tal su complejidad que el TSP forma parte de los problemas NP-Hard (fue

Richard M. Karp quien en 1972 demostró que el Ciclo de Hamilton era NP-

Completo, lo que implica que el TSP es NP-Hard, esto será demostrado más

adelante), por lo que posee las características explicadas en el apartado anterior

para esa clase.

Además se trata de un problema de optimización (lo que implica buscar valores

para variables discretas de modo que se encuentre la solución óptima respecto a

una función objetivo dada) y sufre el fenómeno de la explosión combinatoria, que

quiere decir que cuando el número de variables del problema aumenta, el número

de combinaciones posibles y los esfuerzos computacionales también, y lo hacen de

forma exponencial, por ello se dice que el TSP es un problema de optimización

combinatoria.

De manera teórica el algoritmo de “fuerza bruta”, que consiste en probar todas las

posibles rutas del problema, es óptimo y fácil de plantear, el problema llega al

impleméntalo de forma práctica debido al tiempo que supone. Las posibles rutas

que se pueden tomar, dadas n ciudades y pasando exactamente una vez por cada

una de ellas, son n!, pero puesto que el problema especifica el punto de partida

(aunque no lo especificase, al tratarse de un ciclo Hamiltoniano, el resultado del

problema es independiente del punto de partida), las posibles rutas de un TSP son

(n-1)!, por lo que queda demostrado que el problema aumenta de forma

exponencial (más bien factorial). Para un problema de 24 ciudades nos

encontramos ente la friolera de veinticinco mil trillones de posibilidades, y si el

problema contase con unos pocos cientos de ciudades sería inabordable en la

práctica porque no hay un ordenador tan potente como para poder resolverlo.

Esto provoca que sea inviable resolver el problema mediante un algoritmo que

pruebe todas las posibilidades, por lo que en el siguiente capítulo veremos

algoritmos que aunque no obtienen el óptimo del problema nos proporcionan una

solución mucho más eficiente.

1.2.1 Definición formal del problema

Para la descripción formal del TSP vamos a introducir primero la nomenclatura que

utilizamos para el problema y algunas nociones sobre la teoría de grafos (Martí,

2003), para finalmente exponer la formulación del problema:


10

- G es el grafo del problema y está formado por V, A y C, por lo que se

representación es la siguiente: G = (V, A, C).

- V es el conjunto de vértices, también llamados nodos, que en nuestro caso

son las ciudades que forman el problema V = {1, 2, …, n}.

Al tamaño de V lo denominamos dimensión (n), que es equivalente al

número de ciudades que forma el problema.

- A es el conjunto de aristas o arcos del problema, es decir, el camino o unión

que hay para ir de un vértice a otro.

Hablamos de un grafo completo si para cada par de vértices existe una

arista que los une.

- C es la matriz de costes, donde 𝑐𝑖𝑗 es el coste que supone (generalmente

en términos de distancia) ir de la ciudad i a la ciudad j, es decir, el coste

asociado a la arista (i,j).

Habitualmente C es de tamaño nxn, poniendo en las filas las ciudades de

origen y en las columnas las de destino. Como en cada fila se pone la

distancia de la ciudad de esa fila a todas las demás, y son n ciudades en

total, hay n columnas y como cualquier ciudad puede ser tomada como

origen también hay n filas.

Cuando nos enfrentamos a un problema del tipo TSP, los únicos datos de los que

partimos para su resolución son los que forman el grafo del problema, es decir, los

vértices, aristas y costes. En este documento asumimos que el grafo que se nos

proporciona es el grafo completo, ya que al ser el caso más general el

planteamiento que hagamos nos servirá para cualquier caso particular.

Que el grafo sea completo significa que para cada par de ciudades existe un

camino de unión entre ellas. Si nos encontramos ante un problema que no une

directamente dos vértices, creamos una arista ficticia de unión cuyo coste será

equivalente al coste del camino más corto que une a ambas ciudades. Por ejemplo

en la figura 2 podríamos añadir una arista ficticia (1-7) de coste 9 equivalente al

camino (1-3-7).

Una sucesión de aristas (𝑎1, 𝑎2,…, 𝑎𝑘) donde el vértice final de una arista es el

mismo que el inicial de la arista sucesiva, es un camino. Además lo denominamos

camino simple si cumple la condición de que no pasa por el mismo vértice más de

una vez.

Un ciclo es un camino cuyo vértice final de 𝑎𝑘 coincide con el vértice inicial de 𝑎1 y

se trata de un ciclo simple si el camino que lo compone también lo es.


11

Cuando hablamos de un ciclo simple que no utiliza todos los vértices del grafo del

problema estamos hablando de un subtour. En el caso opuesto, cuando un ciclo es

simple y pasa por todos y cada uno de los vértices que componen el grafo del

problema nos encontramos ante un tour o ciclo Hamiltoniano por lo que se puede

denotar como (𝑎1, 𝑎2,…, 𝑎𝑛). Es éste último tipo el que se requiere construir en el

TSP, incluyendo además la condición de que sea de coste mínimo.

En la figura 2 vemos un grafo de un problema, donde hay 8 vértices representados

con círculos amarillos numerados, varias aristas que se reconocen porque son

rectas de unión entre dos vértices y el coste de cada arista que está representado

con un número al lado de su arista respectiva. El camino marcado en negrita es

uno de los posibles ciclos Hamiltonianos del grafo.

Figura 2. Ciclo Hamiltoniano. Martí, 2003.

Uno de los modos de formular el TSP es el que utilizamos a continuación [7], que

utiliza variables binarias en un modelo programación lineal entera. La función

objetivo del TSP consiste en minimizar el coste del recorrido que realiza el viajante,

y, según dicho modelo, tiene el siguiente aspecto:

Min ∑ ∑ (𝑐𝑖𝑗𝑥𝑖𝑗)𝑛𝑗=1𝑗≠𝑖

𝑛𝑖=1

Donde n es el número de ciudades del problema, 𝑐𝑖𝑗 es el coste de ir de la ciudad i

a la j y 𝑥𝑖𝑗 es la variable binaria {0,1} del problema, que toma el valor de uno en

caso de que el ciclo Hamiltoniano posea esa arista (i,j) y el valor cero en caso

contrario (por lo que, como es lógico, si no se va por el camino que une la ciudad i

con la j, su coste no se suma).

Además el problema debe cumplir las siguientes restricciones:

∑ (𝑥𝑖𝑗)𝑛𝑖=1𝑖≠𝑗

= 1 para j = 1, 2, …, n


12

∑ (𝑥𝑖𝑗)𝑛𝑗=1𝑗≠𝑖

=1 para i = 1, 2, …, n

𝑢𝑖 - 𝑢𝑗 + n𝑥𝑖𝑗 ≤ n – 1 para 1 ≤ i ≠ j ≤ n

La primera restricción asegura que no se pueda llegar a una misma ciudad desde

varias y que sí que se llegue a ella, es decir que la ciudad de llegada tenga uno y

sólo un origen.

La segunda restricción asegura que no se pueda salir desde una misma ciudad a

varias y que además todas las ciudades tengan una salida, formando así parte del

recorrido, lo que significa que cada ciudad tenga uno y sólo un destino.

La tercera restricción obliga a que sea sólo un camino el que cubra todas las

ciudades, es decir, evita que dos o más caminos disjuntos se complementen

cubriendo en conjunto las n ciudades. Para ello se asegura que todo camino tiene

que pasar por la ciudad 1. La variable 𝑢𝑖 es una variable de libre elección que

indica el orden en que se realiza el camino, es decir, si 𝑢𝑖 = t quiere decir que la

ciudad i es visitada en el paso t, siendo el orden t = 1, 2, …, n. Definimos el

recorrido con origen y final en la ciudad 1 (lo cual no implica pérdida de generalidad

puesto que se trata de un ciclo Hamiltoniano, por lo que el punto de partida no

afecta a la solución). Se cumple que 𝑢𝑖 - 𝑢𝑗 ≤ n – 1 ya que 𝑢𝑖 no puede ser mayor

que n (𝑢𝑖 = n es la última ciudad visitada) y 𝑢𝑗 no puede ser menor que 1 (como

muy pronto se visita la primera), además para el caso en que la variable 𝑥𝑖𝑗 = 1

tenemos que 𝑢𝑖 - 𝑢𝑗 + n𝑥𝑖𝑗 = (t) – (t + 1) + n = n – 1.

El cumplimiento de las tres restricciones obliga a que el camino creado sea un ciclo

y que además sea Hamiltoniano.

1.2.2 Complejidad computacional del TSP

Como hemos dicho en el apartado de clasificación de los problemas de decisión, el

problema del agente viajero pertenece a la clase NP-Completo (por tanto también

es NP-hard). Para demostrarlo trataremos a continuación las dos condiciones que

debe cumplir todo problema para pertenecer a dicha clase [8]:

- El TSP es un problema NP.

Para comprobar que un tour del problema es válido, lo primero que hay que

hacer es comprobar que posee todos los vértices del problema,

posteriormente sumar los costes de todas las aristas y comprobar que el

coste total de la trayectoria es mínimo.


13

Todo este proceso se puede realizar en tiempo polinómico por lo que queda

demostrado que el TSP pertenece a la clase de problemas NP.

- Todos los problemas NP se pueden trasformar en NP-Completo mediante

transformación polinómica, es decir, el problema tiene que ser NP-hard.

Para realizar la comprobación tomamos como referencia los ciclos

Hamiltonianos, puesto que se sabe que son problemas NP-Completos (lo

demostró en 1972 Richard M. Karp).

Partimos de G = (V, A), siendo éste un ejemplo de ciclo Hamiltoniano. A partir

de ahí creamos el grafo completo G’ = (V, A’), donde A’ son las aristas (i,j)

para todo i, j pertenecientes a V (excepto i=j). Los costes de dichas aristas

son 0 en caso de que la arista pertenezca a A (ciclo Hamiltoniano) y 1 en

caso de que no pertenezca a A.

Una vez creado el grafo completo suponemos que h es un ciclo

Hamiltoniano que existe en G, por tanto el coste de cada arista de h en G’ es

0, lo que hace que el coste total del recorrido h en G’ sea 0. Esto significa

que si el grafo G posee un ciclo Hamiltoniano, entonces G’ tendrá un ciclo de

coste 0.

Inversamente suponemos que G’ posee un ciclo h’ de coste 0. Esto solo

puede ocurrir en el caso de que todas las aristas de h’ sean de coste 0 y

para que puedan ser de coste 0 tienen que pertenecer a A.

Ambos supuestos implican que G posee un ciclo Hamiltoniano, si y sólo si, G’

posee un ciclo de coste 0, por lo que queda demostrado que el TSP es un

problema NP-Completo.

1.2.3 Aplicaciones del TSP

El TSP tiene una amplia aplicación, sobre todo en los campos del transporte y la

logística, tanto para optimizar rutas en sí mismas, como para servir de herramienta

(subproblema) a problemas de optimización combinatoria mayores.

Pero lo cierto es que se puede emplear en cualquier situación que requiera

seleccionar nodos en un orden determinado que permita minimizar el coste, por lo

que podemos decir que el TSP va mucho más allá de los problemas de planificación

de rutas, utilizándose también para otras aplicaciones como pueden ser:

minimización de los desplazamientos en fabricación, recogida robotizada de

material en almacenes, programación de una máquina de taladrado, impresión de

circuitos electrónicos, organización de estaciones de trabajo…

A continuación explicaremos brevemente algunas de las aplicaciones del problema

en cuestión (Gutin y Punnen, 2007):


14

- Problemas de programación de máquinas.

Uno de los problemas más estudiados es el de organización y secuenciación

de máquinas, donde los vértices son las n tareas que deben ser procesadas

de forma secuencial en una máquina y la matriz de costes es el conjunto de

𝑐𝑖𝑗 siendo éste el coste de puesta en marcha (configuración, cambios de

herramienta…) que supone cambiar de la tarea i a la j.

Cuando todas las tareas son procesadas la maquina se resetea, volviendo a

su estado inicial, lo cual supondrá el coste 𝑐𝑛1.

Lo que se busca en esta aplicación es encontrar la secuencia de tareas que

minimiza los costes totales de puesta en marcha de la máquina.

- Fabricación celular.

Cuando se poseen familias piezas que requieren procesamientos similares,

éstas se agrupan y se procesan juntas en una célula especializada para

mejorar la eficiencia y reducir los costes. En la mayor parte de los casos en

las células se utilizan robots para manejar el material y así reducir el tiempo

de procesado. La secuenciación de las actividades a desarrollar por el robot

puede ser considerada TSP.

Un ejemplo de este problema es el siguiente:

Secuenciar las actividades del robot en una célula robótica de dos máquinas

(M1 y M2), existiendo n tipos de piezas y teniendo que ser todas ellas

procesadas por la M1 y posteriormente por la M2. El proceso de una pieza

es: el robot coge la pieza del stock inicial, la lleva a la M1, la procesa la M1,

el robot la coge de la M1 y la lleva a la M2, la procesa la M2 y finalmente el

robot la coge de la M2 y la lleva al stock final.

Para este problema se consideran 2 ciclos de movimientos robóticos

posibles, en el primero el robot coge una pieza de M1, la lleva a M2, espera

a que se procese, la recoge y la deja en el stock final, luego va al inicial,

coge otra pieza, la lleva a M1, espera a que se procese, la lleva a M2 y así

sucesivamente, mientras que en el segundo ciclo considerado el robot coge

una pieza de M1, la lleva a M2 y en lugar de esperar a que se procese, se va

a por otra pieza al stock inicial y la lleva a la M1, vuelve a la M2 (espera si

no ha acabado), coge la pieza y la lleva al stock final, va a la M1 (espera si

es necesario), coge la pieza y la lleva a la M2 y así sucesivamente.

Lo que se debe hacer es seleccionar en cada etapa (para este ejemplo,

cuando se acaba de procesar la pieza en M1) qué ciclo robótico se elige

para minimizar el coste.

La elección del ciclo que más conviene para una etapa dada depende del

tiempo que tarda el robot en trasladarse entre máquinas y stocks y del

tiempo necesario para que las máquinas 1 y 2 realicen el proceso de la

pieza.


15

- Problemas de asignación de frecuencia:

Este problema puede ser por ejemplo, el de asignar una frecuencia a cada

transmisor de una red de comunicaciones, de entre un conjunto dado de

frecuencias posibles que satisfacen unas restricciones de interferencias.

Las restricciones se pueden representar en el grafo G = (V, A), donde V son

los n transmisores y el coste equivale a la tolerancia necesaria, por lo que se

debe elegir una frecuencia (entre las posibles), tal que la frecuencia del

transmisor i menos la frecuencia del transmisor j (en valor absoluto), tiene

que ser mayor que la tolerancia 𝑐𝑖𝑗.

Lo que se busca es minimizar el rango de frecuencias utilizadas entre las

posibles, cumpliendo siempre la restricción de la tolerancia.

- Estructuración de matrices:

Partimos de una matriz X = (𝑥𝑖𝑗)𝑚𝑥𝑛 y asumimos que f es una función de

coste específica para cada problema.

Para cada fila i de la matriz tenemos 𝐿𝑖 (𝑋) = ∑ 𝑓(𝑥𝑖𝑗, 𝑥𝑖(𝑗+1))𝑛𝑗=1

teniendo en cuenta que 𝑥𝑖(𝑛+1) = 𝑥𝑖1. Por tanto 𝐿 (𝑋) = ∑ 𝐿𝑖 (𝑋)𝑚𝑖=1 .

Del mismo modo para cada columna j, 𝐶𝑗 (𝑋) = ∑ 𝑓(𝑥𝑖𝑗, 𝑥(𝑖+1)𝑗)𝑚𝑖=1 ,

donde 𝑥(𝑚+1)𝑗 = 𝑥1𝑗. El sumatorio de 𝐶𝑗 (𝑋) para todas las columnas

es 𝐶 (𝑋) = ∑ 𝐶𝑗 (𝑋)𝑛𝑗=1 .

Supongamos que queremos resolver un problema de estructuración de filas.

A partir de la matriz X obtenemos S (X), que es la familia de matrices

obtenida de realizar permutaciones en las filas de X (o al realizar

permutaciones en las columnas en caso de que el problema a tratar sea de

estructuración de columnas).

Lo que se pretende en este problema es buscar la matriz Y perteneciente a

S (X), de modo que C (Y) sea al mínimo C de todas las matrices que forman

el conjunto S (X).

Este problema se puede resolver mediante el TSP de grafo completo donde

los vértices son las m filas V = {1,2,…,m} y el coste de las aristas es 𝑐𝑖𝑘 =

∑ 𝑓(𝑥𝑖𝑗, 𝑥𝑘𝑗)𝑛𝑗=1 , para todo i, k pertenecientes a V.

Si se tratase de un problema de estructuración de columnas de la matriz

también se podría resolver como un TSP del mismo modo que la

estructuración de filas pero sustituyendo C por L y construyendo el conjunto

S (X) mediante permutaciones de columnas de X.


16

1.2.4 Versiones del TSP

Existen muchas versiones diferentes de este problema, que difieren en ciertas

restricciones que añaden al problema original. Algunas de las más estudiadas son

las que exponemos a continuación (Larré, 2012):

- TSP Métrico o delta-TSP.

Este tipo es aquel en el que los costes (o distancias) del problema cumplen

la desigualdad triangular, es decir que el coste de ir de una ciudad a otra

pasando por una intermedia, no puede ser menor que el coste de ir

directamente (𝑐𝑢𝑣 + 𝑐𝑣𝑤 ≥ 𝑐𝑢𝑤 para todo vértice u, v y w pertenecientes al

conjunto de vértices del problema V).

Cuando las ciudades del problema están en un plano hay varios modos de

calcular la distancia [7], dos de ellas son las que generan estos casos

particulares del TSP Métrico:

TSP Euclidiano o TSP Planal: la distancia entre dos ciudades es la

distancia euclidiana entre los puntos en el plano de dichas ciudades.

TSP Rectilíneo: Para calcular la distancia entre dos ciudades se halla

la distancia de Manhattan, es decir, la suma de las diferencias entre

las coordenadas “x” e “y” de las ciudades en el plano.

Este es el caso, por ejemplo, del traslado de un robot de un punto a

otro, cuyo modo de movimiento es realizar primero el desplazamiento

en una coordenada, y luego en la otra.

- TSP Simétrico (STSP).

Este es el caso en el que los costos o distancias del problema son

simétricos, es decir, que el coste de ir de una ciudad a otra es igual en

ambos sentidos: 𝑐𝑣𝑤= 𝑐𝑤𝑣 para todo vértice v, w pertenecientes a V.

Esta característica hace que se trate de un grafo no dirigido, por lo que para

esta versión del problema, es indiferente si el ciclo se recorre en un sentido

o en el contrario, y por ello las rutas factibles para el problema se reducen a

la mitad, quedando ((n-1)!)/2 ciclos posibles.

- TSP Asimétrico (ATSP).

Es la versión contraria al STSP, es decir, dadas dos ciudades v y w, el coste

de ir de v a w no tiene por qué ser el mismo que el que supone ir de w a v.

Este problema es el que resolvemos en este documento por lo que lo

detallaremos en el siguiente apartado.


17

1.2.5 Problema de Agente Viajero Asimétrico, ATSP

Para el Problema del Agente Viajero Asimétrico se puede dar el caso de que dadas

dos ciudades, no existen caminos en ambas direcciones que las una directamente

o incluso que la distancia o coste que hay de una ciudad a otra no sea la misma en

un sentido que en el otro, (aunque también puede ser la misma). Con que esa

desigualdad se de en un solo par de vértices ya se trata de un grafo dirigido, y por

tanto el problema ya es asimétrico.

El ATSP es más genérico que el caso simétrico, de hecho, un método capaz de

resolver el ATSP también puede resolver la versión simétrica ya que ésta es un caso

concreto del asimétrico donde las posibles soluciones se reducen a la mitad. Para

un problema ATSP de n ciudades, la cantidad de ciclos posibles es de (n-1)!.

Ante este tipo de problemas nos encontramos diariamente, cuando vamos a

realizar un recorrido y nos topamos con un accidente de tráfico, calles transitables

en un solo sentido, diferentes precios en los billetes de avión en función de si se

entra en un país o se sale…

El ATSP puede ser resuelto mediante la conversión del mismo a un problema TSP

simétrico, que resulta más fácil de manejar. Para ello una de las opciones es

duplicar el tamaño de la matriz de modo que, teniendo una matriz de costes de

tamaño n en el problema asimétrico, la convertimos en una matriz de costes

simétrica de tamaño 2n como vemos en la figura 3.

Figura 3. Conversión del ATSP al caso simétrico. [7].

El procedimiento para la conversión es duplicar cada ciudad del problema creando

así un segundo nodo ficticio. A Los nodos duplicados se le asignan pesos muy bajos

(usamos-∞, pero también puede ser cero, a no ser que exista alguna arista del


18

grafo original que valga 0, en cuyo caso tendría que ser un valor menor para

permitir un salto libre entre un nodo y su ficticio) para que permita hallar rutas muy

baratas que enlazan el nodo ficticio con el real.

En la actualidad existen muchos softwares libres que permiten resolver el TSP, pero

en este proyecto no vamos a utilizar ninguno de ellos, sino que vamos a crear un

programa propio, utilizando uno de los métodos de resolución de problemas de

optimización, para encontrar una buena solución al ATSP.

El método que utilizaremos para crear nuestro programa junto con otros algoritmos

adecuados para la resolución de problemas de optimización combinatoria serán

explicaremos en el siguiente capítulo.


19

2. MÉTODOS DE RESOLUCIÓN DE PROBLEMAS

En primer lugar vamos a introducir los métodos principales utilizados para la

resolución de un problema de optimización combinatoria, como es el caso de los

NP-hard, y por tanto del Problema del Agente Viajero Asimétrico (ATSP), éstos son:

- Algoritmos exactos.

- Algoritmos de aproximación o métodos heurísticos.

- Métodos híper heurísticos.

El tercero de los tipos, denominado “híper heurísticos”, se utiliza en algunas

situaciones en las que un problema concreto no tiene una buena resolución ni

mediante algoritmos exactos, ni con la heurística, pero sí se puede descomponer

en varios casos especiales o “sub-problemas” para los cuales son posibles

heurísticas mejores o incluso algoritmos exactos, es decir, lo que hace la Híper

Heurística es crear nuevos algoritmos mediante la combinación de heurísticos ya

conocidos, compensando las debilidades de unos con otros (Ross, 2005).

A continuación se explicara brevemente cada uno de los dos primeros tipos, para

posteriormente enfocarnos en los algoritmos de aproximación, más concretamente

en la metaheurística, de la cual forma parte el método que nos proporcionará la

solución adecuada al ATSP en este artículo, el algoritmo de Optimización por

Enjambre de Partículas (PSO). Finalmente se describirá en que consiste esa

metaheurística que nos concierne, el PSO.

En la figura 4 que se muestra a continuación, se expone el esquema con la

clasificación de los métodos de resolución que consideramos más importantes,

desde el punto de vista de nuestro estudio, para resolver los problemas de

optimización, marcando además a qué categorías corresponde el PSO.


20

Figura 4. Métodos de resolución de problemas de optimización. Elaboración propia.

Algoritmos exactos

Algoritmos de

aproximación o

heurísticos

Algoritmos híper

heurísticos

MÉTODOS DE RESOLUCIÓN DE PROBLEMAS DE OPTIMIZACIÓN

Heurística

tradicional

Métodos de

descomposición

Métodos

inductivos

Métodos de

reducción

Métodos

constructivos

Métodos de

búsqueda local

Metaheurística

Basados en

trayectoria

SA, Recocido

simulado

ILS, Búsqueda

local iterada

VNS, Vecindario

variable

GRASP TS, Búsqueda

tabú

Basados en

poblaciones

EA, Algoritmos

evolutivos

PSO, Enjambre

de partículas

ACO, Colonia de

Hormigas

EDA, Estimación

de distribución

SS, Búsqueda

dispersa


21

2.1 Algoritmos exactos

El algoritmo exacto se caracteriza por encontrar la solución óptima al problema

propuesto. El hecho de que siempre proporcione como solución el óptimo global es

una ventaja, mientras que el tiempo de ejecución de estos algoritmos es su

principal desventaja ya que crece de forma exponencial con el tamaño del

problema.

El tiempo invertido para resolver un problema NP-hard de optimización

combinatoria mediante un método exacto, si es que existe el método, en la mayoría

de los casos suele ser tan grande que resulta inaplicable. De hecho, este tipo de

algoritmos es incluso inviable para un problema de 20 ciudades.

En este documento describiremos de forma muy breve este tipo de algoritmos

puesto que la mayoría de los problemas ingenieriles no se pueden resolver

mediante métodos exactos, y hay que recurrir a los aproximados que explicaremos

más adelante.

Algunos de los algoritmos exactos más importantes se describen a continuación

(Hoffman, 2000):

- Técnicas enumerativas.

La solución más directa es intentar todas las posibles combinaciones del

problema y hallar la función objetivo para cada una de las permutaciones,

eligiendo la que logra el mejor resultado (menor o mayor valor de la función

objetivo, dependiendo de si es un problema de minimización (caso del ATSP)

o de maximización).

El problema de esta solución, es que el tiempo de ejecución es de orden (n!),

siendo n el número de ciudades que habría que visitar, por lo que implica

mucho tiempo. Hay veces que se puede reducir, en cierta medida, el tiempo

computacional eliminando posibilidades debido a la dominación, que es en

lo que se basa el algoritmo de ramificación y poda o ramificación y acotación

(Guerequeta y Vallecillo, 1998). Este algoritmo consiste en realizar una

enumeración parcial del espacio de soluciones posibles, mediante la

generación de un árbol de expansión. El árbol se organiza de modo que

cada nodo de nivel k representa una parte de la solución, formado por k

etapas ya realizadas, y sus hijos son las prolongaciones posibles al añadir

una nueva etapa. El proceso de poda consiste en calcular una cota (función)

para cada posible prolongación y si dicha cota es peor que la de la mejor

solución hallada hasta ahora, no se explora más esa rama (la poda entera).

El método se realiza en 3 etapas: Selección del nodo entre el conjunto de

los nodos vivos (aquellos que no han sido ya podados), Ramificación

(construcción de los posibles hijos del nodo seleccionado) y Poda.


22

El algoritmo finaliza cuando se agota el conjunto de nodos vivos, lo cual

garantiza que el que queda es el mejor del problema, puesto que todos los

que han sido podados tenían una cota que la de éste.

- Enfoques de relajación y descomposición.

Otra de las técnicas de acotación muy conocidas (con mucho éxito hasta

que apareció la de acotación y poda) es la relajación Lagrangiana donde se

busca eliminar las restricciones malas, poniéndolas en la función objetivo

como penalización (al ponerlas como penalización también se evita

infringirlas para obtener un mejor resultado. El peso de ellas depende del

multiplicador Lagrangiano que se le aplique). Moviendo esas restricciones a

la función objetivo, el sub-problema resultante es más fácil de resolver. Es

necesario resolver iterativamente el sub-problema hasta encontrar los

valores óptimos para los multiplicadores.

- Planos de corte basados en combinaciones poliédricas.

Se basa en la aplicación de la teoría poliédrica para resolver problemas

numéricos. Teniendo en cuenta el teorema de Weyl, si podemos enumerar el

conjunto de desigualdades lineares que definen la convexificación de los

puntos posibles y los rayos extremos del problema, podremos resolver el

problema de programación entera mediante programación linear.

Podemos decir que los métodos exactos son muy eficaces ya que logran la solución

óptima, pero no son eficientes debido al excesivo tiempo que necesitan para ello.

Es la segunda razón, la que provoca que los problemas de optimización

combinatoria sean, en su inmensa mayoría, resueltos mediante algoritmos de

aproximación.

2.2 Algoritmos de aproximación o heurísticos

El problema ATSP que tratamos, pertenece a la categoría NP-hard de optimización

combinatoria (tienen como objetivo encontrar el máximo o mínimo de la función

objetivo del problema de entre un conjunto de soluciones finito, teniendo en cuenta

que sus variables de decisión son discretas). Los problemas NP-hard son

considerados “difíciles de resolver” y en términos algorítmicos podemos decir que

eso significa que no se puede garantizar encontrar el óptimo global (mejor solución

de entre todas las posibles) para un tiempo de ejecución razonable, por ello los

métodos exactos no son eficientes para este tipo de problemas, lo cual da paso a

los algoritmos de aproximación.

Los algoritmos de aproximación o heurísticos (proveniente de la palabra griega

“heuriskein” que significa encontrar o descubrir) son utilizados en problemas donde


23

la rapidez de la ejecución es tan importante como la calidad de la solución

obtenida, puesto que encuentran un equilibrio razonable, dando una buena

solución (aunque no sea necesariamente la óptima) en un tiempo de cómputo

moderado. Según Díaz y otros (1996) una buena definición de algoritmo heurístico

es la siguiente (Martí, 2003):

Un método heurístico es un procedimiento para resolver un problema de

optimización bien definido mediante una aproximación intuitiva, en la que la

estructura del problema se utiliza de forma inteligente para obtener una

buena solución.

En los últimos años ha habido un gran desarrollo de los métodos heurísticos

enfocados a resolver problemas de optimización, habiéndose publicado muchos

artículos relacionados con la materia en revistas especializadas como por ejemplo

la “Journal of Heuristics” e “INFORMS Journal on Computing”, además de la

publicación de un importante número de libros.

Hay varias razones para utilizar los procedimientos heurísticos:

- Hay algunos problemas para los cuales no se conoce ningún método exacto

que pueda resolverlos.

- En algunos casos en los que sí existe el método exacto, su coste

computacional es tan grande que lo hace inviable.

- La flexibilidad de los métodos aproximados es mucho mayor que la de los

exactos dejando, por ejemplo, agregar condiciones de modelización

complicada.

- El método aproximado suele ser parte de un procedimiento global que

garantiza el óptimo del problema. Hay dos opciones:

El método aproximado proporciona una buena solución inicial de

partida.

El método aproximado es un paso intermedio del procedimiento

global, utilizándolo por ejemplo para seleccionar variables en el

método Simplex.

Los algoritmos heurísticos dependen del problema concreto para el que se diseñan,

cosa que no ocurre por ejemplo con el algoritmo exacto de ramificación y poda cuyo

procedimiento esta prefijado y es prácticamente independiente del problema para

el que se utiliza. A pesar de que los métodos aproximados dependen del problema

determinado, pueden ser trasladados a otros particularizando algunas técnicas e


24

ideas específicas del algoritmo. Por ello para aplicar un método heurístico hay que

especificar el problema concreto a tratar.

En el caso concreto de este artículo, el problema de referencia que tenemos en

cuenta a la hora de explicar los métodos es el Problema del Viajante (TSP).

2.2.1 Calidad de un algoritmo heurístico

Un buen algoritmo heurístico debe poseer las siguientes características (Martí,

2003):

- Eficiencia: Que el esfuerzo computacional sea realista y acorde a la calidad

de la solución obtenida.

- Bondad: La solución que ofrece debe ser lo suficientemente buena, es decir,

que esté cerca del óptimo global del problema.

- Robustez: Debe de tener una probabilidad muy baja de obtener una mala

solución (alejada del óptimo).

Hay varios modos de medir la calidad del algoritmo con el que trabajamos:

- Compararlo con una solución óptima aplicándolo a un problema cuya

solución óptima se conoce (aunque la colección es reducida). Para hacer

esta comparación se mide la desviación porcentual del valor que nos ofrece

nuestro método heurístico al aplicarlo al problema y el óptimo del mismo

problema. Ésta medida se hace para varios ejemplos y se halla la el

promedio de las desviaciones.

- Compararlo con una cota en los casos en que no disponemos ni siquiera de

un conjunto limitado de ejemplos del problema del que conozcamos el

óptimo. La bondad de esta medida, obviamente, depende de lo buena que

sea la cota del problema escogida, es decir, de la cercanía de la cota al

óptimo del problema. Por ello si no tenemos información de lo buena que es

la cota esta medida carece de interés.

- Compararlo con un método exacto truncado, como por ejemplo con el de

Ramificación y Acotación si le establecemos un límite de iteraciones, un

tiempo máximo de ejecución, o algún otro criterio de parada que evite el

problema de tiempo de estos métodos exactos. Aunque sabemos que así lo

más probables es no lograr el óptimo, el valor obtenido nos sirve de cota

para hacer la comparación con nuestro algoritmo heurístico.


25

- Compararlo con otros algoritmos heurísticos. Ésta comparación es de las

más utilizadas para los problemas NP-hard ya que para ellos son conocidos

buenos heurísticos. La efectividad de esta comparación depende de lo

bueno que sea el otro método heurístico con el que nos estamos

comparando.

- Analizar el comportamiento de nuestro algoritmo en el peor de los casos, es

decir, ponerlo en práctica con los ejemplos más desfavorables para el

algoritmo y acotar, de manera analítica, la máxima desviación respecto al

óptimo. El problema de este método es que al coger el peor de los casos los

resultados no son representativos del comportamiento medio del algoritmo.

2.2.2 Clasificación de los métodos heurísticos o aproximados

Debido a la gran variedad de métodos heurísticos existentes y a su diversa

naturaleza (algunos incluso diseñados para problemas concretos sin opción de

generalización), es muy difícil realizar una clasificación completa de los mismos. Un

modo de clasificación es el que damos a continuación (Martí, 2003), formado por

varias categorías no excluyentes:

- Métodos de descomposición: Se trata de descomponer el problema en sub-

problemas más fáciles de resolver, sin olvidar a la hora de tratarlas, que

todas esas divisiones pertenecen al mismo problema.

- Métodos inductivos: Este tipo de algoritmos usa la idea “opuesta” al grupo

anterior, puesto que trata de generalizar versiones sencillas al caso

completo. Para ello utiliza propiedades o técnicas válidas para casos de fácil

análisis, en problemas más completos.

- Métodos de reducción: Trata de identificar e introducir como restricciones

del problema algunas propiedades que las buenas soluciones cumplen. Con

ello se simplifica el problema, puesto que se acotan las soluciones posibles.

Debido a esa característica, este tipo de métodos tiene el riesgo de restringir

de tal modo que deje fuera el óptimo del problema original.

- Métodos constructivos: Estos métodos construyen paso a paso una solución

del problema tratado, añadiendo en cada paso un elemento hasta

completar una solución. Se trata de métodos iterativos y deterministas que

seleccionan la mejor elección en cada iteración del algoritmo. Son


26

ampliamente utilizados en problemas clásicos como el del viajante que nos

concierne.

- Métodos de búsqueda local: Estos métodos parten de una solución del

problema, al contrario que los constructivos que la van creando poco a poco.

A partir de esa solución inicial, van mejorando progresivamente, obteniendo

en cada paso una nueva solución, producto de un movimiento de la solución

anterior a la nueva, con mejor valor. El método se da por terminado cuando

para la solución existente no se encuentra ninguna otra solución accesible

que mejore el valor actual.

Los métodos mencionados hasta ahora forman parte de los heurísticos

tradicionales. En los últimos años ha aparecido una nueva categoría, los métodos

Metaheurísticos, que usan como base los métodos de búsqueda local junto con los

constructivos.

- Métodos Metaheurísticos: El término Metaheurístico fue introducido por

Fred Glover en 1986 al definir una clase de algoritmos de aproximación que

combinan heurísticos tradicionales con estrategias eficientes de explotación

del espacio de búsqueda. Estos métodos son más recientes y complejos que

los heurísticos clásicos y surgieron para mejorar los resultados obtenidos

por éstos.

Puesto que nuestro estudio trata de un método de éste último tipo, en los

siguientes apartados vamos a describir brevemente los métodos constructivos y los

de búsqueda local, en el enfoque del TSP, por ser la base de la metaheurística y

posteriormente profundizaremos en ella para finalmente llegar al algoritmo PSO

que trataremos en el siguiente capítulo.

2.2.3 Métodos constructivos

En este apartado trataremos los procedimientos constructivos aplicados a nuestro

problema específico, el TSP.

Se trata de procedimientos iterativos que seleccionan y añaden un elemento (el

que mejor evaluación posee de todos los posibles) en cada paso hasta obtener la

solución completa.

A continuación detallaremos de forma breve cuatro de los métodos constructivos

más utilizados para resolver el problema del Viajante, los cuales están descritos en

la revisión realizada por Jünger, Reinelt y Rinaldi (1995):


27

- Heurísticos del Vecino más Próximo.

Éste procedimiento se lo debemos a Rosenkrantz, Stearns y Lewis (1977) y

consiste en la construcción de un ciclo Hamiltoniano (ciclo que pasa

exactamente una vez por cada vértice, salvo por el vértice del que parte ya

que también es al que llega al final del ciclo) de coste reducido, buscando el

vértice más cercano al vértice en que te encuentras.

Este algoritmo presenta el problema denominado “miopía del

procedimiento”, lo cual significa que empieza muy bien escogiendo aristas

de bajo coste pero no ve más allá de lo que escoge en cada momento, y por

tanto no se preocupa de lo que va quedando, haciendo que cuando el

procedimiento va evolucionando, las aristas que queden para elegir serán

cada vez menos y probablemente su conexión requiera un coste muy

elevado. Además la implementación de este método para ejemplos de gran

tamaño es muy lenta.

Para disminuir la miopía y el tiempo computacional del algoritmo se utiliza

“subgrafo candidato”, es decir, un subgrafo del grafo completo del problema

en el que se representan todos los vértices (n), pero sólo se ponen las

aristas (k) que resultan atractivas (las que suponen un bajo coste, en este

caso, las que unen el vértice con sus vecinos más cercanos).

De este modo se selecciona el próximo vértice a unir examinando solamente

los adyacentes al vértice actual en el subgrafo candidato y en caso de que

todos estén ya metidos en la ruta establecida hasta el momento, se

examinan todos los vértices restantes (cuando un vértice se mete en la ruta

se eliminan las aristas que inciden en él del subgrafo candidato debido a

que no se puede pasar dos veces por la misma ciudad). Además se

establece un número s (menor que k) que sirve para evitar aislamientos, es

decir, cuando hay un vértice que no está aún incluido en el tour y está

conectado a s o menos aristas en el subgrafo, se añade al tour para evitar

que quede aislado y suponga un coste muy elevado al insertarlo en la

solución.

- Heurísticos de Inserción.

Este tipo de algoritmos comienzan creando ciclos que visitan únicamente

ciertos vértices y poco a poco los amplían añadiendo el resto de los vértices

hasta crear un ciclo Hamiltoniano.

Este procedimiento fue desarrollado por los mismos autores que el del

vecino más próximo y se ha comprobado experimentalmente que el ciclo

inicial no condiciona mucho la solución del problema.

Existen varios criterios de inserción del vértice: Inserción más cercana

(meter el vértice j que más cerca esté del ciclo, sabiendo que la distancia del

vértice al ciclo es la mínima distancia que hay desde ese vértice a

cualquiera de los vértices del ciclo), inserción más lejana (se selecciona el

vértice más lejano al ciclo, calculando la distancia del modo anterior),


28

inserción más barata (coger el que supone el coste más reducido) e

inserción aleatoria (se selecciona al azar).

- Heurísticos Basados en Árboles Generadores.

Este heurístico se basa en árboles generadores de coste mínimo, que posee

información sobre la estructura del grafo, además de la información de

coste que ya añadían los ciclos Hamiltonianos.

Prim creó en 1957 el algoritmo que obtiene un árbol generador de mínimo

peso (grafo donde todo par de vértices están unidos mediante un camino y

que no posee ciclos, además al ser el de mínimo peso tiene que ser el árbol

generador, de todos los posibles del grafo, que menos coste supone) y

Christofides es quien, en 1976, creó el algoritmo que lleva su nombre y

busca un camino Hamiltoniano de costo bajo en un grafo. Los pasos

principales del algoritmo de Christofides son: Calcular un Árbol Generador de

Peso Mínimo, obtener un conjunto de vértices (impares) del mismo y obtener

un acoplamiento perfecto de peso mínimo sobre ellos, posteriormente

añadir al árbol las aristas del acoplamiento y realizar el procedimiento de

obtención del Tour (formar un ciclo de Euler y saltando los vértices visitados

transformarlo en un ciclo Hamiltoniano).

- Heurísticos Basados en Ahorros

Los fundadores de este método son Clarke y Wright (1964), cuya propuesta

original fue para problemas de rutas de vehículos pero nosotros lo veremos

adecuado al problema del viajante.

En este método se crea un ciclo Hamiltoniano mediante la combinación de

subtours, que comparten un vértice llamado base.

El procedimiento consiste en crear los subtours y luego eliminar las aristas

que conectan dos vértices de diferentes subtours con el vértice base, para

después conectar dichos vértices entre sí, uniendo así los dos subtours (se

hace con las que más ahorro proporcionen (entendiendo por ahorra, la

diferencia que hay entre las aristas que se han eliminado respecto a la que

se ha añadido). En este tipo de problemas también se puede usar el

subgrafo candidato para mejorar los resultados del algoritmo y acelerar la

ejecución.

Podemos ver un ejemplo gráfico del método en la figura 5, donde el vértice

base es el z y se eliminan las uniones del mismo con i y j para introducir

posteriormente la nueva arista (i,j).


29

Figura 5. Heurísticos Basados en Ahorros. Martí, 2003.

A continuación se muestra en la tabla 2 la comparativa de los 4 métodos

anteriormente descritos en la que se especifica la desviación de la solución

obtenida al resultado óptimo y el tiempo computacional del algoritmo. El tiempo de

ejecución está dado sobre el ejemplo de mayor tamaño de la librería TSPLIB

(pr2392) debido a que al tratarse de métodos sencillos su tiempo es reducido.

Tabla 2. Resultados de los métodos constructivos. Martí, 2003.

Podemos apreciar que el método de los ahorros y el de inserción del elemento más

lejano son lo que mejor resultado proporcionan, aunque también son más lentos.

2.2.4 Métodos de búsqueda local

Los métodos de búsqueda local, también llamados métodos de mejora, suelen

obtener mejores soluciones que los constructivos. Lo que hacen es partir de una

solución inicial y examinar sus alrededores en busca de otra solución mejor a la

actual. Formalmente podemos decir:

Para un conjunto de soluciones X del problema, cada una de las soluciones x tiene

asociado un subconjunto, perteneciente a X, que es el entorno o vecindad de x,

N(x). Dada la solución x, cada solución de su vecindad x’ (que pertenece a N(x)) se

obtiene directamente aplicando un operación, llamada movimiento, a x.

De manera práctica, lo que hacemos es partir de una solución inicial 𝑥0 de la que

calculamos la vecindad N(𝑥0) y aplicando el movimiento 𝑚1, obtenemos 𝑥1


30

perteneciente al entorno. Este proceso se aplica iterativamente creando una

trayectoria hasta que se satisfaga la condición de parada.

En este tipo de métodos es importante determinar cómo definimos el entorno N(x) y

qué criterio tenemos para seleccionar la nueva solución (perteneciente al entorno).

La especificación de la vecindad varía en función del problema que se va a resolver

y en cuanto a los criterios de selección, existen varios. Uno de los más comunes es

el de greedy, que consiste en coger de entre toda la vecindad, aquella solución que

mejor valor tiene en la función objetivo del problema, siendo este valor mejor que el

de la solución actual. Si no existe ninguna solución del entorno que posea un mejor

valor (condición de parada), se detiene el algoritmo y la solución actual será la

solución del algoritmo.

Este método no asegura obtener el óptimo global del problema a causa de la

“miopía” debida a que solo se examina el entorno establecido, por lo que si dentro

del entorno no hay una solución mejor, no irá más allá y dejará el resto del espacio

sin examinar. Esto provoca que lo que lo único que se puede asegurar es que la

solución hallada será el óptimo local respecto al entorno establecido.

El inconveniente de la miopía es una de las cosas que busca solucionar la

metaheurística basada en la búsqueda local que detallaremos más adelante. Para

ello es necesario en ocasiones ir a una solución peor, lo cual tiene algunos

inconvenientes: nos podemos meter en un proceso cíclico al coger a veces

soluciones mejores y otras veces peores y además el problema iteraría sin fin, por

lo que habría que establecer una condición de parada diferente.

Los algoritmos de búsqueda local varían dependiendo del problema que se trate. A

continuación describiremos brevemente tres de los procedimientos más utilizados

para resolver el TSP según Jünger, Reinelt y Rinaldi (1995):

- Procedimientos de 2 intercambio.

Está basado en el hecho de que se pueden acortar los ciclos Hamiltonianos

cuando dos aristas del mismo se cruzan, eliminando las dos aristas

secantes y conectando los dos caminos que resultan mediante aristas que

no se crucen, obteniendo así un ciclo final más corto que el de origen. En la

figura 6 se puede ver como se acorta la distancia del ciclo eliminando las

aristas (i,j) y (l,k) y poniendo (i,k) y (l,j).


31

Figura 6. Procedimiento de 2 intercambio. Martí, 2003.

El movimiento 2-opt sigue este principio, de modo que lo que hace es

eliminar dos aristas del ciclo y volver a unir los dos caminos que se obtienen

de distinto modo, obteniendo así un nuevo ciclo.

El algoritmo heurístico de mejora 2-óptimo examina vértice a vértices y

estudia todos sus posibles movimientos 2-opt, realizando el mejor de ellos

(en caso de que éste reduzca la distancia del ciclo, de lo contrario sobre ese

vértice no se realiza ningún movimiento), esto se repite de forma iterativa

hasta que no existan movimientos 2-opt, que mejoren el ciclo, para ninguno

de los vértices del problema.

Este método tiene un alto coste computacional por lo que se proponen dos

medidas para su reducción: utilizar el subgrafo candidato (una de las aristas

añadidas en el movimiento, como mínimo, tiene que pertenecer al subgrafo)

y el consejo de interrumpir el algoritmo antes de que acabe (las primeras

iteraciones mejoran mucho, pero las últimas apenas varían la distancia).

Estas acciones suponen perder la garantía de llegar a un óptimo local, por lo

que su aplicación dependerá de lo crítico que sea el tiempo de ejecución.

- Procedimientos de k – intercambio.

La diferencia con el anterior es que en este caso el ciclo Hamiltoniano se

divide en k partes (en vez de 2) y como antes, se reagrupan los caminos que

quedan de la manera más beneficiosa, siendo esta modificación el

movimiento k-opt. Cuanto mayor es k, más tiempo computacional lleva

implementar el algoritmo.

Nosotros vamos a ver el caso 3-opt. Un movimiento 3-opt consiste en

eliminar 3 aristas y reconectar los 3 caminos que resultan, para ello hay 8

maneras de conectarlos diferentes que hay que analizar por lo que este

algoritmo es costoso.

Por ello se restringe el problema, definiendo para cada vértice i un conjunto

N(i) de vértices (por ejemplo los contiguos a i), de manera que cuando se

estudian los movimientos 3-opt para una arista (i,j), solo se tienen en

consideración los casos en los que las otras 2 aristas poseen, al menos, uno

de sus vértices dentro de N(i).


32

Los pasos del algoritmo son los mismos que para el caso 2-opt cambiando

el movimiento 2-opt por el 3-opt y se añadiendo la restricción del conjunto

de vértices N(i).

- Algoritmo de Lin y Kernighan.

Este algoritmo tiene el mismo principio de funcionamiento que el 2-opt y 3-

opt, de modo que hace movimientos que mejoran el ciclo Hamiltoniano

inicial del que parte, hasta que llega a un óptimo local del problema.

La diferencia principal con los anteriores es que aquí se utilizan

movimientos compuestos, formados por movimientos consecutivos simples,

que pueden mejorar o empeorar la solución por sí mismos, pero el conjunto

del movimiento completo sí que mejora. Este algoritmo tiene versiones muy

diferentes, dependiendo de los movimientos sencillos que formen el

movimiento compuesto.

En la figura 7 vemos un ejemplo donde el movimiento compuesto es: dos

movimientos 2-opt y un movimiento de inserción.

Ciclo Hamiltoniano Inicial

Movimiento 2-opt (12,1) y (5,6) (12,5) y (1,6)

Movimiento 2-opt (6,1) y (3,4) (6,3) y (1,4)

Inserción del vértice 9 entre el 1 y 4

Figura 7. Algoritmo de Lin y Kernighan. Martí, 2003.

Debido al gran número de combinaciones posibles para realizar los

movimientos, hay que restringir los movimientos a analizar en cada paso.

Dos variantes de hacerlo son:


33

Analizar los movimientos pertenecientes a un subgrafo candidato que

contiene las aristas de los 6 vértices más cercanos al nodo. Se

aceptan movimientos compuestos formados, como mucho, por 15

movimientos simples teniendo que ser todos del tipo 2-opt o

inserción. Y por último, en el primero de los movimientos simples sólo

se analizan 3 candidatos.

En este caso el subgrafo candidato tiene en cuenta las aristas

relativas a los 8 vecinos más cercanos. Al igual que el anterior el

movimiento compuesto puede tener hasta 15 simples 2-opt o de

inserción. Para finalizar, en los 3 primeros movimientos simples sólo

se examinan 2 candidatos.

En la tabla 3 que se muestra a continuación se comparan los métodos anteriores

(la solución inicial se ha hallado con el método del vecino más próximo)

especificando en promedio la desviación respecto al resultado óptimo (se han

utilizado los 30 ejemplos de la librería TSPLIB) y el tiempo de ejecución del

algoritmo (para el ejemplo pr2392 de la librería).

Tabla 3. Resultados de los métodos de búsqueda local. Martí, 2003.

Podemos observar como pasar del método 2-óptimo al 3-óptimo incrementa mucho

el tiempo computacional, cosa que también ocurre cuando en el método Lin y

Kernighan pasamos de un subgrafo de 6 vecinos a uno de 8. También podemos ver

que la desviación del óptimo para los casos de movimientos compuestos es mucho

más eficiente que utilizar solo movimientos simples que mejoran el resultado (k-

óptimo).

Teniendo en cuenta ambos factores el método más eficiente parece el de Lin y

Kernighan para la variante de un subgrafo de 6 vecinos, puesto que el tiempo de

ejecución es 3 veces menor y la diferencia de calidad de la respuesta es muy

pequeña.


34

2.2.5 Métodos Metaheurísticos

Los procedimientos metaheurísticos son un tipo de procedimiento heurístico que

surgen en los años 70 (Luque, G. 2006), bajo la idea de combinar varios métodos

heurísticos a un nivel superior para lograr una eficiente y efectiva exploración del

espacio de búsqueda, aunque no se les conoce así hasta el año 1986, cuando

Glover les otorga el nombre de metaheurísticos por el que ahora los conocemos.

Hasta ese momento eran conocidos como heurísticos modernos. Por ello, aunque

en algunos artículos se siguen utilizando los términos “heurísticos modernos” y

“heurísticos clásicos”, en la mayoría se utiliza “heurística” para denominar a la

heurística clásica y “metaheurística”, para hacer referencia a este tipo específico

de procedimientos heurísticos, que son más recientes y complejos, y cuya

definición puede ser esta que nos ofrecen (Martí, 2003) Osman y Kelly en 1995:

Los procedimientos metaheurísticos son una clase de métodos aproximados

que están diseñados para resolver problemas difíciles de optimización

combinatoria, en los que los heurísticos clásicos no son efectivos. Los

Metaheurísticos proporcionan un marco general para crear nuevos

algoritmos híbridos combinando diferentes conceptos derivados de la

inteligencia artificial, la evolución biológica y los mecanismos estadísticos.

El prefijo “meta” quiere decir “más allá” o “a un nivel superior”, denotando por

tanto, que este tipo de métodos construyen algoritmos que van más allá de la

heurística clásica. Se trata de inteligentes estrategias generales de diseño que

crean o perfeccionan, con elevado rendimiento, procedimientos heurísticos

generales con el objetivo de resolver un problema de forma eficiente.

Una definición formal de los elementos que intervienen en los métodos

metaheurísticos es (Luque, G. 2006):

M = < T, μ, λ, Θ, Φ, σ, Ξ, τ >

Donde:

- T es el conjunto de elementos que manipula la metaheurística, que suele

coincidir con el espacio de búsqueda.

- μ es la cantidad de estructuras (soluciones) con las que trabaja la

metaheurística.

- λ Indica el número de nuevas estructuras, generadas en cada iteración de la

metaheurística, resultantes de aplicar Φ a Θ.


35

- Θ = { θ1,…, θμ} son las variables que almacenan las soluciones con las que

trabaja la metaheurística M, donde todas las θ𝑖 del conjunto Θ pertenecen

a T.

- Φ: Tμ x Ξ → T

λ es el operador responsable de la modificación de las

estructuras.

- σ: Tμ+λ

x Ξ → Tμ función responsable de la selección de las nuevas estructuras

que se tratarán en la siguiente iteración de la metaheurística.

- Ξ = { ξ1, ξ2,…} variables de estado que poseen información sobre la

evolución del algoritmo. El conjunto tiene que tener mínimo un elemento ξ1

= θ∗ , que es la mejor solución encontrada del problema.

- τ: Θ x Ξ {true, false} función que determina el final del algoritmo (criterio de

parada).

El funcionamiento de cualquier metaheurística M se podría definir de manera

formal de la siguiente manera:

Θ𝑖+1 = {θ∗}μ 𝑠𝑖 τ(Θ𝑖 x Ξ) → fin

σ(Φ( Θ𝑖 x Ξ)) en otro caso

2.2.5.1 Características de los métodos Metaheurísticos

Los métodos metaheurísticos poseen ciertas características fundamentales (Luque,

2006), de entre las que destacamos las siguientes:

- Estos métodos son plantillas o estrategias generales que lo que hacen es

guiar el proceso de búsqueda, con el objetivo de realizar eficientemente la

exploración del espacio de búsqueda del problema para lograr un resultado

óptimo o bastante aproximado a éste.

- Son algoritmos generalmente no deterministas y además son aproximados,

por lo que no se puede tener la absoluta certeza de que la solución que te

proporcionan sea el óptimo global del problema (la cual sí que obtienes en

los algoritmos exactos).


36

- Pueden agregar restricciones que evitan explorar los espacios de búsqueda

no óptimos.

- Los métodos metaheurísticos no son dependientes del problema para el

cual se van a utilizar, sino que su estructura básica es general para todo

problema.

- Son procedimientos que se pueden transformar fácilmente en algoritmos

paralelos (ejecución de varias partes del algoritmo al mismo tiempo, lo

contrario a los secuenciales), lo cual permite una notable reducción del

tiempo computacional.

- Los metaheurísticos controlan una serie de heurísticos específicos que sí

que hacen uso de las características del problema para el que se diseñan,

puesto que la metaheurística es una estrategia de nivel alto, que para

explorar el espacio de búsqueda se vale de diferentes métodos.

- Dado que la metaheurística debe ser válida para afrontar problemas con

espacios de búsqueda de grandes dimensiones, es muy importante que

exista un equilibrio dinámico entre la exploración del espacio (búsqueda en

regiones distantes del espacio, para poder diversificar su estudio) y la

explotación de las áreas concretas (esfuerzo empleado en la búsqueda

dentro de la región actual, para poder hacer un estudio suficientemente

intenso). Este equilibrio permite identificar rápidamente regiones

potenciales de espacio de búsqueda global, a la vez que evita perder tiempo

en estudiar regiones ya exploradas o en aquellas cuyas soluciones no son de

alta calidad.

De los algoritmos metaheurísticos se esperan las siguientes propiedades [9]:

- Fácil comprensión:

Simplicidad en cuanto a la comprensión del método, que debe ser

claro y sencillo.

Precisión y concretización en los pasos a seguir para crear el

algoritmo, con el objetivo de permitir una fácil implementación del

mismo.

Coherencia entre los elementos que forman la metaheurística y los

principios de la misma.

- Alto rendimiento:


37

Efectividad, eficacia y eficiencia. Debe proporcionar soluciones de

alta calidad, tener una elevada probabilidad de llegar a ellas y

aprovechar al máximo los recursos de que dispone (tiempo de

computación y memoria). Para evaluar estas propiedades hay que

ejecutar una cierto número de problemas con soluciones conocidas,

teniendo en cuenta tanto la desviación al óptimo, como el tiempo de

ejecución empleado.

- Aplicación amplia:

Utilidad general de la metaheurística, que permita que el algoritmo

sirva para muchos problemas diversos.

Adaptabilidad a diferentes entornos o variaciones del modelo a

aplicar.

Robustez suficiente para que el resultado del problema a penas varíe

ante modificaciones del modelo o entorno al que se aplica.

- Utilidad del método:

Interactividad que permita que el usuario pueda ir modificando

partes del proceso para mejorar su rendimiento.

Multiplicidad en las soluciones proporcionadas. Debe proporcionar

varias soluciones cercanas al óptimo, con el objetivo de que el

usuario escoja la que más le conviene.

Autonomía en su funcionamiento para evitar que el usuario este

pendiente del programa durante su ejecución.

2.2.5.2 Clasificación de los métodos Metaheurísticos

No existe un modo único de clasificar las técnicas metaheurísticas, puesto que

depende de la propiedad que tengamos en cuenta.

Algunas de las clasificaciones que se utilizan hoy en día están ligadas a las

siguientes características: si se fundamentan en la naturaleza, si poseen memoria,

si poseen una o varias estructuras de vecindario, la naturaleza de la función


38

objetivo, si se en cada iteración se trata un solo punto del espacio de búsqueda o si

por el contrario se trabaja con una población (conjunto de “puntos”)…

En nuestro caso hemos escogido la última de las clasificaciones enumeradas

anteriormente, puesto que creemos que es la más utilizada en los artículos

científicos, obteniendo por tanto dos grupos diferenciados (Luque, 2006):

- Metaheurísticas basadas en la trayectoria.

Estas técnicas están, en su mayor parte, basadas en los métodos de

búsqueda local con el añadido de que intentan escapar de esos óptimos

locales para mejorar su resultado.

En este tipo de métodos tomamos un punto como partida del problema y en

cada paso del algoritmo se exploran los vecinos del mismo, y se va

actualizando el punto actual creando así una trayectoria en el espacio de

búsqueda del problema.

Se termina la búsqueda cuando se alcanza la condición de parada que

puede ser: un número máximo predefinido de iteraciones, alcanzar una

calidad aceptable, detectar un estancamiento del proceso…

Teniendo en cuenta la definición formal dada en el apartado 1.2.5, este tipo

de metaheurísticas se caracterizan porque el elemento μ es 1, es decir, que

se trabaja con una sola estructura, en lugar de usar una población de una

cantidad μ de estructuras (también llamadas partículas o individuos de la

población, dependiendo del método).

A continuación se describen brevemente las metaheurísticas clasificadas

dentro de este conjunto:

SA, Recocido, Templado, o Enfriamiento Simulado

Se trata de una de las metaheurísticas más antiguas que se conocen

y probablemente la primera que trata de evitar los mínimos locales,

permitiendo para ello escoger soluciones cuyo valor de la función

objetivo es peor que el que te proporciona la solución actual.

Su funcionamiento es una simulación del proceso de recocido de los

cristales y metales, y lo que hace es estudiar el vecindario de la

partícula actual y, mediante un determinado criterio, escoger uno de

sus vecinos. Posteriormente, si ese vecino proporciona un mejor

fitness que el actual, directamente se sustituye, y si el fitness que

proporciona es peor, también se realiza la sustitución pero con una

determinada probabilidad que depende de la variación de fitness que

provocaría y de la temperatura (la probabilidad es una analogía del

proceso físico de enfriamiento, por lo que cuanto más avanzan las

iteraciones (nos vamos acercando al óptimo), menos temperatura

hay, y por tanto menos probabilidad de escoger un fitness peor).


39

Tomando como referencia la definición formal del apartado 1.2.5, en

esta metaheurística tanto μ como λ tienen el valor de 1 (se utiliza

una sola partícula o estructura), Ξ almacena la mejor solución

encontrada y la temperatura, Φ determina la elección del vecino y σ

determina si ese vecino sustituye al actual o no.

ILS, Búsqueda Local Iterada

Se trata de un método muy genérico en el cual en primer lugar se

genera una solución inicial a la que se le aplica un método de

búsqueda local para mejorarla, obteniendo así la solución inicial

definitiva y posteriormente en cada iteración se realiza una

perturbación sobre la solución actual y se le aplica un método de

búsqueda local. Para terminar la iteración, si el nuevo candidato (ya

perturbado y mejorado) pasa unos criterios de aceptación

determinados (dependientes de la búsqueda histórica y del nuevo y

actual candidato) se sustituye el actual por el nuevo candidato.

El proceso más importante a la hora de determinar el funcionamiento

de este algoritmo es el de la perturbación, puesto que no debe ser ni

tan pequeño como para no ser capaces de salir de un óptimo local, ni

tan grande como para provocar que caigamos en un método de

búsqueda local reinicializado de forma aleatoria.

Según la notación del apartado 1.2.5, μ y λ tienen el valor de 1, Ξ

almacena la mejor solución encontrada y el histórico, Φ realiza la

perturbación y su posterior búsqueda local y σ evalúa el criterio de

aceptación determinando si el candidato pasa, o no, a ser el actual.

VNS, Búsqueda con Vecindario Variable

Es un algoritmo muy general y, por tanto, flexible y adaptable a

posibles variaciones que se basa en ir cambiando entre diferentes

vecindarios a lo largo de la búsqueda.

En primer lugar se define un conjunto de vecindarios (𝑘𝑚𝑎𝑥

vecindarios) y después en cada iteración se realizan 3 fases que

consisten en elegir aleatoriamente al candidato del vecindario 𝑁𝑘(s),

siendo s el actual (comenzando por k=1), mejorar el candidato

seleccionado mediante búsqueda local y finalmente si el resultado

obtenido es mejor que el actual se realiza el movimiento

(sustituyendo el actual por el candidato resultante de la búsqueda y

volviendo a la primera fase con k=1) para esta nueva solución s, en

caso de que el resultado no sea mejor, no se realiza sustitución y se

vuelve a la primera fase, incrementando k (hasta que ésta alcance el

valor de 𝑘𝑚𝑎𝑥).


40

De este modo conseguimos el equilibrio entre intensidad y

diversidad, ya que la búsqueda local nos permite la explotación del

área mientras que los diferentes vecindarios ayudan a la exploración

del espacio de búsqueda.

Para la definición formal del apartado 1.2.5, las características de

este método son: tanto μ como λ tienen el valor de 1 (se manipula

una sola partícula), Ξ almacena la mejor solución encontrada y el

vecindario utilizado k, Φ selecciona al vecino del k-ésimo vecindario y

realiza sobre él la búsqueda local y σ determina si ese vecino

sustituye al actual o no.

GRASP, Procedimiento de Búsqueda Miope Aleatorizado y Adaptativo

Esta metaheurística fue desarrollada a finales de los 80 por Feo y

Resende y se trata de una combinación de los métodos heurísticos

constructivos y los de búsqueda local (apartados 1.2.3 y 1.2.4).

El algoritmo se divide en dos etapas, la primera es la generación de

soluciones utilizando el primero de los heurísticos mencionados y la

segunda es la mejora de la solución anteriormente construida

mediante el heurístico de búsqueda local.

En la construcción de soluciones se parte de una solución parcial

vacía 𝑠𝑝 a la que se van añadiendo en cada paso diferentes

componentes c. Los componentes son elegidos de forma aleatoria

entre una lista restringida de candidatos (RCL), que está compuesta

por los α mejores vecinos del conjunto 𝑁(𝑠𝑝). La variable α es elegida

por el usuario y determina el funcionamiento del algoritmo (Los dos

extremos: si α es 1 equivaldrá a un algoritmo voraz ya que siempre

se añadirá el mejor c y si α es 𝑁(𝑠𝑝) la elección de c será totalmente

aleatoria entre todo el vecindario).

En la segunda etapa del algoritmo se mejora la solución generada en

la fase anterior utilizando algoritmos de búsqueda local simples o

complejos, dependiendo de la elección del usuario.

El método GRASP, según la definición formal del apartado 1.2.5,

utiliza tanto μ como λ con un valor de 1, Ξ almacena solamente la

mejor solución encontrada, Φ genera una solución y sobre ella realiza

la búsqueda local y σ sustituye la solución actual por la mejora

encontrada.

TS, Búsqueda Tabú.

El origen de esta metaheurística se sitúa a finales de los años 70 de

la mano de Glover. Se trata de una de las metaheurísticas más

exitosas hasta el momento a la hora de resolver problemas


41

combinatorios y se basa en principios generales de Inteligencia

Artificial como es el concepto de memoria.

Lo que hace es extraer información de lo ocurrido y actuar en

consecuentemente, por lo que podemos decir que realiza una

búsqueda inteligente. Para ello se utiliza una lista tabú (TL) con

memoria a corto plazo que nos permite evitar los óptimos locales, a

la vez de impedir buscar en regiones que ya han sido estudiadas. En

dicha lista se almacenan los movimientos recientes y los descarta

para posibles soluciones futuras.

En cada iteración del algoritmo se filtra el vecindario de la posición

actual, 𝑁(s), con las soluciones excluidas (TL) obteniendo un

vecindario que cumple la condición tabú, al cual se le añaden las

soluciones que cumplen el denominado criterio de aspiración (el más

común es permitir introducir soluciones que posean un fitness mejor

que el mejor encontrado hasta el momento, aunque pertenezcan a la

TL). De esta unión obtenemos el vecindario reducido 𝑁𝑎(s).

Posteriormente escogemos el vecino que mejor fitness posee dentro

del 𝑁𝑎(s), se actualiza la lista tabú añadiendo este nuevo movimiento

y se reemplaza el vecino seleccionado por el actual.

Según la definición formal del apartado 1.2.5, en la búsqueda tabú μ

vale 1, Ξ almacena la mejor solución encontrada y la lista tabú, Φ

obtiene 𝑁𝑎(s) y σ determina cuál de los vecinos pertenecientes a

𝑁𝑎(s) sustituye al actual (el de mejor fitness).

- Metaheurísticas basadas en la población.

Como su propio nombre indica en este tipo de metaheurísticas

manipulamos en cada iteración un conjunto de soluciones denominado

población. La mayor diferencia que existe entre los diferentes métodos aquí

clasificados radica en el modo de manipulación de la población que utilizan.

A continuación se describen brevemente los más comunes (Luna, 2008):

EDA, Algoritmos de Estimación de la Distribución.

El primer paso, como en la mayoría de los algoritmos, es crear una

población inicial. Posteriormente, en cada iteración se selecciona un

conjunto de individuos de la población original, se estudia su

distribución probabilística y con ella se generan los nuevos individuos

que formarán la nueva población.

Muchos autores clasifican este método como una variación de los

Algoritmos Evolutivos, que explicaremos a continuación, o incluso

como un tipo de éstos, en el cual la fase de reproducción se hace de

una forma especial (mediante la distribución de la probabilidad).


42

SS, Búsqueda Dispersa.

Este método se basa en el principio de que dadas dos soluciones,

éstas se pueden combinar creando así una nueva solución que

mejora las dos predecesoras.

El primer paso del algoritmo es generar aleatoriamente la población

inicial, luego con los elementos anteriores más representativos se

genera un conjunto de referencia, RefSet (formado por soluciones

con elevada diversidad y calidad).

Posteriormente inician las iteraciones donde se crean varios

subconjuntos de soluciones, S, a partir del RefSet, y las soluciones de

estos subconjuntos son combinadas creando soluciones nuevas.

Cuando ya tenemos creadas las nuevas soluciones, se mejoran

mediante un algoritmo de búsqueda local elegido por el usuario y se

actualiza el RefSet sustituyendo parte de las soluciones del conjunto

de referencia inicial por algunas de las nuevas soluciones (solo las

que mejoran a las iniciales).

Al final de cada iteración se comprueba si RefSet converge y en caso

de ser cierto, se vuelve a generar la población completa de forma

aleatoria, se genera el conjunto de referencia (en este caso se tiene

en cuenta tanto la población creada como el RefSet anterior) y se

sigue iterando hasta que se alcance la condición de parada.

Según la definición formal del apartado 1.2.5, en este caso Φ lo

primero que hace es comprobar si converge RefSet, en caso

afirmativo crea un nuevo conjunto de referencia y en caso contrario

genera los subconjuntos, los combina y mejora los individuos

resultantes de la recombinación anterior.

EA, Algoritmos Evolutivos.

Este tipo de algoritmos simula el comportamiento evolutivo de los

seres en la naturaleza, que permite que se adapten a diferentes

cambios producidos en su entorno.

Se manipula un conjunto de individuos, donde cada uno de ellos

constituye una solución del problema, y en cada iteración hace

evolucionar a dicha población, obteniendo así una nueva más

adaptada al entorno, lo que en nuestro caso significa que posee

mejor valor de fitness.

En primer lugar se crea, bien sea de forma aleatoria o con ayuda de

un heurístico de construcción, una población inicial y se evalúa con la

función objetivo (calculando por tanto su fitness), posteriormente en

cada iteración se realizan tres fases diferenciadas.

La primera es la selección de los padres, donde se crea una nueva

población temporal de tamaño λ (población de padres), a partir de la


43

original de μ individuos, siguiendo las bases de la selección natural

(prevalecen aquellos individuos que tienen mejor fitness).

En segundo lugar se lleva a cabo la reproducción durante la cual se

realizan operaciones, con cierta probabilidad, sobre la población de

padres (recombinación de parejas o cruce y luego la mutación),

obteniendo así una nueva población, los hijos.

Para finalizar la iteración se evalúa el fitness de la población de hijos

y se realiza el remplazo de la población original (Hay dos tipos: el que

sólo tiene en cuenta a la población de hijos, y el que también tiene en

cuenta a la antigua población, de modo que se mantienen a los

mejores individuos originales y se sustituyen los peores por los

mejores hijos).

El Φ de la definición del apartado 1.2.5 es, en este caso, el

responsable de seleccionar a los padres entre la población original,

posteriormente recombinarlos y luego mutarlos y σ se encarga de

realizar el remplazo.

Este es un esquema general en el que se basan diferentes

algoritmos como son la Programación Evolutiva (EP), las Estrategias

Evolutivas (ES) y los Algoritmos Genéticos (AG), que son los más

conocidos.

PSO, Optimización por Enjambre de Partículas.

Este método simula el modo en que los enjambres de abejas buscan

el polen en la naturaleza (o el comportamiento de bandadas de aves

y bancos de peces). Lo que hacen es sobrevolar el espacio buscando

el área con mayor densidad de flores, teniendo en cuenta que

siempre recuerdan el lugar donde ellas han visualizado la mayor

cantidad y además saben cuál es el mejor sitio, encontrado por el

conjunto del enjambre. Las abejas siguen volando, en busca de

nuevas mejores soluciones, modificando su dirección en función de

esos dos datos.

La metaheurística comienza generando de forma aleatoria la

velocidad y posición inicial de cada partícula que forma la población.

Luego se evalúa el fitness de cada individuo, sabiendo con ello cuál

es la mejor solución del enjambre.

En cada iteración se actualiza la velocidad de las partículas teniendo

en cuenta la mejor solución propia y la del conjunto, y con esa

velocidad movemos la partícula, hallando así la nueva posición.

Para terminar la iteración evaluamos las posiciones y actualizamos

los valores de los óptimos encontrados por cada partícula y por el

enjambre.


44

ACO, Optimización basada en Colonia de Hormigas.

El algoritmo ACO está basado en el comportamiento natural de las

hormigas a la hora de buscar el camino más corto entre sus fuentes

de alimento y el hormiguero. Cada hormiga inicia la búsqueda de

forma aleatoria (ya que al principio no hay feromona) y al caminar va

depositando un rastro de feromona (sustancia química) que con el

tiempo se va evaporando, de modo que la hormiga que va por el

camino más corto, es la que menos tiempo da a la feromona para

evaporarse, por lo que su camino tendrá más rastro que los demás, y

como cada hormiga elige el siguiente camino a tomar en función de

la cantidad de feromona, cada vez se van acercando más al camino

corto.

La metaheurística se basa en ese proceso, de modo que el primer

paso es generar la población inicial de forma aleatoria, luego se

actualiza la matriz de feromona (formada por todos los arcos que

forman los posibles caminos) y a continuación empiezan las

iteraciones donde se actualiza la solución de cada individuo de la

población teniendo en cuenta un método heurístico de construcción y

el rastro de feromona.

Para terminar la iteración se calcula el fitness y se actualiza la

feromona (se realiza tanto la evaporación que evita caer en óptimos

locales, como el aumento de la feromona en los lugares que forman

parte de las mejores soluciones de esta iteración).

También se pueden añadir otras operaciones al método que

dependen de todo el conjunto de individuos, como por ejemplo, la

mejora de soluciones mediante búsqueda local.

Según la definición del apartado 1.2.5, lo más relevante es que Ξ

almacena la mejor solución encontrada, la matriz de feromonas e

información heurística y Φ determina la construcción de las nuevas

soluciones a partir de la información que hay en Ξ.

En el siguiente capítulo se explicará en detalle la Optimización por Enjambre de

Partículas, puesto que es la que la metaheurística en la que basamos este

proyecto.


45

3. OPTIMIZACIÓN POR ENJAMBRE DE PARTÍCULAS

El concepto del método de Optimización por Enjambre de Partículas, denominado

también PSO debido a sus siglas en inglés “Particle Swarm optimization”, es que

las partículas sobrevuelan el hiperespacio de soluciones potenciales de un

problema, acelerando hacia mejores soluciones posibles. Se trata de una analogía

con la naturaleza, concretamente está basado en el comportamiento de los

enjambres de abejas en busca de alimento que veremos más adelante.

El PSO utiliza un conjunto de partículas (denominado población o enjambre), que

representan soluciones candidatas. Cada una de esas partículas posee una

posición concreta (x) y se va moviendo según una determinada velocidad (v) por

todo el espacio de búsqueda, obteniendo así una nueva posición. Para calcular la

velocidad de cada partícula se tiene en cuenta la mejor posición encontrada hasta

el momento por la propia partícula (la denominamos p y cuyo valor en la función

objetivo es Pbest) y la mejor posición encontrada hasta ese instante por todo el

enjambre (llamada g y cuyo valor es Gbest).

Además el PSO forma parte de los métodos metaheurísticos, de resolución de

problemas de optimización, por lo que las características de la metaheurística

explicadas en el capítulo anterior, también son aplicables a este método en

particular. Una de las más importantes es el hecho de que este método

proporciona una solución cercana al óptimo global del problema, pero no asegura

que coincida con el óptimo.

El PSO es un algoritmo simple y robusto, pero bastante efectivo, que optimiza un

amplio rango de funciones. Tomando como referencia la naturaleza se podría decir

que es un término medio entre los procesos evolutivos (los cuales requieren

periodos de tiempo indefinidos, de larga duración) y los procesos neuronales (que

ocurren en milisegundos).

La raíz del método está basada en dos componentes metodológicos (Eberhart y

Kennedy, 1995):

- Está vinculado a la vida artificial en general y a un rebaño de pájaros, un

banco de peces o un enjambre en particular.

- También está relacionado con la computación evolutiva, teniendo vínculos

con los Algoritmos Genéticos y la Programación Evolutiva.

El concepto de ajuste hacia el Pbest y Gbest que tiene el PSO es muy

similar, conceptualmente hablando, al operador de cruce que utilizan los AG

y además el PSO utiliza el concepto Fitness, al igual que se hace en la EP.


46

Finalmente, esta metaheurística, al igual que la programación evolutiva, se

ve afectada por los factores estocásticos.

La optimización por enjambre de partículas es capaz de encontrar solución a

muchos de los tipos de problemas que también son resueltos mediante los

algoritmos genéticos, sin padecer, además, algunos de los problemas a los que

éstos se enfrentan:

- Por un lado la interacción en grupo mejora el progreso hacia la solución.

- Por otro lado el PSO tiene memoria, la cual no poseen los AG, haciendo que

todas las partículas retengan el conocimiento de las buenas soluciones, lo

que permite mejorar el resultado.

La forma general del PSO lo que busca es optimizar funciones continuas no

lineares, por lo que, como veremos más adelante, en el caso de este proyecto

tendremos que utilizar una versión discreta del PSO para aplicarla al TSP puesto

que éste es un problema discreto (posee un número concreto de vértices).

3.1 Origen

La metaheurística de Optimización por Enjambre de Partículas fue simulada por

primera vez por James Kennedy (psicólogo) y Russell Eberhart (ingeniero eléctrico)

en 1995. Ésta simulación fue una analogía de una bandada de pájaros en busca de

maíz y tuvo mucha influencia del trabajo de Heppener y Grenander en el año 1990.

Reynolds y Heppner y Grenander son unos de los científicos más relevantes en el

estudio del comportamiento social (Kennedy y Eberhart, 1995), en su caso

simulando una bandada de pájaros. Reynolds se focalizó en la estética de las

bandadas mientras que Heppener (zoólogo) lo hizo en las reglas subyacentes que

permite a una gran cantidad de pájaros moverse de forma sincronizada (cambiando

de dirección repentinamente, dispersándose y reagrupándose…). Ambos modelos

están basados en gran medida en la manipulación de distancias inter-individuales,

es decir, la sincronización del comportamiento de la bandada está basado en el

esfuerzo de los pájaros por mantener una distancia óptima entre ellos mismos y

sus vecinos.

Según (Kennedy y Eberhart, 1995), el término “Partícula” fue un compromiso

puesto que los miembros de la población no tienen apenas masa ni volumen, por lo

que podrían llamarse puntos, sin embargo la velocidad y aceleración es más

aplicable a partículas. Es la segunda de las razones la que los hizo decantarse por

la elección de “Partícula” frente a “Punto” y a consecuencia de dicha decisión, los


47

autores decidieron llamar a su representación Optimización por Enjambre de

Partículas.

3.2 Evolución del PSO

A continuación describiremos brevemente el desarrollo conceptual del PSO

(Kennedy y Eberhart, 1995).

El algoritmo comenzó siendo una simulación de un ambiente social simplificado,

donde los agentes eran pájaros (tomando como base los estudios de Reynolds y

Heppner) y la intención original fue simular gráficamente la impredecible

coreografía sincronizada de una bandada de aves, pero como veremos acabó

siendo la simulación de un enjambre.

A continuación se explican los precursores del PSO, en forma de modificaciones

sobre ese PSO original, que han hecho que el algoritmo sea como lo conocemos

hoy en día:

- Velocidad del vecino más cercano y la variable “locura”.

La población de pájaros es inicializada aleatoriamente con una posición

para cada agente (pájaro) y con una velocidad. Ambos parámetros con sus

correspondientes coordenadas es “x” e “y”.

En cada iteración un bucle del programa determinaba para cada agente,

qué otro pájaro es su vecino más próximo y posteriormente asigna al primer

agente la velocidad de dicho vecino. Ésta simple regla crea la sincronización

del movimiento.

Desafortunadamente tras pocas iteraciones la bandada acaba teniendo una

dirección unánime e inmutable.

Ese problema se soluciona añadiendo una variable estocástica llamada

“locura”. Lo que hace esa variable es añadir, en cada iteración, un cambio

en algunas velocidades elegidas al azar, introduciendo así la variación

suficiente para que la simulación resulte interesante y se asemeje más a la

realidad.

- El vector Maizal (Cornfield vector).

La simulación de Heppner introdujo una fuerza dinámica en la simulación.

Sus pájaros se reunían en torno a un “roost”, que es una posición

determinada que los atrae hacia sí, hasta que finalmente aterrizan allí.

Añadiendo esta fuerza, ya no era necesaria la variable “locura”, ya que la

simulación asumía vida en sí misma.

Además en su modelo había otra cosa muy curiosa, los pájaros de Heppnes

sabían dónde estaba su “roost”, pero en la vida real los pájaros aterrizan en

cualquier lugar que satisface sus necesidades más inmediatas (árbol,

antena…), sobretodo, donde hay comida (si sacas comida de pájaros a la


48

calle, al momento hay muchos pájaros, aunque nunca hayan tenido un

conocimiento previo de su localización).

Esto nos hace pensar que algo de la dinámica de las bandadas permite a

sus miembros sacar provecho del conocimiento de otros.

Como consecuencia, nuestros autores crean el “Vector Maizal”, que es un

vector bidimensional con coordinadas “x” e “y” del plano, tal que:

Cada agente evalúa su posición actual, donde 𝑥𝑥 y 𝑥𝑦, son las

coordenadas x e y de la posición actual del agente y la fórmula de

evaluación es la siguiente:

Evaluación = √(𝑥𝑥 − 100)2 + √(𝑥𝑦 − 100)2 ,

Cada pájaro recuerda su mejor evaluación (valor Pbest) y la posición

p que produjo ese valor en sus respectivas coordenadas: 𝑝𝑥 y 𝑝𝑦.

Mientras que cada agente se mueve en el espacio evaluando sus

posiciones, sus velocidades se ajustan de forma sencilla

aproximándose a la posición de su Pbest de la siguiente manera:

Si el agente está a la derecha de su p (𝑥𝑥>𝑝𝑥), su 𝑣𝑥 (velocidad

en la coordenada x) se ajustará de forma negativa mediante

una cantidad aleatoria ponderada con un parámetro del

sistema de la siguiente forma: 𝑣𝑥= 𝑣𝑥 – rand()*p_increment.

Si está a la izquierda de su p (𝑥𝑥<𝑝𝑥), 𝑣𝑥 se ajustará

positivamente: 𝑣𝑥= 𝑣𝑥 + rand()*p_increment.

Si está por encima de p (𝑥𝑦>𝑝𝑦), la velocidad en la coordenada

y será: 𝑣𝑦= 𝑣𝑦 - rand()*p_increment.

Y si se encuentra por debajo de su p (𝑥𝑦<𝑝𝑦): 𝑣𝑦 = 𝑣𝑦 +

rand()*p_increment.

Además cada agente conoce la mejor posición global del conjunto (g)

y su valor (Gbest). Para almacenarlo se asigna a la variable g el índice

del vector del agente con el mejor valor, por lo que 𝑝𝑥(𝑔) es la mejor

posición “x” del grupo y 𝑝𝑦(𝑔) es la mejor posición “y” del mismo.

Toda esta información está disponible para cada uno de los agentes

del conjunto.

De nuevo se ajustan las velocidades de cada agente, del mismo

modo que antes pero teniendo en cuenta ahora la posición g

(g_increment es un parámetro del sistema):

Si 𝑥𝑥>𝑝𝑥(𝑔): 𝑣𝑥 = 𝑣𝑥– rand()*g_increment.

Si 𝑥𝑥<𝑝𝑥(𝑔): 𝑣𝑥 = 𝑣𝑥+ rand()*g_increment.

Si 𝑥𝑦>𝑝𝑦(𝑔): 𝑣𝑦 = 𝑣𝑦– rand()*g_increment.

Si 𝑥𝑦<𝑝𝑦(𝑔): 𝑣𝑦 = 𝑣𝑦+ rand()*g_increment.

En la simulación un círculo marca la posición (100,100) que equivale a la

evaluación = 0, y los agentes se representan con puntos de colores en su

posición. De este modo un observador puede ver de forma gráfica e intuitiva


49

la evolución de la bandada de agentes hasta que encuentran el simulado

maizal.

Cuando los parámetros p_increment y g_increment son relativamente altos,

la bandada parece ser violentamente absorbida por el maizal. En pocas

iteraciones todos los agentes parecen ser reagrupados dentro de un

pequeño círculo que rodea al objetivo.

Cuando p_increment y g_increment son bajas, la bandada se arremolina

alrededor del objetivo, acercándose de un modo realista, balanceándose

rítmicamente con subgrupos sincronizados, para finalmente aterrizar en

objetivo.

- Eliminación de variables auxiliares

Puesto que el modelo puede optimizar de forma simple, es importante

identificar las partes del mismo que no son necesarias.

Kennedy y Eberhart pronto se dieron cuenta de que el algoritmo funcionaba

igual de bien y parecía igual de realista sin la variable “locura”, por lo que se

eliminó.

Después se dieron cuenta de que la optimización ocurría un poco más

rápido cuando la velocidad del vecino más cercano era eliminada, aunque el

efecto visual cambiaba.

El cambio visual producido fue que movimiento ya no era tan sincronizado,

por lo que la simulación pasaba de tener un comportamiento de bandada a

comportarme más como un enjambre, pero con este nuevo comportamiento

también era capaz de encontrar el maizal. En este punto fue en el que se

dieron cuenta de que el PSO era más una simulación de enjambre que de

bandada.

Las variables p y g y sus incrementos sí que son necesarias.

La primera es la memoria autobiográfica, cómo cada individuo

recuerda su propia experiencia.

El ajuste de la velocidad mediante p_increment es llamado “simple

nostalgia”, que muestra cómo cada individuo tiende a volver al lugar

que más le ha satisfecho.

Por otro lado la variable g hace referencia al conocimiento público,

aquel que es conocido por todo el enjambre.

Un valor alto de p_increment respecto a g_increment tiene como resultado

el aislamiento individual en el espacio, mientras que lo contrario (alto valor

de g_increment respecto al p_incerment), hace que la bandada vaya

rápidamente a un mínimo local. Por tanto hay que buscar el equilibrio entre

las dos parámetros del sistema.

Experimentalmente se ha comprobado que valores bastante similares de

p_increment y g_increment son la búsqueda más efectiva del problema.


50

- Búsqueda multidimensional.

A pasar de que el algoritmo parece modelar bastante bien una bandada

buscando un maizal, los problemas de optimización más interesantes no

son ni lineares, ni bidimensionales.

Uno de los objetivos de los autores es modelar el comportamiento social, el

cual es multidimensional.

Para ello se realiza el “simple salto” de cambiar tanto 𝑥𝑥 y 𝑥𝑦, como también

𝑣𝑥 y 𝑣𝑦, de vectores unidimensionales a matrices D*N, donde D es el

número de dimensiones y N el número de agentes.

- Aceleración por distancia.

Aunque el algoritmo funcionaba bien, había algo estéticamente

desagradable.

Hasta ahora los ajustes de velocidad estaban basados en una prueba de

desigualdad (si 𝑥𝑥>𝑝𝑥 disminuirlo, y si 𝑥𝑥<𝑝𝑥 aumentarlo).

Ciertos experimentos revelaron que cuánto más lejos se revise el algoritmo,

más fácil es de entender y mejorar su rendimiento, por lo que a partir de

este momento, en lugar de comprobar el signo de la desigualdad, las

velocidades fueron ajustadas de acuerdo con sus diferencias

dimensionales, con respecto a sus mejores localizaciones, de la siguiente

manera:

𝑣 = 𝑣 + rand()*p_increment*(𝑝 - 𝑥)

𝑣 = 𝑣 + rand()*g_increment*(𝑝(𝑔) - 𝑥)

- Versión actual simplificada.

Pronto se dieron cuenta de que no había una buena forma de adivinar el

correcto valor para p_increment y g_ingrement, por ello esos dos términos

fueron también eliminados del algoritmo.

El factor estocástico fue multiplicado por 2 para dar una media de 1, por lo

que ese agente sobrevolaría el objetivo la mitad de tiempo.

Esta versión supera la anterior. Investigaciones posteriores mostrarán si

existe un valor óptimo para la constante actualmente fijada en 2, si el valor

debe ser desarrollado para cada problema, o si puede ser determinado a

partir de algún conocimiento de un problema particular.

El PSO simplificado actual ajusta la velocidad del siguiente modo:

𝑣 = 𝑣 + 2*rand()*(𝑝 - 𝑥) + 2*rand()*(𝑝(𝑔) - 𝑥)

- Otros experimentos.

Otras variaciones del algoritmo han sido probadas, pero ninguna parece

mejorar la versión simplificada anteriormente explicada.


51

3.3 Analogía con la naturaleza

El PSO es una técnica de optimización iterativa, siendo estas técnicas tan antiguas

como la vida en sí misma, muestra de ello es que incluso los seres más primitivos

actuaban de acuerdo a un impulso muy simple, el de mejorar su situación.

Observando la naturaleza encontramos muchas acciones y estrategias naturales,

que demuestran su efectividad con la persistencia de las especies que participan

en ellas, por lo que no es sorprendente que bien de forma explícita o implícita,

varios modelos matemáticos de optimización tengan su base en comportamientos

biológicos.

Además de la efectividad de algunos comportamientos de las especies, otra razón

para utilizar métodos basados en la naturaleza es, que no parece ilógico suponer

que algunas mismas normas sociales subyacen en el comportamiento social de los

animales y de las personas (Kennedy y Eberhart, 1995).

El socio-biólogo E. O. Wilson, referenciándose a los bancos de peces, dijo: “Al

menos en teoría, los miembros individuales de un banco de peces pueden

beneficiarse de los descubrimientos y de la experiencia previa de todos los demás

miembros del banco durante la búsqueda de alimento. Esta ventaja puede llegar a

ser decisiva, pesando más que la desventaja de la competencia por los productos

alimenticios, siempre que los recursos estén distribuidos impredeciblemente en

bancales”.

De la declaración de Wilson podemos interpretar, de manera general, que el

intercambio social de información entre especies ofrece una ventaja evolutiva. Esta

conclusión es una hipótesis fundamental para el desarrollo del PSO.

Entre los modelos que se basan en conductas de la naturaleza, podemos distinguir

aquellos que se basan en comportamientos individuales de los que lo hacen en

comportamientos colectivos (Clerc, 2010):

- En el caso individual, la estrategia más utilizada es tratar de beneficiarse en

todo momento de cualquier mejora inmediata (que mejore el objetivo), este

modo de actual puede hacer que se caiga en un óptimo local.

Para evitar estos óptimos locales lo que se hace es permitir que en algunos

caso se empeore, con la esperanza de obtener al final un mejor resultado,

pero para evitar el caos total, el sujeto debe almacenar la mejor posición

para poder volver a ese punto en caso de ser necesario.

- En el caso colectivo, esa información puede ser conservada de forma

natural, basta con que el individuo con la mejor posición no se mueva y sea

el resto del grupo el que siga explorando los alrededores, necesitando dos


52

parámetros adicionales al caso anterior, que son el tamaño del grupo

(puede ser fijo o variable durante la búsqueda) y su estructura (entendiendo

por estructura al modo de transmisión de la información que se da entre los

miembros del grupo). Es más probable caer en un óptimo local cuando se

utilizan métodos individuales, que cuando se usan los colectivos.

El PSO es un método colectivo además de iterativo, cooperativo y parcialmente

aleatorio.

A lo largo del tiempo muchos investigadores han creado simulaciones

computacionales basadas en el movimiento de organismos animales (bandadas de

pájaros, bancos de peces…). Cabe remarcar la labor tanto de Reynold como de

Heppner y Grenander, cuyos descubrimientos fueron tenidos muy en cuenta por

Kennedy y Eberhart a la hora de adentrarse en el mundo del PSO.

Por supuesto, el comportamiento humano no es idéntico al de un banco de peces,

una bandada de pájaros o un enjambre de abejas, los cuales se mueven para evitar

depredadores, buscar comida, buscar compañeros, optimizar su entorno…mientras

que los humanos no solo ajustan su trayectoria por factores físicos, sino que

también tienen en cuenta las variables cognitivas y experimentales, por lo que los

métodos no son una copia exacta del comportamiento animal.

En el desarrollo del PSO lo que se simula es el modo de actuar de los enjambres,

aunque, como vimos en el apartado anterior, comenzó simulando bandadas de

pájaros.

En la naturaleza las abejas vuelan por el espacio buscando el lugar donde haya

mayor concentración de flores, puesto que allí será probablemente el sitio donde

encuentren más polen para alimentarse.

Durante su vuelo, cada abeja es capaz de recordar el sitio donde ella ha localizado

mayor densidad floral y además todas las abejas del enjambre saben cuál ha sido

el sitio con más flores localizado por el conjunto del enjambre.

Cada abeja va variando individualmente su movimiento aproximándose hacia las

dos posiciones que recuerda, probablemente hacia algún punto entre ambas.

Si durante el vuelo alguna abeja encuentra un lugar con más flores que el

encontrado hasta el momento por el enjambre, lo comunicaría y todo el enjambre

reorientaría su búsqueda hacia ese nuevo punto (si el punto encontrado supera el

mejor sitio que ella ha encontrado, pero no supera el mejor global encontrado por

el enjambre, en ese caso, sólo su dirección se modificaría).


53

Para desarrollar el algoritmo hay que tener en cuenta los 5 principios básicos de la

inteligencia de los enjambres que desarrolló Millonas en su modelo de vida artificial

(Eberhart y Kennedy, 1995):

- Principio de proximidad: La población debe ser capaz de llevar a cabo

cálculos simples del espacio y del tiempo.

- Principio de calidad: la población debe de ser capaz de responder a los

factores de calidad del entorno.

- Principio de diversidad: La población no debe realizar sus actividades por

canales excesivamente estrechos.

- Principio de estabilidad: La población no debe cambiar su forma de

comportarse cada vez que cambie el entorno.

- Principio de adaptabilidad: La población tiene que cambiar su

comportamiento cuando merece la pena la ganancia computacional. (este

principio y el anterior son lados opuestos).

El PSO cumple estos 5 principios. Se trata cálculos en un espacio n-dimensional

llevados a cabo sobre una serie de pasos de tiempo (proximidad). La población

responde a los factores de calidad Pbest y Gbest. La distribución de respuestas

entre p y g asegura la diversidad. Y finalmente, la población sólo cambia su estado

(comportamiento) cuando g cambia (estabilidad porque sólo cambia en ese caso y

a su vez adaptabilidad porque cuando varía g es capaz de ajustarse).

3.4 Descripción del método

El PSO está compuesto por un número de partículas localizadas en el espacio de

búsqueda de alguna función o problema.

Cada partícula realiza un seguimiento de sus coordenadas en el hiperespacio, las

cuales se asocian con la mejor solución que ha logrado la propia partícula hasta el

momento (p), cuyo fitness (valor de la función objetivo) se almacena en Pbest, y con

la mejor solución que ha logrado el conjunto del enjambre (g), cuyo valor se

almacena en Gbest.

El fundamento del algoritmo consiste ir cambiando, a cada paso del tiempo, la

posición de cada partícula según la velocidad de la misma. La velocidad se ve

afectada por la posición actual, su posición p y por g. El usuario debe determinar la

velocidad máxima a la que se pueden mover las partículas para evitar que sea tan


54

alta como para hacer que las partículas vuelen fuera del espacio útil y se produzcan

desbordamientos.

La inicialización del PSO es, al igual que para los algoritmos genéticos, un conjunto

de soluciones aleatorias (posiciones), pero el PSO añade además, que a esas

soluciones potenciales se les asigna una velocidad inicializada también se forma

estocástica, de modo que después las soluciones potenciales (llamadas partículas)

“vuelan” por el espacio.

Cada una de las partículas evalúa el objetivo de la función en su posición actual y

posteriormente determinan su movimiento en el espacio de búsqueda combinando

la información de su posición actual, su mejor posición encontrada y la mejor

posición del conjunto de partículas del enjambre; todo ello afectado por algunas

perturbaciones aleatorias.

La siguiente iteración se lleva a cabo cuando todas las partículas que forman el

enjambre se hayan movido.

Finalmente el enjambre, como un todo, probablemente se sitúe muy próximo a un

óptimo de la función a estudiar.

Mientras el sistema realiza iteraciones, las partículas individuales son conducidas

hacia un óptimo global basado en la interacción de sus búsquedas particulares y

las búsquedas públicas del conjunto. El criterio de parada (ya sea en forma de

umbral de error, de iteraciones máximas o al presionar una tecla) debe ser definido

y cuando sea satisfecho, las iteraciones deben cesar y el mejor de los vectores

encontrados se deberá escribir en un archivo como solución al problema.

Parece obvio que cuantas más iteraciones se realicen (lo cual implica más

posiciones analizadas), mejor será la solución, pero hay que tener en cuenta que

los recursos necesarios para cada iteración tienen un precio y hay que evaluar si

merece la pena la mejora que puedas hallar en relación al coste que supone. Por

ello se marca un criterio de parada.

3.4.1 Pasos del algoritmo

En primer lugar introducimos la nomenclatura que vamos a utilizar posteriormente

para describir el algoritmo paso a paso. Cada individuo (partícula) del PSO se

compone de tres vectores dimensionales:

- 𝑥𝑖 que es la posición actual de la partícula i. Conjunto de coordenadas

(tantas coordenadas como dimensiones tiene el espacio) que describe el

punto actual en espacio de búsqueda.


55

- 𝑝𝑖 que es el conjunto de coordenadas de la mejor posición encontrada hasta

el momento por la partícula i.

Además cada partícula también posee la variable 𝑃𝑏𝑒𝑠𝑡𝑖 (“previous best”)

que almacena el fitness de la posición 𝑝𝑖, con el objetivo de hacer

comparaciones de manera más sencilla.

- 𝑣𝑖 que se refiere a la velocidad de la partícula i.

Puesto que el PSO no se trata de una colección de partículas individuales, sino que

interactúan entre ellas para poder así progresar y lograr una buena solución al

problema, también se tiene en cuenta el siguiente vector común para todo el

enjambre:

- 𝑔 que es el conjunto de coordenadas de la mejor posición encontrada hasta

el momento por cualquier partícula del conjunto.

Análogo a 𝑃𝑏𝑒𝑠𝑡𝑖, existe la variable 𝐺𝑏𝑒𝑠𝑡 que almacena el valor de 𝑔.

En resumen, podemos describir el algoritmo PSO como una técnica de optimización

para usar en un espacio de números reales, cuyas soluciones potenciales del

problema son representadas como partículas que poseen coordinadas 𝑥𝑖 y

velocidades de cambio 𝑣𝑖 en un espacio D-dimensional. Cada partícula i tiene el

registro de su mejor rendimiento previo en el vector 𝑝𝑖 y a la variable g se le asigna

la posición del mejor rendimiento encontrado por todo el conjunto hasta el

momento. En cada iteración del algoritmo se realiza: el ajuste de 𝑣𝑖 hacia la

dirección de 𝑝𝑖 y de 𝑔 y la actualización y evaluación de cada partícula y ajuste de

los parámetros 𝑝𝑖 y de 𝑔.

A continuación se expondrán detalladamente paso a paso ese proceso [10]:

En primer lugar hay que inicializar la población por lo que para cada partícula i se

hace lo siguiente:

- Se inicializa aleatoriamente 𝑥𝑖 con la condición de que se encuentre dentro

del límite inferior y superior del espacio de búsqueda.

- Se asigna a 𝑝𝑖 la misma posición que se acaba de hallar aleatoriamente

para 𝑥𝑖, puesto que al ser la iteración inicial, el mejor valor encontrado por la

partícula corresponde con la única posición que ha explorado, la actual.

- Se calcula el fitness de 𝑥𝑖 para la partícula y se otorga el valor calculado a su

correspondiente 𝑃𝑏𝑒𝑠𝑡𝑖.


56

- Se inicializa g con la posición 𝑥1 de la primera partícula analizada y el fitness

de 𝑥1 se otorga a 𝐺𝑏𝑒𝑠𝑡.

Durante el proceso de inicialización, para el resto de las partículas lo que se

hace es mirar si su 𝑃𝑏𝑒𝑠𝑡𝑖 es mejor que el 𝐺𝑏𝑒𝑠𝑡, en cuyo caso se

reemplaza g por la posición 𝑥𝑖 y el valor de 𝑥𝑖 se le da a la variable 𝐺𝑏𝑒𝑠𝑡.

- Se inicializa de manera aleatoria la velocidad 𝑣𝑖.

Comienzan las iteraciones del algoritmo en las que se llevan a cabo los siguientes

pasos para cada partícula i (mientras no se cumpla el criterio de parada):

- Se actualiza la velocidad de la partícula según la siguiente fórmula:

𝑣𝑖 = α*𝑣𝑖 + β*rand()*(𝑝𝑖 - 𝑥𝑖) + γ*rand()*(𝑔 - 𝑥𝑖)

Donde rand() son números aleatorios, y α, β y γ son parámetros muy

importantes que se deben definir bien ya que regulan el comportamiento y

la eficacia del modelo. Son los responsables de que haya un equilibrio entre

la exploración y explotación del algoritmo.

- Se actualiza la posición actual de la partícula, añadiendo a 𝑥𝑖 las

coordinadas de 𝑣𝑖 y obteniendo así la nueva 𝑥𝑖 que utilizaremos para esta

iteración. La fórmula es la siguiente:

𝑥𝑖 = 𝑥𝑖 + 𝑣𝑖.

- La posición actual 𝑥𝑖 se evalúa mediante la función objetivo como posible

solución al problema.

- Si la evaluación de la posición es mejor que ninguna de las que han sido

encontradas hasta el momento por la partícula (Fitness de 𝑥𝑖 mejor que

𝑃𝑏𝑒𝑠𝑡𝑖):

Se actualiza 𝑝𝑖, sustituyendo sus coordenadas por las de 𝑥𝑖.

Se actualiza el valor de 𝑃𝑏𝑒𝑠𝑡𝑖 otorgándole el valor del fitness de 𝑥𝑖.

En caso contrario el 𝑝𝑖 y 𝑃𝑏𝑒𝑠𝑡𝑖 de la partícula no se modifican.

- Sólo en caso de que la partícula haya mejorado su 𝑝𝑖, se examina si el

𝑃𝑏𝑒𝑠𝑡𝑖 de esa partícula es mejor que 𝐺𝑏𝑒𝑠𝑡, y en caso de ser cierto:

Se actualiza 𝑔, sustituyendo sus coordenadas por las de 𝑝𝑖.

Se actualiza el valor de 𝐺𝑏𝑒𝑠𝑡 otorgándole el valor de 𝑃𝑏𝑒𝑠𝑡𝑖.


57

En caso contrario 𝑔 y 𝐺𝑏𝑒𝑠𝑡 conservan sus valores.

- Se evalúa la condición de parada (establecida por el usuario) y:

Si no se ha alcanzado la condición de parada, se vuelve al primer

paso del proceso de las iteraciones.

Si la condición de parada se cumple, se devuelve 𝑔 como la mejor

posición encontrada y 𝐺𝑏𝑒𝑠𝑡 como el mejor valor hallado. Y se

finaliza el algoritmo.

3.5 Versiones del PSO

A pesar de que el método es simple y bastante conciso, existen varias versiones en

función del espacio de búsqueda que se debe de analizar (continuo, discreto…), de

cómo se establecen los parámetros…

A continuación mostramos dos versiones concretas del PSO.

La primera de ellas cambia el concepto de “intercambio de información” que

teníamos en la versión original del PSO, ya que en lugar de compartir la información

con todo el enjambre, cada partícula sólo comparte información con una parte

concreta del mismo.

La segunda versión es una adaptación del PSO para poder utilizar este método en

problemas con espacios discretos, como es el caso del TSP.

3.5.1 Modelo Lbest

Se trata de una versión local del PSO (Eberhart y Kennedy, 1995). En esta variante

las partículas sólo tienen información de ellas mismas y de sus vecinas más

cercanas, en lugar de tener relación con la totalidad del grupo.

La diferencia es que las partículas en vez de moverse hacia las posiciones 𝑝𝑖 y 𝑔,

con mejor valor propio (𝑃𝑏𝑒𝑠𝑡𝑖) y mejor valor global (𝐺𝑏𝑒𝑠𝑡) respectivamente, lo que

hacen es dirigir su movimiento en función de las posiciones 𝑝𝑖 y 𝑙𝑖, es decir, la de

mejor valor propio y la de mejor valor local (𝐿𝑏𝑒𝑠𝑡𝑖).

Por tanto el modelo apenas varía. Lo que hace es, que en lugar de utilizar las

variables 𝑔 y 𝐺𝑏𝑒𝑠𝑡 ya conocidas, utiliza 𝑙𝑖, que es el conjunto de coordenadas de la


58

mejor posición encontrada hasta el momento por el vecindario de la partícula i, y

𝐿𝑏𝑒𝑠𝑡𝑖, que es la variable que almacena el fitness de la posición 𝑙𝑖.

Haciendo la sustitución de esas dos variables en el PSO general explicado en el

apartado anterior, obtenemos el algoritmo para el modelo Lbest.

Por un lado esta versión tiene la ventaja de que es menos propensa a encontrar un

óptimo local, frente a la versión estándar del PSO. Esto se debe a que un número

de grupos de partículas espontáneamente se separa y explora diferentes regiones,

por lo que resulta más flexible que el modelo original. De todos modos esta versión

también tiene posibilidad de caer en un óptimo local (la mejor manera de evitarlo

es establecer una velocidad máxima pequeña, aunque sabiendo que es un

algoritmo aproximado, tampoco lo asegura), pero aun existiendo la posibilidad, ésta

es menor que en el modelo original.

Por otro lado, aunque está versión rara vez se queda atrapado en óptimos locales,

está probado experimentalmente que necesita más iteraciones, de media, que el

PSO estándar para cumplir el mismo criterio de nivel de error. Por ello se puede

decir que la versión local parece funcionar peor que el algoritmo general.

3.5.2 Modelo Binario Discreto, DPSO

El PSO ajusta las trayectorias de sus partículas a lo largo del espacio del problema

en función de la mejor solución previa de cada partícula y la mejor del conjunto.

La versión estándar opera en un espacio continuo (de números reales), donde las

trayectorias se definen como cambios en la posición (en un número de

dimensiones que están representadas por las D coordenadas del vector 𝑥𝑖).

El caso, es que muchos problemas de optimización poseen un espacio discreto de

búsqueda (no utilizan variables continuas, sino que cuentan con niveles de

variables). Los típicos ejemplos son aquellos que requieren el orden u organización

de elementos discretos, como en el problema que nos concierne a nosotros, el

ATSP.

Es la razón anterior, junto con el hecho de cualquier problema, discreto o continuo,

puede ser expresado en notación binaria, las que hacen que un optimizador que

opere con funciones de dos valores (binarias) parezca ventajoso. Esto propulsó el

desarrollo de esta versión: el algoritmo de Optimización por Enjambre de Partículas

Discreto, DPSO.

En esta versión (Kennedy y Eberhart, 1997) el algoritmo opera con variables

binarias discretas (solo pueden tomar el valor 1 o el valor 0).


59

Y dado que el PSO general trabaja ajustando trayectorias a través de la

manipulación de cada coordinada (dimensión del espacio) de la partícula y algunos

de los éxitos del algoritmo son derivados de que sobrevuela óptimos locales

conocidos, explorando más allá de ellos y entre ellos, conceptos claves a

desarrollar en este modelo son, cómo tratar en un espacio discreto la trayectoria, la

velocidad, la exploración “entre y más allá”…

En el espacio binario una partícula puede moverse de la esquina más cercana a la

más lejana del espacio cambiando diversos números de bits. La velocidad de la

partícula en conjunto puede ser descrita por el número de bits cambiados por

iteración, es decir, la velocidad de una partícula podría ser una secuencia de

operadores de intercambio o permutaciones. Una partícula con 0 bits cambiados

no se mueve, mientras que el movimiento más lejano se da cuando se cambian

todas las coordinadas binarias (bits).

Hay que definir la velocidad como cambios de las probabilidades de que un bit

(coordenada de los vectores) de 𝑥𝑖 de tome un estado o el otro.

Cada coordenada de 𝑣𝑖 representa la probabilidad de que su bit correspondiente

en 𝑥𝑖 tome el valor 1. (Sí para cierta coordenada 𝑣𝑖=0.04, hay un 40% de

posibilidades de que su bit en 𝑥𝑖 sea 1, y un 60% de que sea 0).

La fórmula de la velocidad (aplicable a cada coordenada de cada partícula) se

mantiene sin cambios, excepto por el hecho de que ahora 𝑝𝑖, 𝑥𝑖 y 𝑔 son enteros en

{1, 0} y, teniendo en cuenta que 𝑣𝑖 es una probabilidad, su valor debe estar en el

intervalo [0’0, 1’0]. Su aspecto es el siguiente:

𝑣𝑖 = α*𝑣𝑖 + β*rand()*(𝑝𝑖 - 𝑥𝑖) + γ*rand()*(𝑔 - 𝑥𝑖)

En cuanto a la actualización de 𝑥𝑖, una transformación logística S(𝑣𝑖) puede ser

usada para lograr esta última modificación del modelo. S() es una transformación

sigmoidea que se aplica del siguiente modo:

𝑆(𝑋) = 1

1 + exp (−𝑋)

El cambio resultante en la posición es definido por la siguiente regla, donde rand()

es un número aleatorio seleccionado de una distribución uniforme [0.0, 1.0] :

Si(rand()<S(𝑣𝑖)); entonces 𝑥𝑖 = 1; sino 𝑥𝑖 = 0

Al igual que en el caso continuo se limitaba 𝑣𝑖 con un 𝑣𝑚𝑎𝑥 (parámetro del sistema),

en el caso discreto también se hace de modo que |𝑣𝑖|<𝑣𝑚𝑎𝑥, pero esto

simplemente limita la probabilidad última de que el bit 𝑥𝑖 tome como valor un 0 o


60

un 1, es decir, si 𝑣𝑚𝑎𝑥 = 6.0, entonces las probabilidades de S(𝑣𝑖) se limitarán entre

0,9975 y 0,0025 (probabilidades resultantes cuando se utilizan las velocidades

extremas 6 y -6).

Especificar un valor alto de 𝑣𝑚𝑎𝑥 hace a los nuevos vectores menos prometedores.

Parte de la función de 𝑣𝑚𝑎𝑥 en el DPSO es fijar un límite a la exploración adicional

una vez que la población haya convergido.

Cuando 𝑣𝑚𝑎𝑥 era alto en el problema continuo significaba que aumentaba el rango

explorado por la partícula, en la versión binaria ocurre lo contrario, bajos 𝑣𝑚𝑎𝑥

permiten mayores tasas de mutación.

Originalmente las trayectorias se ajustaban alterando la velocidad (o tasa de

cambio de posición) según:

𝑥𝑖 = 𝑥𝑖 + 𝑣𝑖.

En la presente versión discreta binaria, dado que 𝑣𝑖 funciona como un umbral de

probabilidad, los cambios en 𝑣𝑖 podrían representar un cambio de posición en sí

mismo (no tiene en cuenta la posición anterior a la hora de actualizar 𝑥𝑖, sino que

solo tiene en cuenta la velocidad):

Si(rand()<S(𝑣𝑖)); entonces 𝑥𝑖 = 1; sino 𝑥𝑖=0.

A medida que S(𝑣𝑖 ) se aproxima a cero, entonces la posición de la partícula se fija

más probablemente en el valor 0.

La trayectoria en el modelo binario es probabilística y la velocidad, en una sola

dimensión, es la probabilidad de que un bit de 𝑥𝑖 cambie; por lo que aunque 𝑣𝑖

deba permanecer fijo (según la fórmula de la velocidad 𝑣𝑖 permanece fijo cuando 𝑥𝑖

= 𝑝𝑖 = 𝑔), la “posición” de la partícula en esa dimensión es dinámica ya que cambia

la polaridad (de 1 a 0 y viceversa) con la probabilidad dependiente del valor 𝑣𝑖 .

La probabilidad de que un bit sea 1 es S(𝑣𝑖 ) y la probabilidad de que sea 0 es (1 –

S(𝑣𝑖 )). Por tanto las probabilidades de cambio son:

- Si el bit ya está en 0, la probabilidad de cambio es S(𝑣𝑖 )

- Si el bit tiene valor 1, la probabilidad de cambio es (1 – S(𝑣𝑖 )).

Esto hace que la probabilidad de que un bit cambie, p(Δ), (siendo ésta un ratio de

cambio absoluto, no direccional para un bit) dado el valor 𝑣𝑖 de su coordenada es:

p(Δ)= S(𝑣𝑖 )*(1 - S(𝑣𝑖 )) = S(𝑣𝑖 )- S(𝑣𝑖 )²


61

En conclusión podríamos decir que el mayor cambio de esta versión es que los

miembros de la población no son vistos como soluciones potenciales, sino que son

probabilidades.

El valor 𝑣𝑖 para cada dimensión determina la probabilidad de que el bit 𝑥𝑖 de esa

dimensión tome un valor u otro, pero 𝑥𝑖 por sí mismo no tiene valor hasta que no

es evaluado (la actual posición de la partícula en el espacio d-dimensional es

efímera). Una partícula individual i con su particular 𝑣𝑖 podría tener una posición

diferente 𝑥𝑖 en cada iteración.

Esto no ocurre en la versión general del PSO donde los individuos son una

representación de una solución potencial al problema. Cada individuo es evaluado,

actualizado y vuelto a analizar.

En el capítulo siguiente se explicará de forma detallada la aplicación del algoritmo

DPSO al problema específico ATSP y se analizarán sus resultados experimentales.


62


63

4. IMPLEMENTACIÓN Y EXPERIMENTACIÓN

Este capítulo comienza con la explicación, de forma teórica, de la manera elegida

para implementar el método PSO al problema ATSP, es decir, la forma de resolver

una instancia dada del ATSP, mediante la aplicación de un algoritmo basado en la

Optimización por Enjambre de Partículas.

De forma paralela al desarrollo de este documento, hemos programado un

algoritmo en lenguaje C++, que lo que hace es resolver una instancia del ATSP

mediante la realización de unos pasos concretos que están fundamentados en el

algoritmo PSO, o dicho de otro modo, hemos puesto en práctica la implementación

anteriormente mencionada, obteniendo así un algoritmo capaz de encontrar una

solución aceptable a cualquier problema ATSP (o STSP ya que es un caso particular

del ATSP) al que se aplique.

Para el desarrollo del algoritmo hemos utilizando el programa CodeBlocks, que es

un entorno de desarrollo integrado (posee editor del código fuente, depurador y

constructor entre otras cosas) y libre para el desarrollo de programas en lenguaje C

y C++.

Los pasos que se han llevado a cabo para construir el programa o algoritmo serán

explicados en detalle en el segundo apartado de este capítulo.

En el momento en que acabamos de construir el programa, éste fue utilizado para

resolver 19 problemas ATSP de la librería TSPLIB. Los resultados de las ejecuciones

del programa, así como el enunciado y las variables utilizadas en cada caso se

muestran en el apartado “resultados experimentales”.

Para concluir el capítulo, se muestra y comenta el análisis estadístico llevado a

cabo sobre los resultados experimentales obtenidos por el programa.

4.1 Aplicación de la metaheurística PSO al problema TSP

En este documento lo que pretendemos es utilizar el PSO para resolver el problema

del TSP, por lo que el método debe de buscar soluciones en un espacio de

búsqueda discreto.

Para ello necesitamos adaptar el PSO original, que trabaja con espacios continuos,

y lo haremos utilizando variables discretas. En los últimos años, varios científicos

han hecho versiones para utilizar el PSO en problemas de optimización discretos,

los primeros autores que propusieron el DPSO fueron Kennedy y Eberhart, cuyo


64

modelo es que se ha utilizado como base en este trabajo para explicar el apartado

3.5.2.

En el desarrollo de nuestro programa vamos a tener en cuenta, tanto el

fundamento de la versión DPSO de Kennedy y Eberhart como el DPSO desarrollado

por Huilian Fan (Fan, 2010).

Partiendo de la base de que en nuestro problema ATSP tenemos n ciudades, la

posición actual de cada partícula que forma el enjambre está establecida por el

vector 𝑥𝑖 donde la secuencia 𝑥𝑖1, 𝑥𝑖2, 𝑥𝑖3, … , 𝑥𝑖𝑛, 𝑥𝑖(𝑛+1) indica la trayectoria seguida

por la partícula i (la ciudad 𝑥𝑖1 es la que visita en primer lugar, luego va a la ciudad

𝑥𝑖2...). Un ejemplo muy sencillo de cómo se representa 𝑥𝑖 es el que se muestra en

la figura 8, donde la ciudad de partida es la 1. El vector es de tamaño n+1 porque

la trayectoria debe de ser un ciclo, es decir, tiene que acabar en la misma ciudad

que empezó (𝑥𝑖1 = 𝑥𝑖(𝑛+1)).

Figura 8. Vector de la posición actual de la partícula i. Elaboración propia.

Los vectores 𝑝𝑖 y el vector g se representan del mismo modo que 𝑥𝑖.

En nuestra versión redefiniremos la velocidad (entendiéndola como la responsable

del movimiento o actualización de las partículas), inspirándonos en el operador de

permutación (“Swap Operator”). Para ello, añadimos la operación de cruce, la de

inyección o la inversa y el factor de adaptación al ruido. Estas operaciones van a

ser las responsables de la actualización de las partículas en cada iteración.

A continuación vemos el diagrama de flujo del algoritmo y la explicación de los

pasos que lo componen, incluido el funcionamiento de las operaciones ya

mencionadas.

4.1.1 Pasos del algoritmo

En el figura 9 se muestra esquemáticamente el diagrama de flujo que vamos a

seguir para implementar el PSO al ATSP. Posteriormente explicaremos cada uno de

los pasos del algoritmo.

4

5 6

7

1 3

2

𝑥𝑖 = {1, 3, 5, 7, 2, 4, 6, 1}

𝑖


65

Figura 9. Pasos para la implantación del método PSO al ATSP. Elaboración propia.

11. Imprimir 𝑔 y 𝐺𝑏𝑒𝑠𝑡 y finalizar algoritmo.

SI

NO

1. Inicializar el algoritmo.

2. Calcular Fitness.

3. Actualizar 𝑝𝑖 y 𝑃𝑏𝑒𝑠𝑡𝑖 iniciales.

4. Actualizar 𝑔 y 𝐺𝑏𝑒𝑠𝑡 iniciales.

5. Empieza la iteración t.

6. Creación de la nueva población mediante:

a. Operación de cruce xi′(t).

b. Operación Inyección||Inversa xi(t + 1)′.

c. Operación del ruido xi(t + 1).

7. Calcular Fitness.

8. Actualizar 𝑝𝑖 y 𝑃𝑏𝑒𝑠𝑡𝑖.

9. Actualizar 𝑔 y 𝐺𝑏𝑒𝑠𝑡.

10. ¿Se satisface el criterio de parada?


66

En el primer paso hay que inicializar el algoritmo, asignando valores fijos a algunas

variables, pidiéndolos por pantalla al usuario o incluso generándolos según algún

procedimiento establecido. La diferencia entre establecer un valor o pedirlo es, que

si lo asigna el programador ese valor va a ser constante para el programa (queda

establecido internamente) independientemente de que sea una instancia u otra,

mientras que si el valor se pide por pantalla, el usuario decide cada vez que ejecute

del programa qué valor le quiere asignar. En el algoritmo debemos inicializar:

- La matriz de distancias utilizando los datos que nos ofrece el enunciado.

- Número de partículas que forma la población. Nuestro programa está

diseñado para pedir el valor por pantalla, dado que no sabemos cuál es la

elección óptima y así se puede ir variando para ver con cuál funciona mejor.

- Ciudad de partida de las partículas. También es un dato pedido al usuario,

puesto que en muchos enunciados no viene establecida. Nótese que la

ciudad de partida no afecta al resultado del problema porque es un ciclo

Hamiltoniano, esta variable sólo afecta a la percepción visual del vector a la

hora de mostrar el resultado.

- Longitud de cruce (m), es un valor constante para cada ejecución que

determina el funcionamiento de los operadores que utilizaremos para

actualizar la población. Se pide al usuario, porque, al igual que ocurre con el

número de partículas, no conocemos su valor óptimo.

- Número de iteraciones que debe realizar el algoritmo antes de su

finalización. El número de iteraciones máximas es el criterio de parada que

nosotros hemos elegido y también se pide su valor al usuario.

- Hay que generar el recorrido inicial xi para cada partícula, que comenzará y

acabará por la ciudad de partida, siendo el resto de la secuencia de su

trayectoria elegida al azar.

- Tras establecer xi, asignamos valores a pi, que en el caso de la inicialización

son una copia exacta de la posición inicial. Además la distancia de dichas

trayectorias se guardan en su correspondiente Pbesti.

- Otorgamos a g la trayectoria pi de la partícula i que haya obtenido mejor

Pbesti. Ese mismo valor Pbesti se le asigna a la variable Gbest.

El segundo paso es análogo al paso 7, lo que hay que hacer en ambos es calcular

la distancia total que implica la trayectoria xi de cada partícula (a esa distancia

también se le conoce como fitness y es el valor que se quiere minimizar en la


67

función objetivo). Para ello utilizamos la matriz de distancias y la secuencia de esa

trayectoria y sumamos la distancia que hay de cada ciudad a la ciudad siguiente

según esa secuencia, de modo que al final obtenemos la distancia total del ciclo

recorrido por la partícula. Ese valor se almacena para utilizarlo en comparaciones

venideras.

Los pasos número 3 y 8 lo que hacen es actualizar el vector 𝑝𝑖 y 𝑃𝑏𝑒𝑠𝑡𝑖 de cada

partícula. Para ello lo que se hace es comparar el valor del fitness de xi calculado

en el paso anterior, con el 𝑃𝑏𝑒𝑠𝑡𝑖. Si la distancia total de la trayectoria xi (fitness)

es menor que 𝑃𝑏𝑒𝑠𝑡𝑖, se actualiza 𝑝𝑖 asignándole la trayectoria de 𝑥𝑖 ya que es

mejor que la mejor encontrada hasta el momento y se otorga a 𝑃𝑏𝑒𝑠𝑡𝑖 el valor del

fitness de xi, en caso contrario no se modifican ni 𝑝𝑖, ni 𝑃𝑏𝑒𝑠𝑡𝑖.

En los pasos 4 y 9 se actualizar la trayectoria del vector g y su valor Gbest. El modo

de hacerlo es comparar el valor 𝑃𝑏𝑒𝑠𝑡𝑖 de cada partícula con el valor Gbest. Si

alguna partícula posee un 𝑃𝑏𝑒𝑠𝑡𝑖 menor que Gbest, entonces se actualiza el vector

g con la trayectoria 𝑝𝑖 de dicha partícula y Gbest pasará a tener el valor de 𝑃𝑏𝑒𝑠𝑡𝑖.

En caso de que varias partículas posean mejor fitness que el valor de Gbest, se

escogería aquella que tuviese mejor 𝑃𝑏𝑒𝑠𝑡𝑖, es decir, el más pequeño. Y en el caso

en que ninguna partícula mejore la trayectoria de g, se queda tanto el vector g,

como la variable Gbest igual que estaban.

En el paso 5 comienza la iteración, por lo que si se trata de la primera (venimos del

paso 4) t=1, y en el caso de que vengamos del paso 10, la t se va incrementando

(cada vez que vuelve al paso 5) indicándonos en que iteración nos encontramos.

El paso 6 de creación de una nueva población (actualización las 𝑥𝑖), lo que se hace

es obtener una nueva posición actual para las partículas mediante la aplicación de

la operación de cruce, la inyecta o inversa y la operación de ruido. Estas

operaciones serán explicadas detalladamente en los siguientes sub-apartados.

En el paso 10 lo que hacemos es evaluar el criterio de parada para saber si

debemos de seguir iterando o si debemos finalizar el algoritmo. Para ello lo que se

hace es comprobar si la iteración t en la que nos encontramos es igual o mayor que

el número de iteraciones máximas que tenemos del paso 1.

- Si el criterio de parada no se satisface (no se ha llegado aún al número de

iteraciones máximas establecido), se volverá al paso 5 para empezar una

nueva iteración.

- Si t es igual o mayor que tmax, se satisface el criterio de parada por lo que

pasaríamos al último paso, el 11.


68

Este último paso consiste en imprimir el vector g y el valor Gbest (es el resultado de

nuestro problema, que nos indica la mejor trayectoria encontrada y la distancia que

implica) y posteriormente se terminaría la ejecución del algoritmo.

A continuación explicaremos en qué consisten las operaciones de cruce, de

inyección, de inversión y de adaptación al ruido, para entender mejor el modo en

que se actualizan las partículas que forman la población.

4.1.1.1 Operación de cruce

Partiendo de la posición actual xi de cada partícula, lo que hace la operación de

cruce es intercambiar algunos de sus coordenadas obteniendo la posición xi′

mediante la siguiente fórmula:

xi′(t) = xi(t) ((c1 × r1) pi(t)) ((c2 × r2) g(t))

Donde t es el número de iteraciones del algoritmo, xi(t) es el ciclo que hace la

partícula i en la iteración t, pi(t) es el mejor ciclo encontrado por la partícula i hasta

la iteración t y g(t) es la mejor trayectoria encontrada por todo el conjunto hasta el

momento t.

Los valores m1 = (c1 × r1) y m2 = (c2 × r2) representan las longitudes de cruce,

m1 representa el número de ciudades (coordenadas del vector) que se cruzan entre

xi y pi(t), y Por otro lado m2 indica la cantidad de ciudades que se Cruzan entre el

vector resultante de hacer el cruce anterior y g(t).

Los valores óptimos de m1 y m2 los desconocemos por lo que queda como tema

pendiente a ser estudiado en un futuro. En este trabajo hemos asumido que m1 =

m2 = m y que es constante para todo el algoritmo, siendo la m una variable que se

pide por pantalla al usuario del programa. En la experimentación probaremos con

varios (siempre que no sea mayor que n, ya que si es n se copia completamente un

vector en otro).

es el operador de cruce que funciona de la siguiente manera, partiendo de xi(t)

= {xi1t , xi2

t , … , xi(n+1)t } y pi(t) = {pi1

t , pi2t , … , pi(n+1)

t } la operación de cruce es:

𝑥i(t) pi(t) = {xi1t , pi(k+1)

t , pi(k+2)t , … , pi(k+m)

t , xil t , xi(l+1)

t , … , xi(n+1)t }

Donde k un número entero aleatorio [1, n-1] que se halla cada vez que se realiza

una operación de cruce y xil t , xi(l+1)

t ,… significa que se cogen todas las posiciones


69

de la trayectoria xi(t), en orden, que no hayan sido cogidas ya de pi(t), es decir, que

no estén en (pi(k+1)t , … , pi(k+m)

t ) puesto que no se pueden repetir ciudades.

La operación de cruce hay que realizarla en orden, en primer lugar se cruza 𝑥i(𝑡)

con pi(t) y después el resultado obtenido del cruce anterior, se cruza con g(𝑡),

obteniendo xi′.

Nótese además que la ciudad de partida y la de llegada no se cambian, todas las

operaciones se realizan sobre el resto de coordenadas. Además en caso de que

k+m resulte ser mayor que n, lo que se hace es coger desde k hasta n (inclusive) y

se siguen cogiendo las que falten a partir de la segunda coordenada.

Dada m = 5 y las posiciones de la partícula i, 𝑥𝑖(𝑡) = {1, 8, 7, 3, 2, 6, 9, 4, 5, 1}, 𝑝𝑖(𝑡)

= {1, 7, 3, 2, 4, 6, 9, 8, 5, 1} y g(𝑡) = {1, 4, 8, 6, 7, 2, 9, 5, 3, 1}, un ejemplo de su

operación de cruce completa es:

- Se halla k k = 2 𝑝𝑖(𝑡) = {1, 7, 3, 2, 4, 6, 9, 8, 5, 1} 𝑥𝑖(𝑡) 𝑝𝑖(𝑡) =

{1, 3, 2, 4, 6, 9, 8, 7, 5, 1}

- Se halla de nuevo k k = 6 g(𝑡) = {1, 4, 8, 6, 7, 2, 9, 5, 3, 1} xi′(t) =

{1, 9, 5, 3, 4, 8, 2, 6, 7, 1}

4.1.1.2 Operación de inyección u operación inversa

En esta operación lo que hacemos es realizar una serie de permutaciones sobre la

posición xi′ obtenida en el paso anterior. La operación se representa así:

xi(t + 1)′ = Inyección (xi′(𝑡), Vc) || Inversa (xi

′(𝑡), s, e)

Lo que significa || es que para cada partícula sólo se realiza una operación, o la

inyección o la inversa, cada una con una probabilidad del 50% de ser escogida.

Para determinar cuál de las dos se lleva a cabo lo que hacemos es hallar un

número aleatorio [1, 100] y si está por debajo de 50 se realiza la inyección y en

caso contrario se realizará la inversa. Estas operaciones consisten en:

- Operación de inyección

Para realizar esta operación partimos del vector xi′(t) y lo primer que se

hace es seleccionar el punto de inyección de entre todas sus coordenadas.

El método para hacerlo es el siguiente:

K+1 k+m

K+1 k+m


70

Hallar la probabilidad de selección para cada coordenada j de xi′(𝑡),

utilizando la fórmula: 𝑃𝑗 = 𝑑(xij′ , xi(j+1)

′ )/ ∑ 𝑑(xij′ , xi(j+1)

′ )𝑛𝑗=1 lo que

significa que la probabilidad de seleccionar la ciudad que está en la

ciudad que está en j como punto de inyección es igual a la distancia

que hay de esa ciudad a la siguiente (en la trayectoria xi′(t)), dividido

por la distancia total del recorrido xi′(t).

Lo que quiere decir que cuanto más lejos estén dos ciudades

consecutivas, más probabilidad hay de escoger la primera de ellas

como punto de inyección.

Después se halla la probabilidad acumulada, de cada coordenada y

se genera un número aleatorio. Dependiendo del valor de aleatorio,

se seleccionará una coordenada u otra según esas probabilidades

acumuladas. Esa coordenada será el punto de inyección y la ciudad

correspondiente (el valor de la coordenada) es la ciudad c.

Ahora que ya tenemos el punto de inyección, lo que hacemos es calcular el

vector Vc = {𝑣𝑐1, 𝑣𝑐2

, … , 𝑣𝑐𝑚}, que es la secuencia que indica la ciudad más

cercana para cada ciudad, tomando como partida la ciudad c. Dicho de otro

modo, 𝑐1 es la más cercana a 𝑐 , 𝑐2es la más cercana a 𝑐1…la más cercana

a 𝑐𝑚 está entre 𝑐𝑚−1 y 𝑐1. La variable m es la longitud de cruce utilizada

también en la operación anterior (utiliza el mismo valor durante toda la

ejecución y es el mismo para una operación que para la otra).

Partiendo del vector xi′(t) y del Vc = {𝑣𝑐1

, 𝑣𝑐2, … , 𝑣𝑐𝑚

} calculado, se hace la

operación de inyección en dos pasos:

Inyección (𝑥𝑖’(t), Vc) = {𝑥𝑖1, 𝑥𝑖2, … , c, 𝑣𝑐1, 𝑣𝑐2

, … , 𝑣𝑐𝑚, … , 𝑥𝑖(𝑛+1)}

Eliminar todas las ciudades 𝑥𝑖𝑗 que estén repetidas, es decir quitar

las ciudades correspondientes al vector Vc.

A continuación se muestra un ejemplo de una operación de inyección para

m = 5, la posición anterior hallada en el cruce xi′(t)= {1, 9, 5, 3, 4, 8, 2, 6, 7,

1} y 𝑉5={8, 3, 7, 4, 9} :

Inyección (𝑥𝑖’, 𝑉5) = {1, 9, 5, 8, 3, 7, 4, 9 3, 4, 8, 2, 6, 7, 1}

Inyección (𝑥𝑖’, 𝑉5) = {1, 9, 5, 8, 3, 7, 4, 9 3, 4, 8, 2, 6, 7, 1} = {1, 5, 8, 3, 7,

4, 9, 2, 6, 1} = xi(t + 1)′

- Operación inversa


71

Partimos de vector xi′(t) que obtuvimos en la operación de cruce y de dos

números, s y e, aleatorios entre [2, n] (para evitar cambiar la ciudad de

partida y llegada) cuya única condición es que e sea mayor que s.

La operación consiste en invertir el intervalo de coordenadas, que van

desde la coordenada de la posición s hasta la de la posición e, del vector

xi′(t) de partida. Se hace de la siguiente forma:

Dado 𝑥𝑖’ = {𝑥𝑖1, 𝑥𝑖2, … , 𝑥𝑖𝑠, 𝑥𝑖(𝑠+1), … , 𝑥𝑖(𝑒−1), 𝑥𝑒 , … , 𝑥𝑖(𝑛+1)}

Reverse (𝑥𝑖’, s, e) = { 𝑥𝑖1, 𝑥𝑖2, … , 𝑥𝑖𝑒 , 𝑥𝑖(𝑒−1), … , 𝑥𝑖(𝑠+1), 𝑥𝑠, … , 𝑥𝑖(𝑛+1)}

Un ejemplo de operación inversa para xi′(t) = {1, 9, 5, 3, 4, 8, 2, 6, 7, 1} es:

Se generan dos número aleatorios s = 3 y e = 7 xi′(t) =

{1, 9, 5, 3, 4, 8, 2, 6, 7, 1}

Reverse (𝑥𝑖’, 3, 7) = {1, 9, 2, 8, 4, 3, 5, 6, 7, 1} = xi(t + 1)′

4.1.1.3 Operación de adaptación al ruido

Esta operación parte del vector 𝑥𝑖(𝑡 + 1)′ generado por la operación

inyecta||inversa y su modo de actuar depende de la diversidad, entendiendo por

diversidad a la similitud que existe entre las diferentes posiciones, 𝑥𝑖(𝑡 + 1)′, 𝑝𝑖(𝑡)

y g(𝑡) de la partícula, denotado por 𝑑𝑖𝑣𝑒𝑟𝑠𝑖𝑑𝑎𝑑𝑖. La operación es:

𝑥𝑖(𝑡 + 1) = 𝜂 × 𝑑𝑖𝑠𝑡𝑢𝑟𝑏(𝑥𝑖 (𝑡 + 1)′, 𝑘)

La variable 𝜂 es binaria [0, 1] y hay que calcularla en función de la diversidad de la

siguiente manera:

- En primer lugar hay que hallar la 𝑑𝑖𝑣𝑒𝑟𝑠𝑖𝑑𝑎𝑑𝑖 siguiendo los pasos:

Hallamos las similitudes 𝑠𝑥𝑖(𝑡+1)′,𝑝𝑖(𝑡), 𝑠𝑥𝑖(𝑡+1)′,g(𝑡) y 𝑠𝑝𝑖(𝑡),g(𝑡) que hay

entre las diferentes posiciones de la partícula, teniendo en cuenta

que 𝑆𝑖𝑗 es la similitud que hay entre i y j. La similitud se calcula así:

𝑆𝑖𝑗 =1

(𝑛−1)∑ 𝛿 → 𝑠𝑖(𝑥𝑖𝑘 == 𝑥𝑗𝑘); 𝛿 = 1; 𝑠𝑖𝑛𝑜 𝛿 = 0𝑛

𝑘=2 , lo que

quiere decir que se compara cada coordenada, k, de los vectores i y

j, y si coinciden 𝛿 vale 1, luego hace la media de todos los 𝛿,

obteniendo 𝑆𝑖𝑗 en un intervalo de [0.0, 1.0].

En nuestro caso, por poner un ejemplo, 𝑠𝑥𝑖(𝑡+1)′,𝑝𝑖(𝑡), será un valor

entre 0 y 1, que en el caso de que valiese 0,8 quiere decir que el

80% de las ciudades que forman el problema son recorridas en la

s e

e s


72

misma posición de la trayectoria 𝑥𝑖(𝑡 + 1)′, y de la trayectoria 𝑝𝑖(𝑡).

Si valiera 1, significaría que la trayectoria 𝑥𝑖(𝑡 + 1)′, y la trayectoria

𝑝𝑖(𝑡) son exactamente iguales.

Finalmente calculamos la diversidad de la partícula i con la fórmula:

𝑑𝑖𝑣𝑒𝑟𝑠𝑖𝑑𝑎𝑑𝑖 =1

3(𝑠𝑥𝑖(𝑡+1)′,𝑝𝑖(𝑡) + 𝑠𝑥𝑖(𝑡+1)′,g(𝑡) + 𝑠𝑝𝑖(𝑡),g(𝑡)).

- Asignamos el valor a 𝜂 de la siguiente manera:

Si 𝑑𝑖𝑣𝑒𝑟𝑠𝑖𝑑𝑎𝑑𝑖 < 0,4; entonces 𝜂 = 1

Si 𝑑𝑖𝑣𝑒𝑟𝑠𝑖𝑑𝑎𝑑𝑖 ≥ 0,4; entonces 𝜂 = 0

Esto quiere decir que si la diversidad ≥ 0,4, significa que la posición

𝑥𝑖(𝑡 + 1)′ es muy parecida a 𝑝𝑖(𝑡) y g(𝑡) y las dos últimas parecidas entre

ellas también, por eso no se aplica la operación de ruido (𝜂 = 0), para no

cambiar la partícula ya que es de las mejores de la población.

La operación 𝑑𝑖𝑠𝑡𝑢𝑟𝑏(𝑥𝑖 (𝑡 + 1)′, 𝑘), donde k es un número entero aleatorio que

generamos entre [2, n] y 𝑥𝑖𝑘′ es la ciudad más cercana a 𝑥𝑖𝑘 que tenemos que

calcular, funciona de la siguiente forma:

Dado 𝑥𝑖(𝑡 + 1)′= {𝑥𝑖1, 𝑥𝑖2, … , 𝑥𝑖𝑘, … , 𝑥𝑖(𝑛+1)}

disturb(𝑋𝑖’, k)= {𝑥𝑖1, 𝑥𝑖2, … , 𝑥𝑖𝑘′, … , 𝑥𝑖(𝑛+1)}, y donde estaba 𝑥𝑖𝑘′ ponemos 𝑥𝑖𝑘

Esto quiere decir que la operación de ruido consiste en intercambiar la ciudad que

está en la coordenada k, por la ciudad más próxima a ella, si y sólo si hay poca

similitud entre la trayectoria de la partícula y los las trayectorias óptimas. Tras

realizar la operación de diversidad obtenemos 𝑥𝑖(𝑡 + 1) que es la nueva posición

actual de la partícula que utilizaremos como 𝑥𝑖(𝑡) en la siguiente iteración y

coincidirá con 𝑥𝑖(𝑡 + 1)′ en caso de que 𝜂 = 0.

Un ejemplo de una operación de ruido para xi(t + 1)′ = {1, 9, 2, 8, 4, 3, 5, 6, 7, 1},

𝑝𝑖(𝑡) = {1, 7, 3, 2, 4, 6, 9, 8, 5, 1} y g(𝑡) = {1, 4, 8, 6, 7, 2, 9, 5, 3, 1}, es el siguiente:

- En primer lugar se calcula la similitud entre cada una de esas posiciones

(sin tener en cuenta la ciudad de partida y llegada porque es constante)

contando cuantas coordenadas coinciden.

𝑠𝑥𝑖(𝑡+1)′,𝑝𝑖(𝑡) = 1/8 = 0,125. Como vemos, sólo coincide la ciudad 4.


73

𝑠𝑥𝑖(𝑡+1)′,g(𝑡) = 0/8 = 0. No hay ciudades en la misma posición.

𝑠𝑝𝑖(𝑡),g(𝑡) = 1/8 = 0,125. Sólo coincide la ciudad 9 en 7ª posición.

- Hallamos la diversidad de la partícula y con ello 𝜂:

𝑑𝑖𝑣𝑒𝑟𝑠𝑖𝑑𝑎𝑑𝑖 =1

3 (0,125 + 0 + 0,125) = 0,083 <0,4 𝜂 = 1

- Realizamos la operación de ruido:

Generamos un número aleatorio k = 6, en la posición 6 está la

ciudad 3 supongamos que la ciudad más cercana a la 3 es la 9.

𝑥𝑖(𝑡 + 1) = 1 × 𝑑𝑖𝑠𝑡𝑢𝑟𝑏(𝑥𝑖 (𝑡 + 1)′, 𝑘) = {1, 3, 2, 8, 4, 9, 5, 6, 7, 1}.

Ahora que ya sabemos cómo queremos realizar el programa, de forma teórica, en el

siguiente apartado exponemos como se llevaron a la práctica este conjunto de

pasos.

4.2 Algoritmo desarrollado

El algoritmo lo hemos desarrollado en el lenguaje de programación C++, utilizando

para ello el entorno de desarrollo CodeBlocks (tomado de la web [11]).

El programa internamente funciona llamando a funciones, es decir desde el

archivo principal (main) se van nombrando las funciones o procedimientos que

están definidas en otros archivos que forman el programa y se ejecutan.

En nuestro caso utilizaremos tres archivos diferenciados:

- El principal fichero principal, también conocido como main, es donde vamos

diciendo al programa los pasos de debe ir haciendo, uno tras otro.

- La clase Fichero está compuesta por varios procedimientos y funciones que

sirven para cargar los datos que nos ofrece el enunciado del problema y

guardarlos en variables y matrices para su posterior utilización.

- Finalmente la clase Algoritmo, posee las funciones y los procesos

necesarios para la implementación del PSO al ATSP, es decir, está

compuesta de todos los procedimientos necesarios para generar una


74

solución (e imprimirla), a partir de los de los datos del problema que le

proporción la clase Fichero.

El programa crea tres ficheros de salida de extensión “.txt” con los siguientes

valores:

- “RESULTADO.txt” almacena el nombre del enunciado y el resultado final

Gbest de la ejecución completa.

- “VariablesUtilizadas.txt” tiene guardadas todas las variables que

establece el usuario para cada ejecución del programa y tiene el

aspecto que vemos en la figura 10.

Figura 10. “VariablesUtilizadas.txt”. Elaboración propia.

- “SalidaCompletaResultados.txt” tiene almacenadas todas las variables

que establece el usuario, igual que en el apartado anterior, pero

además posee:

La matriz de distancias del problema

El recorrido actual de cada partícula en la iteración inicial, así

como los recorridos 𝑝𝑖 y el mejor de ellos, el 𝑔. Todos los

recorridos se muestran con sus respectivos fitness.

Para cada iteración de la ejecución se muestra la trayectoria 𝑔

obtenida y su distancia total, Gbest.

Para concluir el fichero se ponen los recorridos 𝑥𝑖 y 𝑝𝑖 para cada

partícula y el recorrido final 𝑔 con sus respectivos valores.

Las variables más importantes que utiliza el algoritmo son las que están descritas a

continuación:

- Cadena “nombreFichero” donde se almacena el enunciado que hay que

resolver.


75

- Variable “dimension” (n) que almacena la cantidad de ciudades que

posee la instancia que estamos resolviendo.

- Matriz “distancias[i][j]” de tamaño (n x n), donde está recogida la

distancia que hay de la ciudad cada ciudad i a cada ciudad j.

- La variable “particulas” indica el número de individuos que forman la

población.

- La variable “ciudadPartida” es la ciudad de la que parte el agente

viajero y a la que debe volver.

- “m” es la longitud de cruce, que nos sirve para determinar, tanto el

funcionamiento de la operación de cruce, como el de la de inyección.

- “iteracionesMax” establece el criterio de parada, en ella se almacena la

cantidad de iteraciones que debe de hacer el programa hasta detenerse

y dar la solución.

- La variable “t” almacena la iteración actual en la que se encuentra el

algoritmo, está será la que se compare con “iteracionesMax” para

comprobar si se ha cumplido el criterio de parada.

- La matriz “recorridoActual [i][j]” es de tamaño (partículas x (n+2)), donde

las filas son las partículas que forman la población y en las columnas de

[1] a [n+1] ponemos la trayectoria actual 𝑥𝑖 que sigue la partícula i,

reservando la última posición ([n+2]) para almacenar el fitness que

supone esa trayectoria.

- “recorridoPbest [i][j]” está estructurada igual que la anterior, solo que en

este caso en vez de guardar el recorrido actual de las partículas, se

guarda el mejor recorrido encontrado por la partícula i hasta el

momento, es decir de [1] a [n+1] tendremos 𝑝𝑖 y en [n+2] estará 𝑃𝑏𝑒𝑠𝑡𝑖.

- “recorridoGbest [j]” en este caso el recorrido se guarda en un vector,

donde j=n+2. El vector almacena en (n+1) columnas el recorrido g y el

Gbest en la [n+2], esto es lo mismo que decir que es una copia de una

fila de “recorridoPbest [i][j]”, concretamente de la fila i que posea el

mejor 𝑃𝑏𝑒𝑠𝑡𝑖.

- El vector “𝑥1[j]” lo utilizamos a lo largo del algoritmo como vector

auxiliar, para poder ir creando las nuevas posiciones de la partícula

paso a paso sin sobrescribir la matriz “recorridoActual [i][j]”, ya que


76

perderíamos su información. Es de tamaño (n+1) y lo que se hace es ir

almacenando la nueva trayectoria de la partícula i, que estamos

actualizando, generada por la operación en que nos encontremos (ya

sea cruce, inyección, inversión o ruido), y cuando ya esté completo el

vector se vuelca la información en “recorridoActual [i][j]” y pasamos a

hacer lo mismo para la siguiente partícula.

A continuación vamos a explicar, a grandes rasgos, la forma de proceder del

algoritmo, mostrando para ello la secuencia de pasos establecida en el main:

- Llamada al procedimiento “cargarFichero” del siguiente modo:

“fichero.cargarFichero”, donde “fichero.” significa que es un proceso de

la clase fichero. Si fuese “algoritmo.” significaría que el proceso está

declarado en la clase algoritmo.

En ese procedimiento lo que hacemos es pedir por pantalla al usuario

que introduzca el enunciado que quiere resolver y almacenar lo que

escribe en la cadena “nombreFichero”.

A continuación se abre el fichero, y de él se obtiene:

El número de ciudades que posee y lo guardamos en la variable

“dimensión”.

La matriz de distancias, que se almacena en “distancias[i][j]”.

- “fichero.mostrarMatriz” en este paso se imprime en el fichero de salida

“SalidaCompletaResultados.txt” la matriz de distancias obtenida en el

paso anterior y además se saca también por pantalla.

- “algoritmo.pedirDatos” el main llama así al procedimiento “pedirDatos”

de la clase Algoritmo donde se pide al usuario por pantalla:

El número de partículas que forma la población, que se

almacena en la variable “partículas”.

La ciudad de partida de la trayectoria. Su valor se almacena en

“ciudadPartida”.

La longitud de cruce que se guarda en la variable “m”.

El número de iteraciones máximas que determina cuándo va a

finalizar el algoritmo. Su valor se guarda en “iteracionesMax”.


77

Todos esos valore son imprimidos por pantalla y además se guardan en

los ficheros de salida “SalidaCompletaResultados.txt” y

“VariablesUtilizadas.txt”.

- Ejecutamos “algoritmo.generarInicial” donde se inicializan:

La matriz que almacena las trayectorias actuales de cada

partícula, “recorridoActual[i][j]”. Para ello ponemos la posición

[i][1] = [i][n+1] = “ciudadPartida” y el resto de las posiciones se

rellenan aleatoriamente entre las ciudades que no forman parte

aún de la trayectria.

La posición [i][n+2] almacena el fitness de la trayectoria que va

desde j=1 a j=n+1. Para ello sumamos las distancias que hay de

la ciudad [i][j] a [i][j+1], para j=1, 2, …, n

“recorridoPBest[i][j]”, en la primera iteración esta matriz es

exactamente igual que “recorridoActual[i][j]” por lo que copiamos

sus valores.

“recorridoGBest[j]”, para actualizarla comparamos los fitness

(posición [i][n+2]) de todas las partículas, hallando la que posee

menor valor. Después otorgamos a “recorridoGBest[j]” la

trayectoria “recorridoPBest[i][j]” (i= partícula con mejor valor).

- “algoritmo.mostrarGbest” este procedimiento lo que hace es imprimir

por pantalla y en el fichero “SalidaCompletaResultados.txt” el vector

“recorridoGBest[j]” completo, es decir, imprime g y su valor Gbest

(posición [i][n+2]).

- Comienzan las iteraciones partimos de t = 0 mientras

“t”<”iteracionesMax” t = t+1 {

“algoritmo.crucePbest” este paso realiza la operación de cruce

de “recorridoActual[i][j]” con “recorridoPbest[i][j]” para cada

partícula y el procedimiento es análogo al descrito en el apartado

4.1.1.1.

Para realizar la operación usamos el vector auxiliar 𝑥1(j).

Utilizamos este vector, en lugar de la matriz de recorrido actual,

para ir rellenando las nuevas posiciones una a una sin

sobrescribir la matriz original ya que perderíamos su trayectoria y

nos hace falta para acabar de rellenar el recorrido después de

poner los valores que se crucen de la matriz de recorrido Pbest.


78

Cuando ya tenemos el vector auxiliar completo actualizamos la

posición de la partícula “recorridoActual [i][j]” = 𝑥1[j].

“algoritmo.cruceGbest” es un procedimiento muy parecido al

anterior (es la segunda parte del apartado 4.1.1.1), donde

partimos de la trayectoria “recorridoActual [i][j]” que es la

consecuencia de aplicar el “crucePbest” y la cruzamos en este

caso con “recorridoGbest [j]”. Al terminar el proceso volvemos a

actualizar las partículas “recorridoActual [i][j]” = 𝑥1[j].

“algoritmo.InjectOrReverse” determina si se realiza la operación

de inyección o la de inversión. Para ello haya un número

aleatorio y si es menor que 51 llama realiza la operación de

inyección y en caso contrario la inversa.

Al igual que las operaciones de cruce, estas también utilizan el

vector 𝑥1[j] y su operación se realiza como se describe en

4.1.1.2. Cuando ya se ha concluido la operación se vuelca el

vector auxiliar en la matriz de recorrido actual de la partícula.

“algoritmo.Ruido” la llamada a este proceso hace que se realice

la operación de adaptación al ruido del modo descrito en 4.1.1.3

almacenando el resultado de dicha operación en 𝑥1[j]. Como ya

sabemos, dependiendo del valor de diversidad que obtengamos

algunas partículas se modificarán y otras (las más cercanas a los

puntos óptimos) no mutarán. Al finalizar el proceso para cada

partícula se almacena 𝑥1[j] en “recorridoActual [i][j]”.

“algoritmo.actualizarPbest”, este proceso está dividido en dos

etapas.

En primer lugar se calcula el fitness del recorrido actual de cada

partícula y se almacena en “recorridoActual [i][n+2]”.

Y en segundo lugar esa posición se compara con su análoga de

la matriz de recorrido 𝑃𝑏𝑒𝑠𝑡𝑖 y en caso de que sea mejor, se

sustituye “recorridoPbest [i][j]” por “recorridoActual [i][j]” para

dicha partícula, si fuera peor no se modificaría el recorrido Pbest.

“algoritmo.actualizarGbest”, este procedimiento es más simple

que el anterior porque ya tenemos calculado el fitness. Lo que se

hace es comparar el valor 𝑃𝑏𝑒𝑠𝑡𝑖 (obtenido en el paso anterior)

de cada partícula con el valor Gbest.


79

Si es mejor el 𝑃𝑏𝑒𝑠𝑡𝑖 de una partícula i que Gbest, entonces

“recorridoGbest [j]” = “recorridoPbest [i][j]”, en caso contrario

conservamos el Gbest que tenemos.

“algoritmo.mostrarGbest”

} Fin de la iteración. Si se sigue cumpliendo que “t”<”iteracionesMax”,

se realiza otra iteración y en caso de que se haya alcanzado el criterio

de parada pasamos al siguiente procedimiento.

- Se acaba la ejecución y se cierra el programa.

4.3 Resultados experimentales

Una vez el programa estuvo terminado, se pasó a evaluar su comportamiento

frente a 19 enunciados ATSP sacados del apartado “Asymmetric traveling salesman

problem” de la biblioteca TSPLIB [12], que contiene tanto los enunciados

mencionados (presentados como en la figura 11), como los mejores resultados

encontrados hasta el momento para esas instancias.

…

Figura 11. Enunciado del problema br17. [12].


80

En la tabla 4 se muestra el enunciado de cada uno de los 19 problemas ATSP de la

librería TSPLIB con su correspondiente dimensión y valor óptimo.

Tabla 4. Librería TSPLIB. Elaboración propia.

4.3.1 Parámetros utilizados

Para resolver cada una de las instancias se han tenido que seleccionar los

siguientes parámetros, que como ya dijimos, dejamos a elección del usuario debido

a la falta de conocimiento sobre su valor óptimo:

- Número de partículas: 50.

En este estudio hemos decidido establecer un valor fijo para el tamaño

de la población. La elección de un número pequeño de partículas está

fundamentada en el hecho de que, según parece, los algoritmos

iterativos avanzan más aumentando el número de iteraciones, que

aumentando el número de partículas, y puestos a elegir el modo de

distribución de nuestros recursos, elegimos poner este valor pequeño y

la cantidad de iteraciones grande para permitir una evolución mayor de

la solución, optimizando en lo posible el tiempo de ejecución.

- Ciudad de partida: 0.

Puesto que el enunciado no nos dice de qué punto debe partir la

trayectoria, y sabemos que el punto de partida no afecta a la solución

final por tratarse de un ciclo Hamiltoniano, ponemos este valor fijo

eligiendo para esta variable la primera ciudad de la matriz de distancias.

- Longitud de cruce: 20%, 30%, 40%, 50%, 60% y 70%.

La variable longitud de cruce la definimos en función de la dimensión de

la instancia a resolver (una longitud de cruce del 20% significa que

m=0,2*n), ya que para un problema de 17 ciudades, hacer que se

crucen 15 es cambiar casi por completo la trayectoria, mientras que

para un problema de 443 ciudades ese cruce sería prácticamente

insignificante.

Enunciados Br17 ftv33 ftv35 ftv38 p43 ftv44 ftv47 ry48p ft53 ftv55

Dimensión 17 34 36 39 43 45 48 48 53 56

Valor óptimo 39 1286 1473 1530 5620 1613 1776 14422 6905 1608

Enunciados ftv64 ft70 ftv70 kro124p ftv170 rbg323 rbg358 rbg403 rbg443

Dimensión 65 70 71 100 171 323 358 403 443

Valor óptimo 1839 38673 1950 36230 2755 1326 1163 2465 2720


81

Para cada enunciado vamos a utilizar esta variable con los 6 valores

porcentuales especificados (entre 20% y el 70% de la dimensión del

problema) y así podremos comprobar con nuestra experimentación si

este algoritmo funciona mejor para longitudes de cruce altas o bajas.

- Iteraciones máximas: 500, 1.000 y 5.000 // 5.000, 10.000 y 30.000.

Para los 15 problemas de la librería, de dimensión relativamente

pequeños (hasta dimensión 171, que equivale al problema ftv170) las

iteraciones que utilizamos son: 500, 1.000 y 5.000.

Los problemas rbg323, rbg358, rbg403 y rbg443, tienen dimensiones

muy altas, por lo que necesitarán más iteraciones para poder obtener

una buena solución. En este caso se utilizarán los valores 5.000,

10.000 y 30.000.

Para poder hacer una comparación estadística adecuada, cada una de las

combinaciones posibles de esos parámetros (hay 18 combinaciones para cada

enunciado) se ha ejecutado 30 veces para cada instancia, ya que si se ejecuta sólo

una vez el resultado de la experimentación no será significativo debido al factor

estocástico que envuelve al método utilizado.

4.3.2 Resultados

A continuación vamos a mostrar una serie de gráficas que muestran la evolución

completa de una determinada ejecución (1 de las 30) del enunciado

correspondiente, por lo que se va marcando el valor Gbest correspondiente a la

iteración 1, 2,…, iteración máxima.

En la gráficas 1 y 2 se muestra la evolución para el enunciado p43 con un 20% de

longitud de cruce y 5.000 iteraciones (cogemos 5.000 porque es el caso más

genérico, también se puede ver de forma aproximada su valor en 500 y en 1.000).

Esta ejecución concreta que hemos escogido parte de una distancia total (Gbest)

de 6.323 en la primera iteración y acaba con un resultado de 5.709, nótese que en

la iteración 25 ya se ha alcanzado el valor 5.788 de Gbest.

En la primera podemos observar el proceso iterativo completo, y de él concluir que

la mayor evolución se da para las primeras iteraciones, por ello en la gráfica 2

mostramos las 25 primeras iteraciones aisladas para observar con detalle la gran

mejora de Gbest que hay entre la primera ejecución (aleatoria) y el Gbest obtenido

tras unas pocas iteraciones.

Ese mismo fenómeno se ha observado en las gráficas con valores de 30%, 40%,

50%, 60% y 70% de este mismo problema.


82

Gráficas 1 y 2. Evolución del resultado Gbest de p43 para 5.000 iteraciones y

longitud de cruce del 20%. Elaboración propia.

Dado que el problema p43 nos da un valor muy cercano al óptimo, en todas las

combinaciones de variables, no hay gran dependencia del resultado obtenido con

los porcentajes de longitud de cruce utilizados.

Para poder comprobar si se puede ver la evolución del resultado en función de la

longitud de cruce exponemos las gráficas 3, 4, 5, 6, 7 y 8 de la evolución del

problema ft170 con porcentajes del 20, 30, 40, 50, 60 y 70 respectivamente.

Lo que podemos decir tras observar estas gráficas es que la dependencia del

resultado con la longitud de cruce no parece tan clara como la dependencia con la

cantidad de iteraciones realizadas.

De hecho, de estas 6 gráficas concretas no podríamos concluir si es mejor una

longitud de cruce mayor o menor, ya que se puede observar claramente que su

progreso es estocástico. Por esa razón, para hacer el estudio estadístico

ejecutamos cada instancia 30 veces, para poder obtener una media objetiva de la

que sí que se podrán sacar conclusiones.

Gráficas 3 y 4. Evolución de Gbest de ft170 para 5.000 iteraciones y longitud de

cruce del 20% y 30% en las respectivas gráficas. Elaboración propia.


83





Para poder seguir con el análisis de los resultados, vamos a hablar a partir de

ahora, de resultados medios, en lugar de utilizar uno concreto.

Para cada una de las posibles combinaciones de cada enunciado se obtienen 30

resultados en su archivo “RESULTADO.txt” correspondiente. Para poder manipular

de una forma cómoda estas soluciones, se han pasado los resultados de cada

problema a una tabla en Excel.

El formato de la tabla completa es el que vemos en la tabla 5 para el problema

concreto p43, donde la zona azul clara muestra los resultados obtenidos para 500

iteraciones, la del medio para 1.000 iteraciones y la más oscura para 5.000.

O 1000 2000 3000 4000 5000 O 1000 2000 3000 4000 5000

O 1000 2000 3000 4000 5000


84

Ta

bla

5. R

esu

lta

do

s d

e la

exp

eri

me

nta

ció

n c

om

ple

ta d

e p

43

. E

lab

ora

ció

n p

rop

ia.


85

En cada fila de la tabla se muestran los 30 resultados obtenidos en la ejecución y

en cada columna se detallan los parámetros utilizados para dicha ejecución de la

siguiente forma: “Número de partículas que forma la población – Número de

iteraciones máximas realizadas (criterio de parada establecido) – Longitud de cruce

en valor porcentual sobre la dimensión del problema”.

En las penúltima fila se muestra el resultado (Gbest) medio de las 30 ejecuciones

realizadas del problema para los parámetros descritos en la columna.

Y para terminar, la última fila muestra el error medio del algoritmo para esos

parámetros. La forma en que se ha hallado ese valor medio es:

𝑒𝑟𝑟𝑜𝑟 𝑚𝑒𝑑𝑖𝑜 = 𝐺𝑏𝑒𝑠𝑡 𝑚𝑒𝑑𝑖𝑜 − 𝐺𝑏𝑒𝑠𝑡 ó𝑝𝑡𝑖𝑚𝑜

𝐺𝑏𝑒𝑠𝑡 ó𝑝𝑡𝑖𝑚𝑜∗ 100

Donde el valor de Gbest óptimo utilizado es el que nos ofrece la librería TSPLIB y se

puede observar en la esquina superior izquierda de la tabla.

Finalmente hemos elaborado una tabla resumen donde se muestra el error medio

de cada uno de los problemas para cada una de sus variantes, es decir se muestra

el error medio de cada de las instancias estudiadas. Se puede ver en la tabla 6.


86

50-5

00-

20%

50-5

00-

30%

50-5

00-

40%

50-5

00-

50%

50-5

00-

60%

50-5

00-

70%

50-1

.000

-

20%

50-1

.000

-

30%

50-1

.000

-

40%

50-1

.000

-

50%

50-1

.000

-

60%

50-1

.000

-

70%

50-5

.000

-

20%

50-5

.000

-

30%

50-5

.000

-

40%

50-5

.000

-

50%

50-5

.000

-

60%

50-5

.000

-

70%

Br1

717

0,09

%0,

00%

0,60

%0,

26%

0,00

%0,

00%

0,00

%0,

00%

0,00

%0,

00%

0,00

%0,

00%

0,00

%0,

00%

0,00

%0,

00%

0,00

%0,

00%

ftv3

334

58,0

6%50

,48%

42,9

4%39

,82%

38,7

4%37

,24%

51,2

6%39

,51%

38,0

3%28

,95%

30,6

4%34

,69%

39,4

5%31

,77%

23,6

3%19

,08%

19,6

3%23

,82%

ftv3

536

60,2

4%46

,31%

44,2

8%39

,34%

37,4

1%39

,61%

54,1

2%40

,20%

38,0

2%29

,35%

33,7

1%31

,86%

43,8

7%27

,92%

23,9

2%20

,98%

20,8

0%23

,19%

ftv3

839

63,0

7%53

,49%

45,1

5%43

,51%

44,4

7%40

,68%

58,4

9%46

,96%

38,2

5%37

,33%

36,7

3%32

,67%

46,4

4%34

,36%

23,7

2%21

,26%

22,6

4%23

,92%

p43

432,

34%

1,83

%1,

75%

1,57

%1,

58%

1,43

%1,

96%

1,76

%1,

42%

1,44

%1,

44%

1,24

%1,

54%

1,17

%0,

92%

0,92

%0,

99%

0,76

%

ftv4

445

83,8

8%74

,68%

68,4

0%62

,06%

59,6

2%57

,89%

78,6

3%64

,41%

55,6

3%55

,05%

52,9

7%50

,85%

64,0

6%52

,33%

41,8

5%34

,46%

37,7

3%37

,30%

ftv4

748

78,3

1%72

,64%

66,9

3%62

,47%

64,9

4%62

,91%

73,3

4%67

,30%

56,7

9%55

,93%

52,8

3%58

,76%

60,3

1%53

,73%

44,5

3%37

,48%

38,5

3%42

,90%

ry48

p48

52,4

5%43

,51%

38,0

4%36

,27%

32,8

7%30

,34%

49,7

6%40

,06%

34,4

8%28

,80%

26,9

9%27

,15%

42,5

6%32

,20%

27,6

0%19

,84%

16,5

2%16

,51%

ft53

5379

,56%

75,4

7%72

,19%

71,5

6%67

,17%

66,5

2%74

,87%

69,7

3%64

,89%

61,1

0%60

,03%

58,5

5%62

,58%

57,9

4%47

,63%

45,0

3%42

,26%

45,1

0%

ftv5

556

106,

21%

97,1

4%90

,84%

82,1

8%83

,40%

85,5

0%99

,11%

89,1

6%80

,03%

68,3

1%72

,65%

72,3

6%86

,35%

73,0

8%60

,79%

57,4

4%55

,57%

54,9

4%

ftv6

465

124,

14%

115,

10%

108,

39%

104,

80%

101,

35%

94,9

9%11

8,02

%11

0,82

%99

,62%

89,0

6%89

,17%

86,5

1%10

4,73

%85

,55%

77,2

3%66

,95%

69,8

8%65

,41%

ft70

7038

,74%

35,7

3%35

,28%

32,8

1%32

,01%

32,3

8%36

,55%

33,5

1%31

,80%

31,4

7%30

,26%

30,1

0%32

,72%

29,6

6%27

,52%

25,4

9%25

,07%

25,0

9%

ftv7

071

130,

90%

123,

81%

117,

00%

110,

78%

110,

50%

108,

97%

125,

71%

117,

09%

108,

81%

99,6

1%10

4,35

%92

,37%

112,

55%

99,9

9%91

,66%

73,2

8%72

,88%

70,4

2%

kro1

24p

100

107,

89%

101,

45%

92,3

3%87

,77%

80,4

1%75

,23%

104,

02%

93,7

3%90

,26%

80,4

7%71

,57%

68,1

3%95

,16%

82,7

3%74

,06%

59,2

6%53

,54%

50,8

4%

ftv1

7017

129

5,93

%29

2,73

%28

8,88

%29

1,29

%28

0,89

%26

3,25

%28

6,84

%28

2,57

%27

4,87

%27

0,40

%26

8,53

%24

7,78

%27

1,35

%26

4,85

%25

3,22

%23

5,17

%22

8,03

%21

0,93

%

85,4

5%78

,96%

74,2

0%71

,10%

69,0

2%66

,46%

80,8

4%73

,12%

67,5

3%62

,49%

62,1

2%59

,53%

70,9

1%61

,82%

54,5

5%47

,78%

46,9

4%46

,07%

50-5

.000

-

20%

50-5

.000

-

30%

50-5

.000

-

40%

50-5

.000

-

50%

50-5

.000

-

60%

50-5

.000

-

70%

50-

10.0

00-

20%

50-

10.0

00-

30%

50-

10.0

00-

40%

50-

10.0

00-

50%

50-

10.0

00-

60%

50-

10.0

00-

70%

50-

30.0

00-

20%

50-

30.0

00-

30%

50-

30.0

00-

40%

50-

30.0

00-

50%

50-

30.0

00-

60%

50-

30.0

00-

70%

rbg3

2332

322

3,41

%22

4,78

%21

5,08

%20

6,95

%19

6,08

%18

6,38

%21

4,89

%21

8,85

%20

7,65

%19

5,60

%18

2,63

%17

4,61

%20

3,97

%20

7,35

%19

1,05

%17

6,66

%16

5,40

%15

8,76

%

rbg3

5835

833

3,38

%33

0,59

%31

0,99

%28

9,54

%27

4,71

%27

1,28

%32

4,10

%31

6,73

%29

5,23

%27

5,74

%25

6,26

%25

1,79

%31

4,98

%29

8,11

%27

4,63

%24

8,71

%23

3,67

%22

8,75

%

rbg4

0340

314

6,74

%13

8,92

%12

8,82

%12

0,71

%11

5,64

%11

2,20

%14

2,55

%13

3,64

%12

1,23

%11

3,27

%10

7,70

%10

3,89

%13

5,25

%12

4,59

%11

1,12

%10

3,16

%95

,99%

94,7

8%

rbg4

4344

314

6,35

%13

7,92

%13

0,61

%12

4,92

%11

7,67

%11

2,85

%14

3,28

%13

4,14

%12

4,68

%11

7,23

%10

9,80

%10

7,34

%13

6,76

%12

4,69

%11

6,33

%10

7,82

%99

,90%

97,4

9%

212,

47%

208,

05%

196,

38%

185,

53%

176,

03%

170,

68%

206,

21%

200,

84%

187,

20%

175,

46%

164,

10%

159,

41%

197,

74%

188,

68%

173,

28%

159,

09%

148,

74%

144,

94%

Cal

idad

: Err

or

Med

io

Nº

Part

ícul

as q

ue f

orm

a la

pob

laci

ón -

Nº

de I

tera

cion

es (

Cri

teri

o de

par

ada)

- L

ongi

tud

de c

ruce

en

fun

ción

de

el t

amañ

o de

l pro

blem

a

Nº

Part

ícul

as q

ue f

orm

a la

pob

laci

ón -

Nº

de I

tera

cion

es (

Cri

teri

o de

par

ada)

- L

ongi

tud

de c

ruce

en

fun

ción

de

el t

amañ

o de

l pro

blem

a

nEn

unci

ado

Cal

idad

: Err

or

Med

io

Ta

bla

6. R

esu

lta

do

s d

e la

exp

eri

me

nta

ció

n: E

rro

r m

ed

io. E

lab

ora

ció

n p

rop

ia.


87

A simple vista podemos observar, tanto caso por caso, como en el error medio, que

cuantas más iteraciones realizamos, mejor resultado vamos obteniendo.

Mientras que de la longitud de cruce podemos decir que en valor medio, cuanto

mayor es su porcentaje mejor solución obtenemos, pero no se puede generalizar

para cada problema, ya que por ejemplo en el enunciado ftv35 es mejor el

resultado que se obtiene para el 60% de longitud de cruce en el caso de 500 y

5.000 iteraciones y para el 50% en el caso de 1.000 que los sus resultados

respectivos con longitud de cruce del 70%.

4.4 Estudio estadístico de resultados

Dado que con la simple observación de la tabla 6 ya podemos concluir que la mejor

situación se da para el mayor número de iteraciones máximas (5.000 en el caso de

los problemas pequeños y 30.000 para los grandes), esta variable no la

analizaremos estadísticamente.

La variable longitud de cruce es la que vamos a analizar en este apartado con los

estadísticos de Friedman y Holm, para determinar qué longitud es la más

adecuada, es decir, ante qué valor se comporta mejor nuestro algoritmo.

Tanto el test de Friedman como el test a posteriori de Holm (García el al., 2009)

son test no paramétricos (se basan en un orden y utilizan datos de tipo nominal,

ordinal o que representan un orden en forma de ranking) que se utilizan para

analizar el comportamiento de algoritmos evolutivos en problemas de optimización.

Estos test se describen brevemente a continuación:

- Test de Friedman

Este test lo que hace es establecer un orden de los resultados

obtenidos por el algoritmo para cada longitud de cada problema, es

decir hay tantos rankings como problemas estemos analizando.

Para establecer el orden se asigna a cada resultado un puesto en un

ranking 𝑟𝑗 para j= 1, 2, …k (El mejor resultado se le asigna el orden 1 y

al peor el orden k, donde k= número de longitudes de cruce estudiadas).

Este test utiliza la siguiente hipótesis nula: suposición de que el

comportamiento de los algoritmos es equivalente y por tanto los

rankings 𝑅𝑗 también son similares, donde 𝑅𝑗 es el ranking medio de los

N problemas analizados (nosotros tendremos 6 rankings medios, los

correspondientes a las longitudes de cruce), por tanto responde a la

siguiente fórmula:


88

𝑅𝑗 = 1

𝑁∑ 𝑟𝑖

𝑗

𝑖

La distribución del estadístico se da según 𝑋𝐹2 que se distribuye según

una distribución 𝑋2 con k-1 grados de libertad. Su fórmula es:

𝑋𝐹2 =

12𝑁

𝑘(𝑘 + 1) [∑ 𝑅𝑗

2 − 𝑘(𝑘 + 1)2

4𝑗

]

Si se rechaza la hipótesis nula, procedemos con el test a posteriori.

- Test de Holm

El test propuesto por Holm es un tipo de test a posteriori.

Este test prueba de manera secuencial las hipótesis ordenadas según

su significancia, entendiendo por hipótesis a:

ℎ𝑖 = 𝛼

(𝑘 − 𝑖)

Donde tenemos que α es un valor fijo [0,1] y k es el valor que se ha

obtenido anteriormente mediante el test de Friedman

Representamos los resultados ordenados como 𝑝1, 𝑝2, … donde 𝑝1 <

𝑝2< …<𝑝𝑘−1. Lo que hacemos en este test es comparar cada 𝑝𝑖 con su

hipótesis α/(k-i), empezando por el valor más relevante.

El modo de hacerlo es: Si 𝑝1 < α/(k-1), la hipótesis se rechaza y

continuamos comparando, 𝑝2 < α/(k-2)…hasta que una de las hipótesis

no pueda ser rechazada. En ese momento todos los demás valores se

mantienen como aceptables.

El estadístico que permite comparar un valor de longitud de cruce con

otro es:

𝑍 =(𝑅𝑖 − 𝑅𝑗)

√𝑘(𝑘 + 1)6𝑁

Donde Z es el valor con el que entramos en la tabla de la normal para

obtener la probabilidad. Y esa probabilidad es la que se compara con el

valor de α.

Dado que la variable a analizar es la longitud de cruce, se ha elaborado una tabla

(tabla 7) con el resultado medio de las 30 ejecuciones de cada enunciado para

cada una de las instancias que poseen las iteraciones máximas de 5.000 en

pequeños y 30.000 en problemas grandes, es decir para sus 6 variantes según la

longitud de cruce. Los valores de esa tabla son los que se utilizan para realizar el

estudio estadístico.


89

Tabla 7. Resultados medios utilizados para el estadístico. Elaboración propia.

4.4.1 Resultados

Tras realizar los estudios estadísticos obtenemos los siguientes rankings (tabla 8)

medios para los 6 algoritmos que comparamos:

Tabla 8. Ranking medio para los 6 algoritmos. Elaboración propia.

Como se puede ver el % que mejor resultado da es el del 70%. El test de Friedman

obtiene un P-valor = 5−11, por lo que se rechaza la hipótesis nula.

Sabiendo ya que esa hipótesis es rechazada procedemos a realizar el test de Holm.

En el test de Holm procedemos comparando la longitud de cruce 70%, ya que es la

más relevante, con todas las demás.

50-5.000-20% 50-5.000-30% 50-5.000-40% 50-5.000-50% 50-5.000-60% 50-5.000-70%

Br17 39,00 39,00 39,00 39,00 39,00 39,00

ft53 11225,90 10905,57 10193,97 10014,60 9823,30 10019,20

ft70 51326,33 50144,67 49317,10 48531,57 48369,87 48374,13

ftv33 1793,33 1694,53 1589,93 1531,33 1538,40 1592,30

ftv35 2119,13 1884,27 1825,33 1782,00 1779,40 1814,53

ftv38 2240,53 2055,73 1892,93 1855,27 1876,33 1896,03

ftv44 2646,27 2457,03 2288,03 2168,80 2221,53 2214,60

ftv47 2847,17 2730,23 2566,87 2441,57 2460,23 2537,90

ftv55 2996,50 2783,07 2585,47 2531,70 2501,60 2491,50

ftv64 3765,03 3412,23 3259,27 3070,20 3124,03 3041,83

ftv70 4144,67 3899,90 3737,37 3378,93 3371,10 3323,10

ftv170 10230,67 10051,70 9731,20 9233,90 9037,33 8566,17

kro124p 70705,37 66201,30 63062,70 57698,27 55627,57 54647,67

p43 5706,47 5686,03 5671,70 5671,90 5675,73 5662,47

ry48p 20559,97 19066,17 18402,67 17283,30 16804,83 16803,57

Valor Medio 12823,09 12200,76 11744,24 11148,82 10950,02 10868,27

50-30.000-20% 50-30.000-30% 50-30.000-40% 50-30.000-50% 50-30.000-60% 50-30.000-70%

rbg323 4030,70 4075,40 3859,30 3668,57 3519,27 3431,13

rbg358 4826,23 4630,07 4356,93 4055,53 3880,60 3823,37

rbg403 5798,87 5536,07 5204,20 5007,87 4831,17 4801,33

rbg443 6440,00 6111,67 5884,07 5652,63 5437,20 5371,60

Valor Medio 5273,95 5088,30 4826,13 4596,15 4417,06 4356,86

Nº de Partículas - Nº de Iteraciones - Longitud de cruce

Nº de Partículas - Nº de Iteraciones - Longitud de cruce


90

Para α = 0,05 (nivel de precisión del 95%) obtenemos del test de Holm los

resultados de la tabla 9. La hipótesis se rechaza si tiene un p-valor menor o igual

que 0,025, por lo que como podemos ver en la columna p (es el p-valor) de la tabla,

los porcentajes 20%, 30% y 40% rechazan la hipótesis de igualdad con el algoritmo

de longitud de cruce 70%.

Tabla 9. Test de Holm para α = 0,05. Elaboración propia.

En la tabla 10 mostramos el test de Holm pero con α = 0,1 (nivel de precisión del

90%). Para ese valor de α, el test de Holm determina que la hipótesis se rechaza si

el p-valor es menor o igual que 0,05.

Por tanto para este nivel de α podemos ver de nuevo, en la columna p, que las

hipótesis que se rechazan son la del 20%, 30% y 40%, mientras que para los

algoritmos con longitud de cruce de 50% y 60% no se puede rechazar la hipótesis

de igualdad respecto al 70%.

Tabla 10. Test de Holm para α = 0,1. Elaboración propia.

Podemos concluir este capítulo diciendo que el método que hemos implementado

se comporta mejor cuantas más iteraciones hagan en cada ejecución, y en cuando

a la variable longitud de cruce debemos indicar, que aunque la longitud de cruce

que mejores resultados obtiene es la del 70%, no podemos decir, estadísticamente

halando, que la longitud de cruce de 70% sea significativamente mejor que la del

50% y 60%. Lo que si podemos asegurar, es que el 50%, 60% y 70% son mejores

que el 20%, 30% y 40%.

Por tanto de ahora en adelante, si se va a ejecutar este algoritmo, recomendamos

que se establezcan el mayor número de iteraciones posibles (siempre que no

sobrepase la capacidad operativa del ordenador) y que la longitud de cruce sea

igual o mayor que el 50% de la dimensión del problema.


91

5. CONCLUSIÓN E INVESTIGACIÓN DE LÍNEAS

FUTURAS

Analizando los resultados experimentales que se han obtenido, podemos concluir

que el algoritmo desarrollado para implementar el método de Optimización por

Enjambre de Partículas al Problema del Agente Viajero parece funcionar

correctamente, obteniendo valores muy cercanos al óptimo en problemas donde el

número de ciudades a recorrer es pequeño, incluso alcanza el mejor resultado

conocido hasta el momento para el menor de los problemas de la librería, el br17.

Sin embargo, para problemas de grandes dimensiones el resultado que se obtiene

dista bastante del valor óptimo conocido.

En cuanto al valor de las variables utilizadas a la hora de ejecutar el algoritmo,

podemos decir que el algoritmo se comporta mejor ante iteraciones máximas y

longitudes de cruce elevadas. No obstante, queda pendiente para investigaciones

futuras cuál sería el valor óptimo para estas variables. También sería recomendable

indagar en el tamaño de la población que optimiza el funcionamiento del algoritmo.


92

6. BIBLIOGRAFÍA

- Applegate, D., Bixby, R., Chavátal, V. y Cook, W. (2011). The Traveling

Salesman Problem: A Computational Study. Pág. 1-3.

- Clerc, M. (2010). Particle Swarm Optimization. Pág.17-19.

- Eberhart, R. y Kennedy, J. (1995). A New Optimizer Using Partcle Swarm

Theory. Sixth International Symposium on Micro Machine and Human

Science. 0-7803-2676-8/95. Pág. 39-43.

- Fan, H. (2010). Discrete Particle Swarm Optimization for TSP based on

Neighborhood. Journal of Computational Information Systems 6:10. Pág.

3407-3413.

- García, S., Molina, D., Lozano, M. and Herrera, F. (2009). A study on the use

of non-parametric test for analyzing the evolutionary algorithms’ behaviour: a

case study on the CEC’2005 Special Session on Real Parameter

Optimization. Journal of Heuristics, 15. Pág. 639-641.

- Guerequeta, R. y Vallecillo, A. (1998). Técnicas de Diseño de Algoritmos,

Capítulo 7: Ramificación y poda. Pág. 255-257.

- Gutin, G. y Punnen, A. (2007) The Traveling Salesman Problem and Its

Variations. Pág. 9-15.

- Hoffman, K. (2000). Combinatorial optimization: Current successes and

directions for the future. Journal of Computational and Applied Mathematics.

Nº 124. Pág. 344-348.

- Kennedy, J. y Eberhart, R. (1995). Particle Swarm Optimization. 0-7803-

2768-3/95. Pág. 1942-1948.

- Kennedy, J. y Eberhart, R. (1997). A Discrete Binary Version of the Particle

Swarm Algorithm. 0-7803-4053-1/97. Pág. 4104-4108.

- Larré, O. (2012) El problema del vendedor viajero en grafos cúbicos. Tesis,

Universidad de Chile. Pág. 1-6.

- Lin, S. (1965). Computer Solutions of the Traveling Salesman Problem. The

Bell System Technical Journal. Volume 44, Issue 10. Pág.2245-2269.


93

- Luna, F. (2008). Metaheurísticas avanzadas para problemas reales en redes

de telecomunicaciones. Tesis doctoral, Universidad de Málaga. Pág. 19-28.

- Luque, G. (2006). Resolución de Problemas Combinatorios con Aplicación

Real en Sistemas Distribuidos. Tesis doctoral, Universidad de Málaga.

- Martí, R. (2003). Procedimientos Metaheurísticos en Optimización

Combinatoria. Universidad de Valencia, Facultad de matemáticas.

- Ross, P. (2005). Search Methodologies, Chapter 17: Hyper heuristics. Pág.

529-531.

Webs Consultadas:

[1] http://www.dc.uba.ar/materias/aed3/2014/2c/teorica/handout_compl.pdf.

Último acceso: Junio 2015

[2] https://es.wikipedia.org/wiki/Teor%C3%ADa_de_la_computaci%C3%B3n#Teor.

C3.ADa_de_la_computabilidad. Último acceso: Junio 2015.

[3] http://ocw.uc3m.es/ingenieria-informatica/teoria-de-automatas-y-lenguajes-

formales/material-de-clase-1/tema-8-complejidad-computacional. Último

acceso: Junio 2015.

[4] https://es.wikipedia.org/wiki/NP-hard. Último acceso: Junio 2015.

[5] https://upload.wikimedia.org/wikipedia/commons/6/66/P_np_np-

completo_np-hard.svg. Último acceso: Junio 2015.

[6] http://www.dii.uchile.cl/~daespino/PApers/TSP_and_IP_chile_050820.pdf.

Último acceso: Julio 2015.

[7] http://es.wikipedia.org/wiki/Problema_del_viajante. Último acceso: Junio 2015.

[8] http://www.csd.uoc.gr/~hy583/papers/ch11.pdf. Último acceso: Junio 2015.

[9] http://www.tebadm.ulpgc.es/almacen/seminarios/MH%20Las%20Palmas%20

2.pdf. Último acceso: Junio 2015.

http://www.dc.uba.ar/materias/aed3/2014/2c/teorica/handout_compl.pdf

https://es.wikipedia.org/wiki/Teor%C3%ADa_de_la_computaci%C3%B3n#Teor.C3.ADa_de_la_computabilidad

https://es.wikipedia.org/wiki/Teor%C3%ADa_de_la_computaci%C3%B3n#Teor.C3.ADa_de_la_computabilidad

https://es.wikipedia.org/wiki/NP-hard

https://upload.wikimedia.org/wikipedia/commons/6/66/P_np_np-completo_np-hard.svg

https://upload.wikimedia.org/wikipedia/commons/6/66/P_np_np-completo_np-hard.svg

http://www.dii.uchile.cl/~daespino/PApers/TSP_and_IP_chile_050820.pdf

http://www.csd.uoc.gr/~hy583/papers/ch11.pdf

http://www.tebadm.ulpgc.es/almacen/seminarios/MH%20Las%20Palmas%202.pdf

http://www.tebadm.ulpgc.es/almacen/seminarios/MH%20Las%20Palmas%202.pdf


94

[10] http://es.wikipedia.org/wiki/Optimizaci%C3%B3n_por_enjambre_de_part%C

3%ADculas. Último acceso: Junio 2015.

[11] www.codeblocks.org. Último acceso: Mayo 2015.

[12] http://comopt.ifi.uni-heidelberg.de/software/TSPLIB95/. Último acceso:

Julio 2015.

http://es.wikipedia.org/wiki/Optimizaci%C3%B3n_por_enjambre_de_part%C3%ADculas

http://es.wikipedia.org/wiki/Optimizaci%C3%B3n_por_enjambre_de_part%C3%ADculas

http://www.codeblocks.org/

http://comopt.ifi.uni-heidelberg.de/software/TSPLIB95/

desarrollo y aplicación del algoritmo pso al problema...

Documents