algoritmo genético para resolver el tsp

8/16/2019 Algoritmo Genético para resolver el TSP

1/18

05 de noviembre de 2015

Algoritmo genético paraTSP en c++ Inteligencia Artificial

Julcarima Calle, Josué.


2/18


3/18

Inteligencia Artificial

2

PRESENTACIÓN

Resumen

El presente informe tiene como objetivo especificar el proceso de solución llevado a cabo para resolverel problema del agente viajero por medio de un algoritmo genético e implementarlo en C++.

Introducción

El problema del agente viajero es un problema NP-Hard de optimización combinatoria, el tiemporequerido para resolverlo es super-polinomial. Resolver el peor caso para un algoritmo determinístico

tarda en proporción exponencial a la cantidad ciudades (un parámetro de la entrada que se explica másadelante).

El problema fue formulado matemáticamente en el 1800 por el matemático irlandés WR Hamilton y porel matemático británico Thomas Kirkman.


4/18

Informe Algoritmo Genético

3

EL PROBLEMA

Especificación del problema

El problema del agente viajero en ciencias de la computación puede ser planteado de la siguientemanera:1

Dada una lista de las ciudades y las distancias entre cada par de ciudades, ¿cuál es el camino

más corto que visita cada ciudad exactamente una vez y vuelve a la ciudad de origen?

En términos de teoría de grafos se puede plantear como sigue:

Dado una grafo ponderado completo (donde los vértices representan las ciudades, las aristas

representan los caminos y los pesos son el costo o las distancias de estos caminos), encontrar

un ciclo de Hamilton con menor peso.

Sin embargo pueden existir variaciones al problema como por ejemplo que el grafo sea dirigido ó que elgrafo no sea necesariamente completo, este último caso se puede incluir en el planteamiento originalconsiderando que las aristas que faltan tienen peso infinito.

En el caso del presente informe se resolverá el problema de forma no determinística tomando en cuentaque los puntos o ciudades pertenecen a un espacio bidimensional y el peso de las aristas es la distanciapitagórica (norma 2) entre los puntos.

1 (Wikipedia)


5/18


4

SOLUCIÓN AL PROBLEMA

Especificación del conocimiento declarativo

Respecto a la declaración de variables de entrada se tiene:

Un conjunto de puntos todos en un espacio bidimensional.

Respecto a las variables de salida del algoritmo se tienen:

Una permutación del conjunto de puntos de la entrada denotando el camino hamiltonianoóptimo.

Estrategia de la solución

Las soluciones existentes en la literatura son muy amplias y se pueden dividir en 2:

1. Determinísticas. – Es decir para una entrada dada siempre obtienen la misma salida.o

Heurísticaso

Exactas.- Este tipo de algoritmos son los únicos que aseguran obtener la soluciónóptima

2. No determinísticas (aleatorizados).- Nótese que estos algoritmos pueden utilizaraproximaciones heurísticas en su procedimiento.

Para el desarrollo del presente trabajo se escogió la estrategia no determinística del algoritmo genético.


6/18


5

Plantear el conocimiento procedural

El algoritmo planteado es a grandes rasgos:

Descripción del conocimiento procedural

Cada uno de los pasos anteriores se especifica como sigue:

1. Generación de la población iniciala. De manera aleatoria se generan los individuos iniciales barajando la permutación

(identificador de un camino/ciclo Hamiltoniano).2. Evolución de la población hasta una condición de parada predefinida. Cada evolución a la

siguiente generación consta de los siguientes pasos.a. Pase de una élite a la siguiente generación (los ELITE mejores siempre pasan a la

siguiente generación). b.

Cruce. Se cruzan los individuos donde la probabilidad de cada participante de unapareamiento es proporcional a su fitness (función de aptitud, la cual en el problema

actual es el recíproco de la distancia).c. Mutación. Después de cada cruce se realiza una mutación en los hijos dependiendo dela probabilidad de mutación.

3. Obtención del mejor individuo de la población final. La condición de parada establecida en estecaso es el número de generaciones o poblaciones (NUMBER_OF_GENERATIONS)

Generación de lapoblación inicial

Evolución de lapoblación hasta una

condición deparada predefinida

Obtención delmejor individuo dela población final


7/18


6

RESULTADOS

Resultados obtenidos

