ALGORITMO DE OPTIMIZACIÓN POR COLONIA DE HORMIGAS

(ACO)

INTRODUCCIÓN

El problema del viajero consiste en el recorrido de aristas para determinar la ruta

cuya solució n permite al viajero llegar a su destino siendo ésta la ó ptima debido a que
es la de menor costo en comparació n con las demá s rutas.

El problema del viajero tiene numerosas aplicaciones en las que resaltan el recorrido
de un transporte escolar, paquetería y correo,  Agencia de viajes (Tours) entre otras.
La dificultad de éste problema es que conforme aumenten el nú mero de nodos,
aumentará n las rutas y por lo tanto las combinaciones se incrementarían.

É ste problema puede resolverse con ACO, pero ¿qué es ACO? Por sus siglas en inglés
Ant Colony Optimization (Optimizació n Colonia de Hormigas), se le llama así porque
simula el comportamiento de las hormigas desde su hormiguero a la fuente de comida.
Mientras se mueven entre estos dos puntos van dejando un rastro de feromona que
ayuda a determinar un camino ó ptimo que las demá s hormigas puedan seguir.

La relació n de ACO con el problema del viajero es que ésta técnica utiliza la
probabilidad para resolver problemas donde su solució n sea el mejor camino o ruta
en un grafo siendo este el objetivo del problema del viajero.

MARCO  TEÓRICO

El problema consiste en un viajante que tienen un nú mero de destinos los cuales debe
visitar, puede partir de cualquier punto con la condició n de regresar al mismo. Los
demá s destinos solo pueden ser visitados una vez por recorrido. El objetivo es
recorrer los lugares cuidando que la ruta sea la de menor costo.
Se representa con la estructura de grafo debido a que sus nodos simbolizan ciudades y
las ramas los caminos que puede recorrer siendo la conexió n de los lugares. Se
considera un problema NP-completo ya que es un algoritmo no eficiente, pero existe
la validació n para la supuesta solució n

En una instancia de éste problema involucra al viajero, el nú mero de destinos(nodos)

a los que llegará segú n el objetivo, los caminos y rutas ( ramas) que viene siendo la
matriz de costos ( el mapa del recorrido) que conectará n dichos lugares con cierto
costo o peso que determinará n el tamañ o de la ruta de modo que se elija la ó ptima.

A continuació n se mostrará una instancia resuelta por fuerza bruta donde se verá con
mayor claridad la estructura de grafo del problema.

INSTANCIA POR FUERZA BRUTA

Realizamos un ejemplo para poder resolverlo por fuerza bruta; es decir crear todas las
combinaciones posibles para que del estado inicial se recorran todos los nodos a
través de las aristas regresando al lugar de inicio sin pasar 2 veces o má s por un
mismo nodo.
El objetivo es identificar por este método cuá l es el camino ó ptimo para realizar el
recorrido.

Instancia: Un niñ o tiene que hacer un recorrido que su madre le ordenó , no importa
donde empiece solo tiene que terminar en el mismo sitio con la restricció n ya
especificada anteriormente. Consiste en pasar por cada uno de los lugares e intentar
hacerlo en el menor tiempo posible, los nú meros que se encuentran en la imagen son
la cantidad de calles que el niñ o tiene que atravesar para ir de un lugar a otro, también
se muestran los 5 lugares a los que tiene que ir. La solució n trata en encontrar el
recorrido por donde el niñ o cruce menos calles para disminuir el tiempo del traslado.
Solución:

Como vamos a estar trabajando con varias combinaciones será un poco tedioso estar
viendo todo el nombre del lugar por lo que decidimos poner solo una letra que
identifique a cada uno de ellos.

Tienda=A
Florería=B
Tortillería=C
Carnicería=D
Panadería=E

Ahora empezamos a buscar todas las combinaciones posibles, nosotros preferimos

usar á rboles para cada uno de los lugares. Así como se muestra en la siguiente imagen,
hicimos el mismo procedimiento para B, C ,D y E:
A partir de las combinaciones obtenidas de los á rboles se consiguió la siguiente tabla:

