INGENIERIA EN SISTEMAS

COMPUTACIONALES

Proyecto Final° Algoritmo

Genetico para el problema
TSP.

Del Ángel Lara Gustavo 14070746

Programación Paralela

Dra. Claudia Guadalupe Gómez Santillán.

Hora: 08:00 a.m. – 09:00 a.m.

Fecha: Viernes 15 de diciembre 2017

1
Contenido
DEFINICIÓN FORMAL DEL PROBLEMA TSP............................................ 2

TSPLIB. .............................................................................................................. 4

ALGORITMO GENÉTICO. .............................................................................. 5

PARALELISMO DEL ALGORITMO ............................................................ 10

PROGRAMA ................................................................................................... 11

RESULTADOS ................................................................................................ 16

CONCLUSIONES ........................................................................................... 20

2
DEFINICIÓN FORMAL DEL PROBLEMA
TSP.
El problema del vendedor viajero, problema del vendedor ambulante,
problema del agente viajero o problema del viajante (TSP por sus siglas en
inglés), responde a la siguiente pregunta: dada una lista de ciudades y las
distancias entre cada par de ellas, ¿cuál es la ruta más corta posible que visita
cada ciudad exactamente una vez y al finalizar regresa a la ciudad origen?
Este es un problema NP-duro dentro en la optimización combinatoria, muy
importante en la investigación de operaciones y en la ciencia de la
computación.

Debido a que todas las ciudades deben ser visitadas una vez, el problema se
reduce a encontrar el orden en el cual se deben visitar dichas ciudades. Cada
solución candidata se puede representar por medio de una permutación p de
tamaño n que representa el orden en el que las ciudades deben ser visitadas. El
costo C de las soluciones candidatas es la sumatoria de las distancias entre
cada par de ciudades. Esto se puede representar gráficamente a través de un
grafo. Existen grafos completos que son cuando cada par de vértices están
unidos por una arista, es decir que contiene todas las posibles aristas. Por
ejemplo:

3
TSPLIB.
TSPLIB es una biblioteca con ejemplos de instancias de TSP. La biblioteca
contiene un archivo con las especificaciones para cada instancia, con su
nombre, el tipo de problema, las dimensiones o tamaño del problema,
comentarios adicionales y, debido a que no todas las instancias proporcionan
una matriz de distancias entre ciudades como tal sino una ubicación,
proporciona además una descripción de la métrica que debe utilizarse para
calcular las distancias en dicha instancia.

4
ALGORITMO GENÉTICO.
Los algoritmos genéticos propuestos por Holland son métodos heurísticos
inspirados en las teorías de Mendel y Watson acerca de la recombinación
genética y las mutaciones en los seres vivos.

Los algoritmos genéticos inician con una población generada aleatoriamente,

después se evalúan sus individuos y se aplican los operadores genéticos para
producir la población de la generación siguiente. Este proceso se repite hasta
que se cumple con alguna condición de parada, por ejemplo un número
determinado de generaciones o ciclos.

La aptitud de los individuos nos indica qué tan bien satisface o soluciona un
individuo el problema de optimización, y sirve como criterio para discriminar
a diferentes individuos dentro de una población.

El paso en el que se evalúa la aptitud de los individuos suele ser el más

costoso para una aplicación real. En el contexto de TSP, la aptitud de los
individuos o soluciones es directamente la suma del costo de cada una de las
aristas en el recorrido que caracteriza dicho individuo, es decir el costo total
del recorrido.

5
Para la solución de este problema se usarán las técnicas siguientes.

GENERACION
POBLACION
(Aleatoria)

I < Generaciones

SELECCIÓN
(Estado Uniforme)

CRUZA
(Position-Based
Crossover)

MUTACIÓN
(Intercambio Recíproco)

RESULTADO
(Ruta Óptima)

6
  GENERACION DE LA POBLACIÓN