Se probó el algoritmo para el caso de xqf1312 (la entrada posee 131 nodos y se encuentra enhttp://www.math.uwaterloo.ca/tsp/vlsi/xqf131.tsp) con los siguientes parámetros:

int TOTAL_POPULATION = 5000;

double MUTATION_PROBABILITY = 0.07;

int NUMBER_OF_GENERATIONS = 10000;

int ELITE = 3;

Obteniendo los siguientes resultados:

Mejores distancias encontradas por generación (población)

GenerationBest distance

found

0 3891.81

1000 2827.73

2000 2623.44

3000 2466.63

4000 2332.91

5000 2185.81

6000 2141.97

7000 2059.38

8000 1991.88

9000 1922.1

9999 1890.8

Conclusiones

Se concluye que en la mayoría de los casos a mayor tiempo gastado en buscar una solución se obtieneuna solución más óptima al final.

Para el caso propuesto la solución óptima tiene una distancia de 564 según 3, mientras el programadiseñado con los parámetros dados solo logró encontrar una solución con distancia de 1890. Estocomprueba que la probabilidad de necesitar un tiempo muy alto para hallar la solución óptima es muyalta.

2

(Math U. Waterloo)3 (xqf131 TSP Problem Optimal Tour)

http://www.math.uwaterloo.ca/tsp/vlsi/xqf131.tsphttp://www.math.uwaterloo.ca/tsp/vlsi/xqf131.tsphttp://www.math.uwaterloo.ca/tsp/vlsi/xqf131.tsp


8/18


7

REFERENCIAS Math U. Waterloo. (s.f.). Obtenido de http://www.math.uwaterloo.ca/tsp/vlsi/index.html

Math U. Waterloo. (s.f.). Obtenido de http://www.math.uwaterloo.ca/tsp/vlsi/xqf131.tour

Wikipedia. (s.f.). Obtenido de https://en.wikipedia.org/wiki/Travelling_salesman_problem


9/18


8

CÓDIGO FUENTE

#include

#include

#include

#include

#include

#include

#include

using namespace std;

/** Parameters **/

int TOTAL_POPULATION = 500;

double MUTATION_PROBABILITY = 0.07;

int NUMBER_OF_GENERATIONS = 1000;

int ELITE = 1; // the best ones which always pass to the next generation

struct Point{

double x, y;

Point(){}

Point(double _x, double _y): x(_x), y(_y) {}

double dist(Point p){

return hypot(p.x - x, p.y - y );

}

};

struct Population{

private:


10/18


9

vector &points;

vector routes;

vector prob;

int n; // size of the route

public:

/** Freeing memory **/

~Population(){

routes.clear();

prob.clear();

}

/** Constructors **/

Population(vector &_points): points(_points){}

Population(int routeSize, vector &_points): n(routeSize),

points(_points){}

Population(int popuSize, int routeSize, vector &_points):

points(_points) {

n = routeSize;

routes.clear();

vector ind; // indexes to shuffle

for(int i = 0; i < n; i++) ind.push_back(i);

// random init

for(int i = 0; i < popuSize; i++){

random_shuffle ( ind.begin(), ind.end() );

vector newRoute = ind;

routes.push_back( newRoute );

}

}


11/18


10

vector getRoutes() const{

return routes;

}

int getRouteSize() const{

return n;

}

vector getProb() const{

return prob;

}

void operator=(const Population& pob){

routes = pob.getRoutes();

n = pob.getRouteSize();

prob = pob.getProb();

}

// OX1 type crossover

void crossover(vector &p1, vector &p2,

vector &h1, vector &h2

){

h1.clear();

h2.clear();

int a = rand()%(n-1), b = rand()%(n-1) ;

if( a > b ) swap(a,b);

bool oc1[n];

bool oc2[n];


12/18


11

memset(oc1, 0, sizeof(oc1));

memset(oc2, 0, sizeof(oc2));

for(int i = 0; i < n; i++){

h1.push_back( -1 );

h2.push_back( -1 );

}

for(int i = a+1; i


13/18


12

}*/

/** mutation **/

double r;

r = (double)rand()/(double)RAND_MAX;

if( r


14/18


13

vector h1,h2;

double r;


int ind1 = lower_bound( prob.begin(), prob.end(), r) -

prob.begin();

int ind2 = ind1;

while( ind2 == ind1){


ind2 = lower_bound( prob.begin(), prob.end(), r) -prob.begin();

}

//cout


15/18


16/18


15

routes.push_back(nRuta);

}

int getSize(){

return (int)routes.size();

}

/** You have to order before calling to this method **/

vector getFirst(){

vector res;

for(int i = 0; i < n; i++) res.push_back( points[ routes[0][i] ]);

return res;

}

vector getFirstIndexes(){

return routes[0];

}

Point getPoint(int i){

return points[i];

}

};

/** Genetic algorithm **/

vector ga_tsp(vector &points){

int n = (int)points.size();

Population pActual (TOTAL_POPULATION, n, points);


17/18


16

pActual.order();

vector result = pActual.getFirst();

vector rIndexes = pActual.getFirstIndexes();

cout


18/18


17

vector points;

/** Reading input **/

double x, y;

while( cin >>x >> y ){

points.push_back( Point(x,y) );

}

vector result = ga_tsp( points );

cout

algoritmo genético para resolver el tsp

Documents