Inicia y Inicia y Inicia y Inicia y Inicia y

termina en A termina en B termina en C termina en D termina en E
A,B,C,D,E,A B,A,C,D,E,B C,A,B,D,E,C D,A,B,C,E,D E,A,B,C,D,E
A,B,C,E,D,A B,A,C,E,D,B C,A,B,E,D,C D,A,B,E,C,D E,A,B,D,C,E
A,B,D,C,E,A B,A,D,C,E,B C,A,D,B,E,C D,A,C,B,E,D E,A,C,B,D,E
A,B,D,E,C,A B,A,D,E,C,B C,A,D,E,B,C D,A,C,E,B,D E,A,C,D,B,E
A,B,E,C,D,A B,A,E,D,C,B C,A,E,B,D,C D,A,E,C,B,D E,A,D,B,C,E
A,B,E,D,C,A B,A,E,C,D,B C,A,E,D,B,C D,A,E,B,C,D E,A,D,C,B,E,
A,C,B,D,E,A B,C,A,D,E,B C,B,A,D,E,C D,B,A,C,E,D E,B,A,C,D,E
A,C,B,E,D,A B,C,A,E,D,B C,B,A,E,D,C D,B,A,E,C,D E,B,A,D,C,E
A,C,D,B,E,A B,C,D,A,E,B C,B,D,A,E,C D,B,C,A,B,D E,B,C,A,D,E
A,C,D,E,B,A B,C,D,E,A,B C,B,D,E,A,C D,B,C,B,A,D E,B,C,D,A,E
A,C,E,B,D,A B,C,E,D,A,B C,B,E,A,D,C D,B,E,A,C,D E,B,D,A,C,E
A,C,E,D,B,A B,C,E,A,D,B C,B,E,D,A,C D,B,E,C,A,D E,B,D,C,A,E
A,D,B,C,E,A B,D,A,C,E,B C,D,A,B,E,C D,C,A,B,E,D E,C,A,B,D,E
A,D,B,E,C,A B,D,A,E,C,B C,D,A,E,B,C D,C,A,E,B,D E,C,A,D,B,E
A,D,C,B,E,A B,D,C,A,E,B C,D,B,A,E,C D,C,B,A,E,D E,C,B,A,D,E
A,D,C,E,B,A B,D,C,E,A,B C,D,B,E,A,C D,C,B,E,A,D E,C,B,D,A,E
A,D,E,B,C,A B,D,E,A,C,B C,D,E,A,B,C D,C,E,A,B,D E,C,D,A,B,E
A,D,E,C,B,A B,D,E,C,A,B C,D,E,B,A,C D,C,E,B,A,D E,C,D,B,A,E
A,E,B,C,D,A B,E,A,C,D,B C,E,A,B,D,C D,E,A,B,C,D E,D,A,B,C,E
A,E,B,D,C,A B,E,A,D,C,B C,E,A,D,B,C D,E,A,C,B,D E,D,A,C,B,E
A,E,C,B,D,A B,E,C,A,D,B C,E,B,A,D,C D,E,B,A,C,D E,D,B,A,C,E
A,E,C,D,B,A B,E,C,D,A,B C,E,B,D,A,C D,E,B,C,A,D E,D,B,C,A,E
A,E,D,B,C,A B,E,D,A,C,B C,E,D,A,B,C D,E,C,A,B,D E,D,C,A,B,E
A,E,D,C,B,A B,E,D,C,A,B C,E,D,B,A,C D,E,C,B,A,D E,D,C,B,A,E

  

Como una de las restricciones es que el recorrido comienza en el mismo lugar donde
finaliza, eso nos permite eliminar unas cuantas combinaciones esto porque coinciden
con otras al momento de leerlas inversamente, por lo que al momento de hacer la
suma de las calles que se pasan en cada recorrido nos dará n el mismo resultado.

Inicia y termina Inicia y Inicia y Inicia y Inicia y