Método Aleatorio.
Esta técnica crea rutas aleatorias de tal manera que ningún elemento se repita
dentro de la ruta. Esta técnica se utiliza cuando se requiere una cantidad alta
de rutas para tener como población.
Rand Asegurar no repetir ciudad y agregando a Individuo
3 Verificación = 0 0 1 0 0 0 0 0 0 0
Individuo = 3 - - - - - - - - -
7 Verificación = 0 0 1 0 0 0 1 0 0 0
Individuo = 3 7 - - - - - - - -
1 Verificación = 1 0 1 0 0 0 1 0 0 0
Individuo = 3 7 1 - - - - - - -
2 Verificación = 1 1 1 0 0 0 1 0 0 0
Individuo = 3 7 1 2 - - - - - -
5 Verificación = 1 1 1 0 1 0 1 0 0 0
Individuo = 3 7 1 2 5 - - - - -
6 Verificación = 1 1 1 0 1 1 1 0 0 0
Individuo = 3 7 1 2 5 6 - - - -
9 Verificación = 1 1 1 0 1 1 1 0 1 0
Individuo = 3 7 1 2 5 6 9 - - -
8 Verificación = 1 1 1 0 1 1 1 1 1 0
Individuo = 3 7 1 2 5 6 9 8 - -
10 Verificación = 1 1 1 0 1 1 1 1 1 1
Individuo = 3 7 1 2 5 6 9 8 10 -
4 Verificación = 1 1 1 1 1 1 1 1 1 1
Individuo = 3 7 1 2 5 6 9 8 10 4

Struct Individuo
P[Numero de ciudades] [ 3, 7, 1, 2, 5, 6, 9, 8, 10, 4]
Aptitud Calcular Aptitud( )

7
  SELECCIÓN
Selección de Estado Uniforme
Esta técnica fue propuesta por Whitley en la cual sólo unos cuantos individuos
son reemplazados en cada generación (los menos aptos).

El algoritmo de la selección de estado uniforme es el siguiente:

• Llamaremos G a la población original.

• Seleccionar R individuos (1 ≤ R < M) de entre los más aptos. Por

ejemplo, R = 2.

• Efectuar cruza y mutación a los R individuos seleccionados. Llamaremos

H a los hijos.

• Elegir al mejor individuo en H.

• Reemplazar los peores individuos de G por los mejores individuos de H.

8
  CRUZA
Position-based Crossover
Esta es una cruza para permutaciones. Esta técnica fue propuesta por
Syswerda como una adaptación de la cruza uniforme para permutaciones. El
algoritmo es el siguiente:
1. Seleccionar (al azar) un conjunto de posiciones de P1 (no necesariamente
consecutivas).
2. Producir un hijo borrando de P1 todos los valores, excepto aquellos que
hayan sido seleccionados en el paso anterior.
3. Borrar los valores seleccionados de P2. La secuencia resultante de valores
se usará para completar el hijo.
4. Colocar en el hijo los valores faltantes de izquierda a derecha, de acuerdo a
la secuencia de P2.
5. Repetir los pasos del 1 al 4, pero tomando ahora la secuencia de P2.
Ejemplo de Position-based Crossover:
P1 = 9 8 4 5 6 7 1 2 3 10
P2 = 8 7 1 2 3 10 9 5 4 6

Valores elegidos de P1 Y P2: 8 6 2 10

Producir un hijo:
H1 = X 8 X X 6 X X 2 X 10
H2 = 8 x X 2 X 10 X X X 6

Borrar de P2 la secuencia usada para H1, de P1 la secuencia usada para H2:

P1’ = 9 X 4 5 X 7 1 X 3 X
P2’ = X 7 1 X 3 X 9 5 4 X

Sustituir de izquierda a derecha los valores que aparecen en P2’ en H1:

H1 = 7 8 1 3 6 9 5 2 4 10
H2 = 8 9 4 2 5 10 7 1 3 6

9
  MUTACIÓN
Mutación por Intercambio Recıproco
En este caso, se seleccionan dos puntos al azar y se intercambian estos valores
de posición.
Por ejemplo, dada:
P = 9 4 2 1 5 7 6 10 3 8

Tendríamos:
P’ = 9 10 2 1 5 7 6 4 3 8

PARALELISMO DEL ALGORITMO

ETAP LECTURA MATRIZ DE GENERACIO SELECCION CRUZA MUTACION
A ARCHIVO ADYACENCI N DE
A POBLACION
HILOS SECUENCIA N N SECUENCIA SECUENCIA SECUENCIA
L L L L

10
PROGRAMA
/*
================================================================
Name : GENECOMBI.c
Author : Gustavo
================================================================
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <omp.h>
#include <time.h> // time()
#define NC 100

int ii, suma;

typedef struct {
int p[NC];
int aptitud;
} individuo;

// Metodo que calcula la aptitud de una permutacion .

int aptitud(int n, int p[n],int grafo[n][n] ) {
suma=0;

for (ii = 1; ii < n; ii++) {

suma += grafo[p[ii - 1]][p[ii]];
}
suma += grafo[p[n - 1]][p[0]];
return suma;
}

//Metodo para imprimir la ruta de cada individuo

void imprime(int *p,int n){
printf("\n[ ");
for (ii = 0; ii < n; ii++) {
printf("%d ",p[ii]);
}
printf("]\n");
}

int main(){
double time1 = omp_get_wtime();
FILE *archivo;
int i,j,k,l;
int n,m,r;
int max,min;
int total = 0;
int num;
int primero, segundo,temp; // variables para mutacion

11
 int generaciones=10000,indiceCruza;
individuo h[2],p1,p2; //hijos y padres auxiliares
int idp1,idp2;// indices de padres

archivo=fopen("kroA100.tsp","r");
if (archivo == NULL) {
printf("No se encontro el archivo\n");
return 0;
}
else{printf("Archivo TSP leido con exito\n");}
fscanf(archivo,"%d",&n);

m = 2 * n; //tamaño de la poblacion
int grafo[n][n]; // matriz de adyacencia
individuo poblacion[m]; //arreglo de individuos = POBLACION
int numeros[n]; // arreglo individuos sin repetir
int coordenadas[n][2];
indiceCruza=n*0.5; //valores que se van a intercambiar ne la
cruza

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

int nada;
fscanf(archivo, "%d", &nada);
for (j = 0; j < 2; j++) {

fscanf(archivo, "%d", &nada);

coordenadas[i][j] = nada;
}
}
fclose(archivo);

//PASANDO DISTANCIAS A GRAFO-----------------------------------------

--------
double dx, dy;

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

#pragma omp parallel for private(j,dx,dy)
for (j = 0; j < i; j++) {
dx = coordenadas[i][0] - coordenadas[j][0];

dy = coordenadas[i][1] - coordenadas[j][1];
grafo[i][j] = grafo[j][i] = round(sqrt(dx * dx + dy * dy));
}
grafo[i][i] = 0;
}
fclose(archivo);

//--POBLACION INICIAL RANDOM

srand (time(NULL));
printf("1)Poblacion Inicial \n");
#pragma omp parallel for private(total,num,numeros)
for(i=0;i<m;i++)
{
total = 0;

12
 #pragma omp parallel for
for(j=0;j<n;j++)
numeros[j] = 0;

//Se genera una ruta aleatoria

while( total < n)
{
num = rand()%n;
if(numeros[num]== 0)
{
numeros[num] = 1;
poblacion[i].p[total] = num;
total++;
}
}
//calculo de la distancia
poblacion[i].aptitud = aptitud(n,poblacion[i].p,grafo);
//imprime(poblacion[i].p,n);
//printf("APTITUD: [%d]",poblacion[i].aptitud);
}

printf("G E N E R A C I O N E S \n");
//Seleccionar los peores individuos

for(i=0;i<generaciones;i++){
printf("Iteracion %d de %d\n",i+1,generaciones);
r = rand()%m;

//------S E L E C C I O N
for (j = 0; j < r; j++) {
//r numero de individuos a seleccionar J indice
// cambiar el peor por un hijo
// de dos en dos porque va por parejas de padres
total = 0;
min = INT_MAX;
max =0;
num = 0;
temp = -1;

for( k = 0; k < n ; k++ ){

numeros[k] = 0; //verificar repeticiones
h[0].p[k] = -1; //hijo1 inicializar en -1
h[1].p[k] = -1; //hijo2 inicializar en -1
p1.p[k] = 0;//padre1 inicializar en 0
p2.p[k] = 0;//padre 2 inicializar en 0
}
//SELECCION DE DOS PADRES AL AZAR

//Seleccion primer padre

idp1 = rand()%m;
//Seleccion segundo padre
idp2 = rand()%m;
while( idp2 == idp1){
idp2 = rand()%m;
}//Buscando padres diferentes

//--------------C R U Z A POSITION-BASED-CROSSOVER

13
 //1)Elegir valores de P1-creacion de secuencia
while( total < indiceCruza ){
num = rand()%n;
if ( numeros[num] ==0 ){
numeros[num] = 1;
total++;
}
}
//2)Producir H1 y H2 eliminar la no ecuencia
//3)Borrar de padre contrario la secuencia
for(k=0;k<n;k++){
if(numeros[k]!=0){//k posicion
l=0;
while(poblacion[idp1].p[l]!=k){
l++;
}
h[0].p[l]=k;//paso 2
p1.p[l]=1;//paso 3

l=0;
while(poblacion[idp2].p[l]!=k){
l++;
}
h[1].p[l]=k;//paso 2
p2.p[l]=1;//paso 3
}
}
//4)De izquierda a derecha - Padre opuesto a hijo
//hijo inicializacion -1
//padre inicializacion 0
for(k=0;k<n;k++){
if(h[0].p[k]==-1){
l=0;
while(p2.p[l]!=0){
l++;
}
h[0].p[k]=poblacion[idp2].p[l];
p2.p[l]=1;
}

if(h[1].p[k]==-1){
l=0;
while(p1.p[l]!=0){
l++;
}
h[1].p[k]=poblacion[idp1].p[l];
p1.p[l]=1;
}
}

//--------------M U T A INTERCAMBIO RECIPROCO

//Mutamos y calculamos el fitness

primero = rand()%n;
segundo = rand()%n;
while( primero == segundo ){
segundo= rand()%n;

14
 }

for (k = 0; k < 2; k++) {

temp = h[k].p[primero];
h[k].p[primero] = h[k].p[segundo];
h[k].p[segundo] = temp;
h[k].aptitud = aptitud(n,h[k].p,grafo);
}

//MAYOR DE LOS DOS PADRES

temp = -1;
if(max < poblacion[idp1].aptitud){
max = poblacion[idp1].aptitud;
num = idp1;
}
if(max < poblacion[idp2].aptitud) {
max = poblacion[idp2].aptitud;
num = idp2;
}

if(min>h[0].aptitud){
min=h[0].aptitud;
temp=0;
}
if(min>h[1].aptitud){
min=h[1].aptitud;
temp=1;
}

// I N T E R C A M B I O mejor de los hijos por peor de los padres

if(poblacion[num].aptitud> h[temp].aptitud){
for (k = 0; k <=n; k++) {
poblacion[num].p[k] = h[temp].p[k];
}
poblacion[num].aptitud=h[temp].aptitud;
}

}//FINAL R INDIVIDUOS DE SELECCION

}//FINAL GENERACIONES

//Buscamos la mejor ruta

min = INT_MAX;
for(i=0;i< m;i++ ){
if( poblacion[i].aptitud<min){
min = poblacion[i].aptitud;
temp = i;
}
}
//Imprimir la mejor ruta
printf("Mejor ruta:\n[ ");
for (i = 0; i < n; i++) {
printf("%d ",poblacion[temp].p[i]);
}

printf(" ] \nAptitud= %d",poblacion[temp].aptitud);

double time2 = omp_get_wtime();
printf("\nTime: %lf\n", time2 - time1);

15
 return 0;
}

RESULTADOS
Archivos TSP LIB a evaluar
ARCHIVO pr76.tsp SOLUCION = 108159

APTITUD TIME
120113 8.371
125753 8.35
122432 8.395
118998 8.448
179122 8.445
173553 8.242
124450 8.39
111565 8.306
119598 8.663
126904 8.165
137368 8.48
148371 8.506
119894 8.402
124630 8.256
113448 8.334
112996 8.497
112305 8.428
121873 8.412
155736 8.318
130764 8.436
137484 8.327
129138 8.379
115360 8.304
133920 8.248 PARALELO
151615 8.273 No de Generaciones 4000
125472 8.353 Porcentaje de cruza 40%
113834 8.32 Porcentaje de muta 100%
118695 8.301 Número de corridas 30
154185 8.242 Aptitud promedio 129669.0667
110496 8.313 Tiempo promedio(seg) 8.363466667
129669.067 8.36346667

16
CARACTERISTICAS COMPUTADORA: 3 RAM, 2 HILOS.
APTITUD TIME
135756 9.214
124355 9.241
113938 9.182
137909 9.421
126410 9.473
170711 9.295
115520 9.001
135851 9.27
146454 9.112
129325 9.194
151391 9.212
160878 9.325
148057 9.302
130626 9.132
134903 9.233
115160 9.292
154718 9.412
131903 9.325
115175 9.241
121404 9.222
187091 9.23
128818 9.982
153648 9.413
123725 9.331 SECUENCIAL
142083 9.272 No de Generaciones 4000
176115 9.316 Porcentaje de cruza 40%
158376 9.032 100%
Porcentaje de muta
147788 9.312
Número de corridas 30
160546 9.394
Aptitud promedio 139925.1
119119 9.224
Tiempo promedio(seg) 9.286833333
139925.1 9.28683333

CARACTERISTICAS COMPUTADORA: 3 RAM, 2 HILOS.

17
 ARCHIVO kroA100.tsp SOLUCION = 21282
APTITUD TIME
24432 30.551
26211 30.266
33665 30.688
24136 30.471
23812 30.201
35033 30.523
23146 30.678
29340 30.477
45955 29.639
22750 29.64
34934 30.256
40683 29.964
24837 30.137
25741 30.341
23356 29.405
22193 29.739
26045 29.874
23479 30.178
33412 30.276
40629 30.305
31477 29.7
34120 29.895
25451 30.014
33771 30.129
25125 30.045
29413 30.122
25622 30.037
23856 29.396
37089 30.597
42747 30.249
29748.66667 30.12643333

18
 PARALELO
No de Generaciones 4000
Porcentaje de cruza 40%
Porcentaje de muta 100%
Número de corridas 30
Aptitud promedio 29748.66667
CARACTERISTICAS 30.12643333
Tiempo promedio(seg)
COMPUTADORA: 4
RAM, 4 HILOS.

APTITUD TIME
27082 33.1
40168 33.2
22837 33.44
31756 33.58
26563 34.16
38486 33.43
49303 33.59
23579 33.59
24121 33.71
40071 33.61
30457 33.61
24725 33.6
24809 33.3
47073 33.54
28755 33.28
21828 33.93
37409 33.5
24409 33.31
34342 33.62
43055 33.45
26695 33.81
31582 33.65
38076 33.44
23935 34
22670 33.34
41776 33.85
23033 33.68
39542 33.79
24393 34.89

19
 SECUENCIAL
No de Generaciones 4000
Porcentaje de cruza 40%
Porcentaje de muta 100%
25487 35.22 Número de corridas 30
31267.23333 33.674 Aptitud promedio 31267.23333
Tiempo promedio(seg) 33.674

CARACTERISTICAS COMPUTADORA: 4 RAM, 4 HILOS.

CONCLUSIONES

Los resultados sé que obtuvieron por los casos de prueba de las instancias
TSPLIB llevando a cabo un algoritmo Genético y llevando la estructura de
ciertos métodos para poder llegar a una solución cercana a la óptima fueron
favorables. Tal vez con un alejamiento a la solución pero con resultados que si
demostraron que la eliminación de individuos no aptos en un algoritmo
genético se aplicó.
La razón de la paralización al sacar la matriz de adyacencia y la creación de la
población inicial fue para poder reducir el tiempo dentro de la ejecución, hubo
cambio pequeño de un par de segundos al ejecutar en instancias menores.
En ambos casos de los resultados mostrados se optó por una muta del 100% y
un porcentaje de cruza del 40% , se escogió de igual forma el número de
iteraciones después de varias pruebas, mientras más aumenta el porcentaje de
cruza más se aleja del resultado que se quiere buscar.
En cada iteración o generación solo se elimina un número de individuos
escogidos por el mejor de sus hijos y se realiza todo el proceso de cruza y
muta dentro de la selección, por tal motivo es rápido el proceso al ejecutarse.
Los resultados promedios de las corridas paralelas fueron mejor y más
cercanos al resultado buscado.

20