en A termina en B termina en C termina en D termina en E
A,B,C,D,E,A=28 B,A,C,D,E,B=34 C,A,B,D,E,C=37 D,A,B,C,E,D=27 E,A,B,C,D,E=28
A,B,C,E,D,A=27 B,A,C,E,D,B=37 C,A,B,E,D,C=34 D,A,B,E,C,D=27 E,A,B,D,C,E=30
A,B,D,C,E,A=30 B,A,D,C,E,B=36 C,A,D,B,E,C=27 D,A,C,B,E,D=25 E,A,C,B,D,E=29
A,B,D,E,C,A=37 B,A,D,E,C,B=27 C,A,D,E,B,C=25 D,A,C,E,B,D=27 E,A,C,D,B,E=28
A ,B,E,C,D,A=26 B,A,E,D,C,B=28 C,A,E,B,D,C=28 D,A,E,C,B,D=21 E,A,D,B,C,E=21
A,B,E,D,C,A=34 B,A,E,C,D,B=30 C,A,E,D,B,C=29 D,A,E,B,C,D=18 E,B,A,C,D,E=34
A,C,B,D,E,A=29 B,C,A,D,E,B=25 C,B,A,D,E,C=27 D,B,A,C,E,D=37 E,B,A,D,C,E=26
A,C,B,E,D,A=25 B,C,A,E,D,B=29 C,B,A,E,D,C=28 D,B,A,E,C,D=30 E,B,C,A,D,E=25
A,C,D,B,E,A=28 B,C,D,A,E,B=18 C,B,D,A,E,C=21 D,B,C,A,B,D=25 E,B,D,A,C,E=27
A,C,D,E,B,A=34 B,C,E,A,D,B=21 C,B,E,A,D,C=18 D,B,E,A,C,D=28 E,C,A,B,D,E=37
A,C,E,B,D,A=27 B,D,A,C,E,B=27 C,D,A,B,E,C=26 D,C,A,B,E,D=34 E,C,A,D,B,E=27
A,C,E,D,B,A=37 B,D,C,A,E,B=28 C,D,B,A,E,C=30 D,C,B,A,E,D=28 E,C,B,A,D,E=27
A,D,B,C,E,A=21
  A,D,C,B,E,A=18

Después de utilizar el método de fuerza Bruta para hacer los recorridos por los 5
lugares pudimos identificar los caminos ó ptimos que el niñ o puede tomar para
cumplir el objetivo de ir a los 5 lugares recorriendo el camino con menos calles.

Como se había dicho anteriormente el problema se puede resolver con el algoritmo

ACO por sus siglas en inglés Ant Colony Optimization (Optimizació n Colonia de
Hormigas)
Este algoritmo relativamente reciente (1992) por su creador Marco Dorigo es un
ejemplo metahurístico. La metahurística involucra conceptos de genética, biología,
inteligencia artificial, matemá ticas entre otras. 
Se basa en la metá fora natural del comportamiento de hormigas para encontrar los
caminos má s cortos entre las fuentes de comida y el hormiguero. También se puede
decir que sigue a la inteligencia de enjambre ya que se basa en la conducta de auto
organizació n como lo es ACO, el alineamiento de aves de vuelo, rebañ os y cardú menes.

Enseguida se muestra un diagrama de flujo del proceso que sigue ACO.

Es importante explicar las fó rmulas relevantes en ACO; actualizació n de feromona y
evaporació n de feromona.  A continuació n una explicació n sencilla y breve de estas
fó rmulas.

SELECCIÓ N DE CAMINO
La Actualización de Feromona se da cuando se deposita la feromona y luego se evapora, así
para cada hormiga

UN POCO DE LO QUE ENCONTRARÁS...

En esta entrada del blog se divide en secciones.

Marco Teó rico donde se muestra informació n general sobre ACO para entender y
tener una mejor idea del algoritmo ademá s de datos sobre su origen y relació n con el
comportamiento de Hormigas.
En la secció n de Desarrollo se mostrará el funcionamiento a partir de las fó rmulas,
empezando por explicar có mo funciona el algoritmo relacionado con el problema del
viajero para después presentar la codificació n de ACO  mostrando su comportamiento.
Se mostrará n ademá s, en esta secció n, los pará metros que utilizamos por ejemplo, la
cantidad de hormigas, la tasa de evaporació n, el valor inicial de la feromona , etc.

Para aclarar puntos sobre el problema del viajero se han creado dos instancias, una de
pocas ciudades y otra de 10 ciudades para mostrar el representar del problema del
viajero de forma grá fica y por medio de un generador de instancias.

Finalmente se mostrará n los resultados y las conclusiones de la prá ctica. 

DESARROLLO

El problema del viajero (TSP; Traveling Salesman Problem) como se explicó

anteriormente, consta de un viajante  que tiene un nú mero de destinos los cuales debe
visitar, puede partir de cualquier punto con la condició n de regresar al mismo. Los
demá s destinos solo pueden ser visitados una vez por recorrido. El objetivo es
recorrer los lugares cuidando que la ruta sea la de menor costo. La relació n que tiene
con el algoritmo ACO se enfoca en que ambos tienen distintas posibilidades de llegar a
su objetivo pero tienen que determinar el de menor costo para convertirlo en la ruta
ó ptima.

Algoritmo
Inicializació n del algoritmo.
void Dibujar_instancia(int Distancias,double Costos)
{
system("cls");
srand(time(NULL));

//Distancias
cout<<"\nDISTANCIAS:\n";
for(i=0;i&alt;Nodos;i++)
{
for(j=i;j<(Nodos);j++)
{
if(j==i)
{
Distancias[i][j]=0;
}else
{
num=1+rand()%(21-1);
Distancias[i][j]=num;
Distancias[j][i]=num;
}
}
for(j=0;j<Nodos;j++)
{
cout<<setw(4)<<Distancias[i][j];
 }
cout<<"\n";
}

//Costos
cout<<"\n\nCOSTOS\n";
for(i=0;i<Nodos;i++)
{
for(j=0;j<Nodos;j++)
{
if(i==j)
{
Costos[i][j]=0;
}else
{
Costos[i][j]=(1/(float)Distancias[i][j]);
}
cout<<" "<<setw(6)<<setprecision(3)<<Costos[i][j];
}
cout<<"\n";
}

//Feromonas
cout<<"\n\nFEROMONAS:\n";
for(i=0;i<Nodos;i++)
{
for(j=i;j<Nodos;j++)
{
if(j==i)
{
Feromonas[i][j]=0;
}else
{
num=1+rand()%(100-1);
numf=(float)num/100;
Feromonas[i][j]=numf;
Feromonas[j][i]=numf;
}
}
for(j=0;j<Nodos;j++)
{
cout<<" "<<setw(5)<<setprecision(5)<<Feromonas[i][j];
}
cout<<"\n";
}
return;
}

void Elegir_CiudadInicio(int Recorridas[Nodos])

{
desde=0;hacia=0;
toper=0;
r=0;
desde=(0+rand()%(Nodos-1));
Recorridas[r][0]=desde;
toper=r;
 return;
}

int main()
{
cout<<"Numero de nodos: ";
cin>>Nodos;
int Distancias[Nodos][Nodos];
float Feromonas[Nodos][Nodos];
double Costos[Nodos][Nodos];
int Recorridas[Nodos][Nodos], Proximas[Nodos][Nodos];
Dibujar_instancia(Distancias,Costos);
for(I=1;I<=5;I++)//5 veces
{
Elegir_CiudadInicio(Recorridas);
for(H=1;H<=3;H++)//para cada hormiga
{
Seleccion_deCamino(Feromonas,Costos,Proximas,Recorridas);
Moverse();
Sumar_Costo();
}
DepositarFeromonas(Feromonas);
ImprimirMejorCamino();
}
ImprimirResultados();
system("PAUSE");
}

Selecció n de la siguiente Arista

void Seleccion_deCamino(float Feromonas[Nodos][Nodos], double
Costos[Nodos][Nodos],int Recorridas[Nodos],int Proximas[Nodos])
{
while(toper<=Nodos)
{
int si_esta;
Proximas={0};

i=0;
for(q=0;q<Nodos;q++)
{
si_esta=0;
if(Recorridas[toper]=q)
{
si_esta=1;
}else
{
for(l=0;l<=toper;l++)
{
if(q=Recorridas[l])
{
si_esta=1;
}
}
}
if(si_esta=0)
{
 Proximas[i]=q;
topep=i;
i++;

}
}

//Probabilidades y cachos
double arriba,abajo;
for(i=0;i<=topep;i++)
{
arriba=0;
abajo=0;

arriba=(pow((Feromonas[(Recorridas[toper])]
[(Proximas[i])]),1)*pow((Costos[(Recorridas[toper])][(Proximas[i])]),1));
for(l=0;l<=topep;l++)//sumatoria de abajo ;)
{
abajo=abajo+((Feromonas[(Recorridas[toper])]
[(Proximas[l])])*(Costos[(Recorridas[toper])][(Proximas[l])]));
}
Probabilidad[i]=(arriba/abajo);
}

i=0;l=0;
while(i<=100)
{
for(ii=0;ii<=(Probabilidad[l]*100);ii++)
{
Ruleta[i]=Proximas[l];
i++;
}
l++;
}
num=0+rand()%(99-0);
//agregar a cds recorridas
hacia=Ruleta[num];

Recorridas[toper][1]=hacia;
toper++;
desde=hacia;
Recorridas[toper][0]=desde;
}
return;
}
 
Actualizació n de la feromona
void DepositarFeromonas(float Feromonas[Nodos][Nodos])
{
float nuevafer,sumatoriaLK;

for(i=0;i<toper;i++)
{
sumatoriaLK+=Feromonas[(Recorridas[i])][(Recorridas[1])]
}
 sumatoriaLK+=(1/Nodos);

for(i=0;i<Nodos;i++)
{
for(j=i;j<Nodos;j++)
{
if(j==i)
{
Feromonas[i][j]=0;
}else
{
nuevafer=((1-0.5)*Feromonas[i][j])+ssumatoriaLK;
Feromonas[i][j]=nuevafer;
Feromonas[j][i]=nuevafer;
}
}
}
return;
}

INSTANCIA 1

El siguiente có digo es el que nos proporciona valores aleatorios ordenados en una

matriz para las instancias del problema del viajero.
El rango de valores que nos puede imprimir este có digo es de 0 a 99.

En seguida se muestra 2 ejecutables del có digo anterior  en el que podremos observar

que los valores de la diagonal principal son ceros ya que la distancia de un punto hacia
ese mismo punto es cero.
En este caso generamos una matriz de 6x6.  Instancia 1.
Así nos quedaría la matriz de la corrida anterior (instancia1).

Este mapa de destinos corresponde a la instancia 1 

Decidimos aumentar un poco la dificultad para que se aprecie mejor cómo funciona el
generador de instancias.

INSTANCIA 2

Ahora generamos una matriz de 10x10.

A partir del ejecutable anterior (instancia 2) podremos acomodar los datos en una
matriz que nos quedaría así
Este mapa de destinos corresponde a la instancia 2

CONCLUSIÓN
En conclusión de ACO…
El algoritmo ACO aunque de principio parecía fácil, ya que el concepto que utiliza es muy
sencillo de entender, al programarlo no resulto de esa forma, incluso nos causó muchas
confusiones, mismas que se fueron solucionando al ir desenvolviendo el problema y
dividiéndolo parte por parte. Por lo que este algoritmo a pesar de tener muchos pasos a
seguir, puede ser programado y reutilizado para más problemas no solo con el problema del
viajero.
Pero también entendemos que es mucho mejor opción utilizar este algoritmos para resolver
el problema del viajero, a resolverlo por fuerza bruta, ya que con instancias muy grandes
podríamos tardar realmente demasiado tiempo en resolver.