Estado Del Arte Final

Proyecto Algoritmos genéticos incrementales
Federico Dominioni - Pablo Musso
Estado del arte
Proyecto Algoritmos Genéticos Incrementales
Año 2003

ÍNDICE
1 INTRODUCCIÓN.....................................................................................................4
1.1 Objetivo.............................................................................................................4
1.2 Definiciones y Siglas.........................................................................................4
1.3 Avances..............................................................................................................4
1.4 Algoritmos Genéticos........................................................................................5
1.4.1 Introducción...............................................................................................5
1.4.2 Computación evolutiva:.............................................................................5
1.4.3 Algoritmo Genético Simple.......................................................................7
1.4.4 Operadores de Selección.........................................................................10
1.4.5 Operadores de Cruzamiento y Mutación.................................................10
1.4.6 Otros Operadores Genéticos Operadores de Ordenamiento e Inversión.12
1.4.7 La base de su funcionamiento: Definiciones Previas..............................14
1.4.8 El Teorema de los Esquemas...................................................................15
1.4.9 Paralelismo Implícito y Desventajas de la Teoría...................................17
1.4.10 Como hacer para resolver mi problema con un AG................................18
1.4.11 Dominancia y Diploides.........................................................................18
2 Paralelismo..............................................................................................................20
2.1 ¿Porqué paralelizar?........................................................................................20
2.2 Modelo Maestro – Esclavo..............................................................................20
2.3 Modelos de grano grueso.................................................................................22
2.4 Modelos celulares............................................................................................24
2.5 Modelos particulares......................................................................................25
2.5.1 Adaptive Hierarchical Fair Competition Model for Parallel Evolutionary
Algorithms:..............................................................................................................26
2.5.2 Algoritmos genéticos incrementales:......................................................26
2.5.3 Otros modelos..........................................................................................27
2.6 Conclusión final:.............................................................................................27
3 Bibliotecas de algoritmos genéticos........................................................................27
3.1 Introducción.....................................................................................................27
3.2 GALLOPS.......................................................................................................28
3.2.1 Presentación.............................................................................................28
3.2.2 Funcionalidades.......................................................................................29
3.2.3 Ventajas y desventajas.............................................................................30
3.3 EO....................................................................................................................30
3.3.1 Presentación:............................................................................................30
3.3.2 Funcionalidades:......................................................................................30
3.3.3 Ventajas y desventajas:............................................................................33
3.4 Galib................................................................................................................33
3.4.1 Presentación:............................................................................................33
3.5 PGAPACK.......................................................................................................34
3.5.1 Presentación:............................................................................................34
3.6 GECO..............................................................................................................35
3.6.1 Presentación:............................................................................................35
3.6.2 Funcionalidades.......................................................................................35
3.6.3 Ventajas y desventajas:......................................................................................36
3.7 SUGAL............................................................................................................37
3.7.1 Presentación:............................................................................................37
3.8 MALLBA........................................................................................................37
3.8.1 Presentación:............................................................................................37
3.9 Conclusiones finales:.......................................................................................38
4 Referencias..............................................................................................................39
1 INTRODUCCIÓN
1.1 Objetivo
El documento presenta los conceptos básicos acerca de algoritmos evolutivos y en particular (y con
mayor profundidad) presenta conceptos acerca de los algoritmos genéticos con el objetivo de comprender
su utilidad y funcionamiento así como también familiarizarse con el vocabulario el cual es utilizado en los
sucesivos documentos del proyecto. Además se presentarán a los algoritmos genéticos paralelos junto con
una clasificación, lo cual es fundamental para comprender el problema planteado a resolver en este
proyecto. También se presentan bibliotecas que existen actualmente en la comunidad científica para la
utilización así como desarrollo de algoritmos genéticos.
Por lo cual este documento podría ser de utilidad para aquellos lectores que sin tener un gran
conocimiento en el área de computación evolutiva quisieran interiorizarse en la misma así como también
para aquellos lectores experimentados que quisieran informarse acerca de las actuales posibilidades reales
de implementación a la hora de abordar un trabajo utilizando algoritmos evolutivos.
1.2 Definiciones y Siglas
Sigla Significado
EA Algoritmo evolutivo
AG Algoritmo genético
AGP Algoritmo genético paralelo
AGS Algoritmo Genético Simple
1.3 Avances
Este documento esa estructurado en 3 capítulos, en el cual en los dos primeros capítulos se explican los
conceptos más relevantes de los AG así como también sus ventajas y desventajas a la hora de paralelizar
dichos modelos estableciendo una clasificación para los mismos (decimos una clasificación debido a que
actualmente no existe una clasificación universal) ; finalmente en el tercer capitulo se presentan diferentes
bibliotecas para trabajar con algoritmos genéticos
En el capítulo 1 introducimos al lector en los algoritmos genéticos secuenciales, de dónde provienen, la

justificación de su uso, problemas ,e tc.
En el capítulo 2 nos centramos en los algoritmos genéticos paralelos. Damos una descripción de los
modelos más importantes de paralelismo y algunos modelos particulares.
En el capítulo 3 nos centramos en la caracterización y descripción de diferentes paquetes (bibliotecas) de
algoritmos genéticos, comentando sus ventajas y desventajas.
1.4 Algoritmos Genéticos
1.4.1 Introducción
En el presente capitulo se presentaran aquellos conceptos fundamentales sobre los algoritmos genéticos
así como también se explicará mediante un poco de teoría la base de su funcionamiento.
Cabe destacar que todos los conceptos tratados en este capítulo son referidos a algoritmos genéticos
secuenciales, la paralelización de dichos modelos será tratada en el capitulo siguiente
1.4.2 Computación evolutiva:
El hombre se ha maravillado desde siempre con la naturaleza de la vida. En particular, ha sido de interés
el estudio de conceptos tales como:
 evolución de la especie
 supervivencia del mas apto
 competitividad
 herencia y conformación de la descendencia.
 Aprendizaje
Por otro lado, existe en el hombre un deseo profundo de poder reproducir la habilidad cognoscitiva por
medios artificiales. El interés del hombre por comprender y estudiar como se desarrolla la inteligencia
con fines de poder reproducirla con ayuda de la computadora, ha despertado la aparición de toda una
rama íntegra de estudio científico llamada “Inteligencia Artificial”.
Cabe destacar que la inteligencia es solo parte del resultado del proceso de evolución de las especies. Han
ocurrido cambios físicos notorios desde el primer organismo unicelular hasta el hombre.
Si bien hoy en día la teoría de Darwin es casi indiscutida en el ámbito científico, existen divergencias
acerca de cómo interpretar la manera en que evolucionó la vida. La Hipótesis Pro Evolución
Acumulativa es en la que se basan todos los algoritmos evolutivos. Aquí la vida se desarrolla a partir de
las mejoras introducidas por la naturaleza en las generaciones pasadas, por lo que las capacidades
adquiridas de generación en generación se acumulan.
De todas maneras se acepta que mutación al azar existe y ésta es tomada en cuenta , sin embargo se
concuerda que ella es causante solo de pequeños cambios y que las grandes variaciones evolutivas están
dadas a través de la descendencia de los individuos mas aptos, por lo cual la siguiente generación obtiene
una acumulación de sus características sumadas a las propias.
El gráfico 1 muestra el patrón típico de la evolución acumulativa, como se puede apreciar algunos
ejemplares heredarían las características de los padres; la evolución de éstas a largo del tiempo semejarán
a una función creciente con intervalos de fuerte crecimiento e intervalos aproximadamente constantes de
estancamiento relativo.
Figura 1: Patrón de la evolución acumulativa
Apoyados en esta teoría los EA buscan resolver diversos problemas a partir de una población de
individuos (cada uno representando una posible solución), donde se imponen a los individuos en una
situación de competitividad por su supervivencia, en la cual los ejemplares más adaptados al entorno
sobrevivirán (una especie de "ley de la selva" virtual en donde sólo los fuertes sobreviven). A su vez
dichos individuos bien adaptados se recombinan con otros (también bien adaptados) para formar nuevos
individuos (los cuales podrían llegar a tener las características genéticas distintivas de ambos padres, lo
cual
por un efecto sinérgico podría llegar a ser incluso ser mejor que la suma de las partes) quienes pasaran a
formar parte de la siguiente generación.
Se impone de esta forma una estructura de generaciones en la cual a través de cada una de las mismas se
transfiere el material genético hacia la próxima generación, y por lo cual cada una de las mismas debería
estar un paso delante de la anterior en cuanto a su evolución. Por lo tanto en la generación final
(determinada por alguna condición de finalización) se encontrarán aquellos individuos mejor adaptados,
es decir las mejores soluciones (las cuales pueden ser óptimas o no)
Formalizando un poco lo dicho anteriormente y a modo de resumen, las técnicas de computación

evolutiva son métodos heurísticas que sirven para atacar problemas de optimización y búsqueda (útiles
cuando dichos problemas son NP) basados en los principios de evolución natural. Dichas técnicas se
pueden clasificar en tres grandes categorías que son: Programación Evolutiva, Algoritmos Genéticos y
Estrategias de Evolución.
De esta manera un EA basa su funcionamiento en generar aleatoriamente una población inicial de

posibles soluciones, la cual a través de diferentes mecanismos irá evolucionando hasta que el algoritmo
finalice (el final estará dado por algún criterio en particular, como ser cantidad de iteraciones o pasos de
evolución).
Aquí se encontrará una población mas adaptada que la inicial en términos de fitness.
Los EA abarcan tres etapas fundamentales: selección, recombinación y reemplazo.
Durante la etapa de selección, se crean a una población temporal en la cual los individuos más aptos
(aquellos con mayores valores de fitness en la población actual) tienen mayor cantidad de copias que el
resto de los individuos (selección natural)
En una segunda etapa se aplican operadores de recombinación a los individuos en esta población
originándose una nueva población.
Por último, los nuevos individuos creados substituyen a los individuos de la población original. Existen
diversas técnicas de reemplazo como veremos más adelante
Cabe destacar que el algoritmo compensa entre la explotación de buenas soluciones (dadas por la
selección) y la exploraciones de nuevas zonas del espacio de la búsqueda (reproducción); ya que la
política del reemplazo permite la aceptación de las nuevas soluciones que no necesariamente son mejores
Es importante hacer hincapié en este momento en que los EAs son métodos heurísticos y por lo tanto no
nos tienen porque brindar la solución optima al problema planteado, es más la bondad de la solución
brindada al finalizar el algoritmo depende de muchos factores (como ser condición de finalización que se
le impuso al algoritmo, complejidad del espacio de búsqueda, etc)
Las características en común que tienen todas las técnicas evolutivas son:
a) Basadas en poblaciones: A diferencia de muchas otras técnicas heurísticas, se caracterizan por

tener en todo momento una población de individuos
b) No operan sobre el espacio real: Debemos construirnos un “especio de representaciones” que

abstraiga al espacio real del problema a resolver a la hora de trabajar con dichas técnicas
c) Función de fitness: Utilizan una función de adecuación (o fitness) que evalúa la bondad de cada
uno de los individuos en la población, es decir con dicha función podemos saber que tan
“adaptado” se encuentra determinado individuo al entorno. Dicha función coincide con la
función a optimizar (maximizar o minimizar)
d) Un mecanismo de selección para simular la supervivencia de aquellos individuos más aptos al

entorno e imponer por lo tanto nuestra ley de la selva
e) Una política de reemplazo, la cual será tomada en cuenta para saber que nuevos individuos
generados formarán parte de la nueva generación. Existen muchas políticas distintas como ser
generacional (toda la generación se reemplaza), elitista (el mejor individuo siempre es mantenido
en la nueva generación), etc
f) Otros operadores estocásticos, como ser mutación, cruzamiento (típico de algoritmos genéticos),
híbridos que utilizan algunos de estos operadores junto con otros operadores dependientes del
problema
Por último queremos mencionar que las diferencias entre las técnicas de computación evolutiva
mencionadas al comienzo de la sección están dadas fundamentalmente en los operadores utilizados y en
la forma en que se ejecutan las etapas de selección, reproducción y reemplazo
1.4.3 Algoritmo Genético Simple
El AGS fue propuesto por Golberg en 1987 y a partir del modelo original de Holland (1975), en donde la
idea del mismo es justamente a partir de una población inicial (generada aletoriamente) aplicar los
operadores de selección y recombinación para generar nuevos individuos pertenecientes a una nueva
población y realizar esto en forma iterativa.
El esquema general del mismo es el siguiente:

P,MP:Poblacion
t:generación Federico Dominioni - Pablo Musso
t=0
Inicializar (P(t));
While Not (Condicion_de_Finalización(P(t)))
{
Evaluar(P(t));
MP(t)=Selección(P(t));
MP(t)=Cruzamientos(MP(t));
P(t+1)=Mutaciones(MP(t));
t=t+1
A partir de lo anterior se destacan 3 etapas fundamentales:
 Selección: Luego de evaluar a los individuos de la población actual, se realiza un

mecanismo de selección, en donde los individuos elegidos formaran parte de la población
temporal MP(t)
 Recombinación: En los algoritmos genéticos los operadores de recombinación
están integrados por el operador de Cruzamiento y el operador de Mutación
 Reemplazo: En el AGS el reemplazo es generacional, por lo tanto una nueva

población reemplaza completamente a la población anterior (en otros modelos de AG se
establecen determinadas políticas de reemplazo)
Dado que los AG son métodos heurísticos para la resolución de problemas de optimización y búsqueda
tratan resolver problemas del estilo:
max/ min f(x 1 , x 2 ,....x n )

Sa : g(x)  0
Una vez parametrizado el problema en las variables x 1 , x 2 ,....x n , debemos codificarlas en un

cromosoma, en el caso del AGS la codificación utilizada es la binaria
Ahora que se ha presentado, el AGS es tiempo de formalizar los conceptos para un modelo general de
algoritmo genético
Formalizando, Definición de un AG
Primero definamos
 Genotipo: Es la representación a nivel de cromosomas de un individuo. Puede ser por ejemplo

binaria, real, diploide, etc. Un cromosoma es una cadena de genes, en donde cada gen podrá
tener determinados valores dependiendo del alfabeto que se utilice. El locus es el nombre que
recibe la posición de un gen, y alelo es el valor que posee el dicho gen. Si el alfabeto  es
por ejemplo    0,1 , un cromosoma será una cadena de bits de determinado largo
predefinido (aunque es posible utilizar también cromosomas de largo variable).
Si bien se pueden utilizar alfabetos de diferentes cardinalidades el
teorema de los esquemas asegura que la codificación óptima es aquella que utiliza alfabetos
minimales (cardinalidad 2)
 Fenotipo: El fenotipo es expresado a partir del genotipo y es mediante el cual se puede medir la
bondad o aptitud de un individuo. Por ejemplo puede ser real, árbol sintáctico. Para fijar ideas si
la codificación de individuos es mediante cromosomas binarios de largo 8 y suponiendo que
dicha codificación representa un entero sin signo; entonces el individuo cuyo genotipo es
10010010 tendrá un fenotipo de 146.
Tal como ocurre en términos biológicos, el genotipo contiene aquellas características de un individuo a
nivel cromosómico y por lo tanto es interna y no depende del entorno. Por otra parte el fenotipo refleja
aquellas características de un individuo desarrollada a partir de la interacción del genotipo con el medio
ambiente. De esta forma podemos deducir que individuos con iguales
genotipos pero sometidos a entornos distintos tendrán diferentes fenotipos.
En el ejemplo presentado anteriormente en particular si utilizamos otra codificación (la cual nos genera
otro entorno) para el genotipo 10010010 (por ejemplo entero con signo) su fenotipo será –18.
Definimos formalmente un AG mediante la siguiente tupla de parámetros:
AG (, G,  , f,  , , S, Gap, , R, )
donde:
  es denominado espacio de búsqueda, y es aquel espacio en el cual el AG trabaja (a nivel

de fenotipos) para hallar una solución al problema. Justamente lo que hará el AG será “partir”
dicho espacio en subespacios de búsqueda (o hiperplanos de búsqueda como los denomina
Whitley) e ir explorando los mismos, luego para aquellos subespacios buenos (en términos de
fitness) los explotará en busca de mejores individuos aún. Esto lo veremos con mayor detalle
más adelante.
 G es aquel espacio en el cual el AG trabaja genéticamente para llegar a una solución, se
denomina espacio de representaciones, y es el espacio formado por todas las representaciones
posibles de individuos, de modo tal que todo individuo generado por el AG (sea bueno o pésimo)
pertenecerá a dicho espacio; notemos que este espacio es una abstracción (a partir) del espacio
real del problema
  :G   es la función de representación, dicha función es la que expresa un genotipo

en un fenotipo, es decir lo decodifica
 f:  R  es la función de fitness, es decir esta función mide cuan adaptado se

encuentra un individuo en particular (a partir de su fenotipo) en el entorno en cuestión
   N es el tamaño de la población
  :   P () representa a la función de inicialización, es decir aquella función que

se aplica para generar la población inicial a partir de la cual comienza a trabajar
genéticamente el algoritmo
 S es el mecanismo de selección utilizado, como veremos mas adelante ruleta, torneo,

etc
 Gap corresponde al porcentaje de la población que será manipulada en cada

generación, es decir al porcentaje de individuos que en cada generación son
reemplazados por los nuevos individuos formados. Notemos que en el caso particular
de reemplazo generacional (como es el caso del AGS) el valor de dicho parámetro es 1
  representa el conjunto de operadores genéticos utilizados. Dependiendo del

problema a resolver se pueden utilizar determinados operadores genéticos, los
comúnmente utilizados son por supuesto cruzamiento y mutación
 R corresponde a la política de reemplazo utilizada para generar una nueva

generación de individuos, la cual puede incluir a los individuos pertenecientes a la
generación actual y a los nuevos individuos generados; o solamente a los nuevos
individuos generados. Las policías de reemplazo mas utilizadas son
generacional, generation gap y steady-state.
El reemplazo generacional ya fue explicado (ver Algoritmo Genético Simple);
generation gap es una política en la cual un porcentaje de la población (indicado por el
parámetro Gap) es reemplazada en cada generación. Finalmente en steady-state se
reemplazan muy pocos individuos (inclusive por lo general se reemplaza solamente
uno), deberá estar predefinido quien es el individuo a reemplazar : el mejor, el peor,
uno al azar, uno elegido al azar dentro de un conjunto de individuos, etc
 es la condición de finalización del algoritmo, la cual puede ser un numero determinado

de generaciones o por ejemplo una condición de convergencia.
1.4.4 Operadores de Selección
Dentro de los algoritmos genéticos se distinguen varios operadores de selección. Listaremos aquí los más
importantes.
Selección Proporcional (Roulette Wheel): Tipo más común de selección. Consiste en seleccionar
individuos de manera proporcional a su fitness. Cada individuo tendrá una probabilidad p de ser
seleccionado que será calculada como el fitness de ese individuo dividido la suma de los fitness de todos
los individuos de la población.
De esta forma los individuos con mejor fitness tendrán mayor probabilidad de ser seleccionados.
Uniforme: En este tipo de selección todos los individuos tienen la misma probabilidad de ser
seleccionados. Se eligen aleatoriamente los individuos.
Torneo: Torneo (N,K), se seleccionan por algún otro método de selección N individuos. De esos N
individuos sobreviven los K mejores (los K que posean mejor fitness).
Rango: Se ordenan los individuos según su fitness de menor a mayor . Se le asigna a cada individuo un
rango que depende de su posición en la lista ordenada. (peor individuo rango menor ). La probabilidad de
que un individuo sea seleccionado va a ser proporcional a su rango o sea la probabilidad de un
individuo i de ser seleccionado es el rango de ese individuo dividido la suma de rangos del resto de los
individuos de esa población.
1.4.5 Operadores de Cruzamiento y Mutación
Cruzamiento:
Los operadores de cruzamiento son operadores de cardinalidad dos es decir que se necesitan dos
individuos para que pueda ser aplicado. Además estos operadores retornan dos individuos. A continuación
distinguiremos algunos tipos de cruzamiento.
Cruzamiento de un punto:
El cruzamiento de un punto es el tipo más común de cruzamiento. En el ,dado una codificación de

individuos establecida por un cromosoma de largo L se selecciona un número aleatorio N entre 1 y L-1.
El primer nuevo individuo estará dado por las primeras N posiciones del cromosoma 1 y las L-N últimas
posiciones del cromosoma 2.
El segundo nuevo individuo estará dado por las primeras N posiciones del cromosoma 2 y las L-N
últimas posiciones del cromosoma 1.
A partir de la combinación de estos cromosomas salen los dos nuevos individuos.
Aquí se presenta un ejemplo para clarificar la idea:
Sean los Strings:
100000000011
001111011011
El largo de cada String es 12. Escojo aleatoriamente un número entre 1 y 11.

Obtengo el 3.
100|000000011
001|111011011
Los Strings finales serán los siguientes:

100111011011
001000000011
Cruzamiento de dos puntos:
En este tipo de cruzamiento se escogen dos números al azar entre 1 y L-1 siendo L el largo de los
individuos. Estos intercamban el segmento que cae entre esos dos puntos.
Ejemplo:
Supongamos que obtengo los número aleatorios 4 y 8 en un String de largo 12.
1001|1101|1011
0010|0000|0011
Intercambio los segmentos y obtengo:
100100001011
001011010011
Cruzamiento de n puntos:
Genaralización del tipo de cruzamiento. Se escogen n puntos al azar y se intercambian segmentos
provenientes del punto de corte impar al punto de corte par próximo. Se puede ver el String como un
anillo de manera que al llegar al último valor se comienza de nuevo desde la izquierda.
Por ejemplo cruzamiento de 5 puntos:
1|00|111|0|1101|1
0|01|000|0|0001|1
0|01|111|0|1101|1
1|00|000|0|0001|1
Vale la pena destacar que para un cruzamiento impar de n puntos en donde n = 2k-1, será igual a un
cruzamiento par de n puntos con n= 2k y punto se encuentra en la posición “0”
De acuerdo a los estudios realizados por De Jong, cuanto mayor sea n se darán peores resultados dado
que se aumenta la probabilidad de romper material genético
Cruzamiento uniforme:
El cruzamiento uniforme funciona de la siguiente manera. Tenemos dos Strings a los cuales les voy a
aplicar este cruzamiento. L es el largo de cada String. Por cada posición entre 1 y L escojo aleatoriamente
de cuál de los dos padres voy a escoger su valor genético en esa posición.
Ejemplo:
Pa:100101
Pb:001101
Escojo aleatoriamente el valor de que individuo va a tener el String en cada posición y obtengo:
PbPbPaPaPbPa:
000101.
El otro String va atener los valores que no fueron seleccionados.
101101
Mutación:
Este es un operador que se aplica sobre un solo individuo y te retorna un solo individuo.
El tipo más común de mutación es aquel en el que para cada individuo se recorren todos sus valores
genéticos para cada posición y se tira una moneda con probabilidad pm para ver si el valor en esa
posición cambia o no. De cambiar el valor cambia por su complementario.
Por ejemplo en el caso de una codificación de bits cambia un 1 por un 0 y un 0 por un 1.
1.4.6 Otros Operadores Genéticos Operadores de Ordenamiento e
Inversión
Además de los operadores de cruzamiento y mutación , se han introducido nuevos operadores de manera
tal de poder brindar una mejor solución para determinado tipos de problemas. Aquí listaremos los
principales:
Inversión:
Principal operador de ordenamiento. Aquí dos puntos son escogidos sobre el largo del cromosoma , y el
cromosoma es cortado en esos dos puntos. Los puntos de borde que se encuentran adentro de la posición
de corte son intercambiados.
Ejemplo:
10|1110|11
10011111
Operadores de ordenamiento:
Los operadores de ordenamiento son utilizados en lugar de cruzamiento para problemas donde se utiliza
inversión y la codificación de cada individuo establece una dependencia entre la posición dentro del
String y su valor. O sea cada componente dentro del String representa un tipo específico de información y
no queremos que al combinar dos Strings desaparezca un tipo de información. Al aplicar inversión se
desordenan las posiciones del String y se puede perder información al aplicar el cruzamiento. Veamos el
siguiente ejemplo:
A= 1234|5678
1011|1011
B= 1265|4378
1001|1111
Al realizar el cruzamiento obtenemos:
A’= 1234| 4368

1011| 1111
B’= 1265| 5678

1001|1011
De esta forma nos damos cuenta que el String A no posee información sobre la posición 5 y posee dos
veces información sobre la posición 4. Esto hace que el operador de cruzamiento no sea un operador
adecuado para estas circunstancias. Por lo tanto se han utilizado otros tipos de combinaciones entre
strings que listaremos a continuación .
PMX:
Bajo PMX dos strings son alineados , y dos lugares de cruzamiento son escogidos uniformemente a través
de los Strings. Estos dos puntos de cruzamiento definen la región de mapeo, que es utilizada para efectuar
un cruzamiento posición por posición a través de los operadores de intercambio.
Ejemplo:
A= 9 8 4 | 5 6 7 |1 3 2 10
B= 8 10 4 | 2 3 10 | 9 5 4 6
Lo que hago es mapear el String B con el A , o sea el 5 con el 2 el 6 con el 3 y el 7 con el 10 cambiando
sus lugares.
A’= 9 8 4 | 2 3 10 |1 6 5 7
B’= 8 10 1 | 5 6 7 | 9 2 4 3
OX (Order CrossOver):
Este tipo de operador trabaja similar al PMX. Primero selecciono las regiones de mapeo.
A= 9 8 4 | 5 6 7 |1 3 2 10
B= 8 10 4 | 2 3 10 | 9 5 4 6
En lugar de utilizar intercambios punto a punto como hace PMX lo que hacemos es utilizar un
deslizamiento para llenar los huecos dejados por transferir las posiciones mapeadas.
Por ejemplo cuando el String B mapea con el String A los puntos 5 6 y 7 dejaran huevos (marcados con
H)
B=8 H 1 | 2 3 10 | 9 H 4 H
Luego los huevos son desplazados.

B= 2 3 10 | H H H | 9 4 8 1
Y son llenados obteniendo los siguientes resultados.
A’=5 6 7 | 2 3 10 | 1 9 8 4
B’= 2 3 10 | 5 6 7 | 9 4 8 1
CX (Cycle CrossOver):
Este tipo de cruzamiento es diferente.

En lugar de escoger los lugares de cruzamiento , comenzamos en la parte izquierda del primer padre.
Suponemos que tenemos
C= 9 8 2 1 7 4 5 10 6 3
D= 1 2 3 4 5 6 7 8 9 10
C’= 9 _ _ _ _ _ _ _
Nos fijamos en el padre D, vemos que al nueve le corresponde el 1 entonces colocamos en C’ el 1.
C’=9 _ _ 1 _ _ _ _
Así sucesivamente hasta que se termina el ciclo.
C’=9 _ _ 1 _ 4 _ _ 6 _
Luego de la finalización del primer ciclo los restantes lugares son llenados a través del otro String.
Completando el ejemplo obtengo:
C’=9 2 3 1 5 4 7 8 6 10
D’=1 8 2 4 7 6 5 10 9 3
1.4.7 La base de su funcionamiento: Definiciones Previas
Antes de comentar la base de teórica de los algoritmos genéticos veremos algunas definiciones previas las
cuales serán de mucha utilidad a la hora de comprender el porque de su funcionamiento
El proceso de búsqueda se basa en identificar “patrones de similaridad” de los individuos, de forma tal de
poder definir clases de individuos semejantes dado que las similaridades entre los individuos más
adaptados ayudar a guiar el proceso.
A través de los esquemas (introducidos por Holland, 1968,1975) podemos definir estos patrones de
similaridad que son de interés para la búsqueda. Un esquema es básicamente un template que describe un
conjunto de individuos con determinadas características comunes en ciertas posiciones de sus
correspondientes cromosomas.
De esta manera se trabaja sobre un alfabeto extendido  U * , donde se define el meta-carácter *
de forma que pueda machear con cualquier valor del alfabeto .

Obviamente un esquema determinado machea a un cromosoma particular si todo símbolo distinto de * en
el esquema coincide con el correspondiente del cromosoma.
Por ejemplo si estamos trabajando sobre el alfabeto binario, el esquema 000* machea con los strings 0000
y 0001; el esquema 0*0* macheará con los strings 0000, 0001, 0100 y 0101.
Toda posición de un esquema cuyo valor correspondiente sea un valor del alfabeto (es decir cuyo valor es
distinto del metacaracter *) se denomina posición fija del esquema.
Es importante destacar que para un alfabeto de largo N caracteres y trabajando con individuos de largo L
tendremos en nuestro espacio de búsqueda N L individuos posibles , por otro lado tendremos
(N  1) L esquemas posibles (por el metacaracter)
Dado un esquema, se define como orden del esquema o(H) a la cantidad de posiciones fijas que éste
posee. Por ejemplo el orden del esquema 0*0* será 2, mientras que el orden del esquema 000* será 3.
Por otro lado, se define dado un esquema a su defining length  (H ) como la distancia (en posiciones)
entre la primer y última posiciones fijas. De esta manera el  (H ) para 0*0* será 2 – 0 = 2, por otra
parte el  (H ) del esquema 000* también será 2 – 0 = 0. Notemos que por definición
 ( H )  [0, l  1] siendo l el largo de la representación
1.4.8 El Teorema de los Esquemas
El teorema de los esquemas fue publicado por Holland en 1975 dentro del libro titulado “Adaptation in
Natural and Artificial Systems” y es la base matemática teórica sobre el funcionamiento de los
algoritmos genéticos.
Para comprender el teorema de los esquemas veremos como se comporta cada uno de los siguientes
operadores:
 Selección
 Cruzamiento
 Mutación
Es importante destacar que en este apartado no se demostrará el teorema, dado que no es el objetivo del
mismo (para el lector interesado se recomienda ver [1] y [2]) ; simplemente comentaremos el efecto de
cada uno de los operadores mencionados anteriormente para poder concluir la idea cualitativa detrás del
teorema.
 Operador de Selección
Sea n(H,t) el número de individuos representantes del esquema H en la generación t; f(H) el valor de

fitness promedio considerando a los individuos que representan a H en la generación t; y f el valor de
fitness promedio de toda la población; se puede demostrar que el efecto de considerar solamente los
operadores de selección es:
f (H )
n( H , t  1)  n( H , t ) 
f
De aquí podemos concluir que aquellos esquemas cuyo fitness promedio sea superior al fitness promedio
de la población tendrán mayor número de representaciones en la próxima generación.
Por otra parte si suponemos que un esquema permanece un factor c constante por encima del promedio,
entonces:
 
f (H ) f c f
n( H , t  1)  n( H , t ) 
 n( H , t ) 
 (1  c)n( H , t ) , entonces por lo tanto:
f f
n( H , t  1)  n( H ,0)(1  c) t
Concluimos por lo tanto que el operador de selección asigna exponencial incremento de los
esquemas con fitness superior al fitness promedio, razonando análogo se concluye que existe un
decrecimiento exponencial de aquellos esquemas con fitness inferior al fitness promedio (este hecho es
denominado ley exponencial).
Es importante destacar que dicho crecimiento exponencial se lleva a cabo en paralelo sobre todos los
esquemas existentes en el espacio de búsqueda (por más detalles ver la sección Paralelismo Implícito)
 Operador de Cruzamiento
Teniendo en mente que dicho operador es destructivo para algunos esquemas, si p c es la probablidad de
cruzamiento y l es el largo de la representación, se puede demostrar que los efectos de los operadores de
selección y cruzamiento son:
f (H )  ( H ) 
n( H , t  1)  n( H , t )  1  p c l  1 
f
De aquí se observa que aquellos esquemas cuyo fitness promedio sea superior al fitness promedio de
la población (condición dada por la selección) y cuyo defining length sea pequeño (alta probabilidad
de supervivencia ante cruzamiento) tendrán incremento exponencial de muestras.
 Operador de Mutación
Ahora veremos el efecto sobre el muestreo de esquemas al aplicar los 3 operadores clásicos
conjuntamente e inferiremos precisamente la conclusión del teorema de los esquemas
Siendo p m la probablidad de mutación de un gen se demuestra que:
f (H )  ( H ) 
n( H , t  1)  n( H , t )  1  p c  o( H ) p m 
f l 1 
Dicha ecuación nos brinda el numero esperado de copias que un esquema H recibirá en la próxima
generación sujeto a los 3 operadores clásicos; y de la misma se puede concluir que esquemas de pequeño
defining length (supervivencia ante el cruzamiento), bajo orden (supervivencia ante la mutación) y
por encima del promedio en cuanto a fitness (supervivencia en la reproducción) (dichos esquemas
se denominan building blocks) recibirán un incremento exponencial de individuos representantes
en las subsecuentes generaciones.
A continuación se mostrará como funciona de manera cualitativa el proceso de búsqueda de un AG

mediante un ejemplo
Si consideramos un espacio de búsqueda tridimensional, el AG muestreará distintos hiperplanos

(correspondientes con los distintos esquemas que el AG va considerando) de dicho espacio, en donde los
hiperplanos que irán siendo muestreados por una mayor cantidad de individuos a medida que al AG
avanza (y son por lo tanto quienes guían la búsqueda) son justamente aquellos que posean pequeño
defining length, bajo orden y se encuentren por encima del promedio en cuanto a fitness mientras que los
otros esquemas en cada generación tendrán menor numero de representaciones la cual decrece
exponencialmente. Si asumimos que se realizó una codificación del problema con 3
bits, entonces lo podemos representar como un simple cubo como se muestra en la figura 2.
Figura 2: Cubo tridimensional correspondiente al espacio de representaciones
Aquí se puede apreciar correctamente que cada esquina del cubo es un individuo posible del espacio de
representaciones, mientras que las aristas o planos del mismo corresponden a diferentes hiperplanos que
el AG irá muestreando a medida que avanza el proceso de búsqueda. En particular el plano frontal del
cubo corresponde al esquema 0**, mientras que la arista AB corresponde al esquema 0*0.
1.4.9 Paralelismo Implícito y Desventajas de la Teoría
Los algoritmos Genéticos procesan muchos esquemas implícitamente en paralelo cuando se encuentran
trabajado con una población, por más que sea simplemente un solo algoritmo genético secuencial el que
esta corriendo. Más específicamente un algoritmo genético secuencial trabajando sobre una población de
N individuos procesa en paralelo N 3 esquemas (aquí no se demostrará este argumento puesto que no es
la intención del documento pero el lector interesado puede ver [1] y [2]). Esto es una prueba más del
sorprendente poder de búsqueda de los algoritmos genéticos ya que procesa una cantidad mucho mayor
de hiperplanos que de los individuos con los cuales está trabajando.
Es importante destacar que si bien los AG en la practica funcionan adecuadamente dando muestras de
paralelismo implícito (aún cuando trabajan con poblaciones reducidas) algunas de las hipótesis supuestas
en el teorema de los esquemas son fácilmente violadas.
En particular las hipótesis del teorema de los esquemas que son violadas son:
 Suposición de Pequeñez. El teorema de los esquemas asume que los esquemas que entre otras
características tengan pequeño defining length serán preservados (e incluso serán muestreados
con un incremento exponencial) sin embargo si en dichos esquemas la ventaja del fitness (exceso
del fitness sobre el fitness promedio) es mayor que su vulnerabilidad (relación entre el defining
length y el largo del genotipo) no serán preservados a pesar de su pequeño defining length.
 Bajo Epítasis. El teorema de los esquemas asume que existen esquemas que tienen un valor
constante c de fitness por el cual se mantienen superiores al fitness promedio de generación en
generación (aún cuando dicho esquema es sometido a operadores destructivos como el
cruzamiento), es decir estos esquemas no son afectados por el contexto genético (por lo tanto
tienen bajo epistasis). Esta suposición es por lo general muy subrealista.
Podemos concluir de esta manera que la visión cualitativa del teorema de los esquemas es adecuada pero,
cuantitativamente hablando poco útil, dado que puede servir para estimar cantidades en una o dos
generaciones en el futuro pero no más que esto (sobre todo porque en más de esta cantidad de
generaciones no podemos asegurar que se mantenga la hipótesis de bajo epítasis)
1.4.10 Como hacer para resolver mi problema con un AG

Para resolver un problema con un algoritmo genético lo primero que debo hacer es pensar
en una representación de los individuos. Que tipo de codificación necesito para resolver el problema.
Luego de esto debemos hallar la función de fitness la cual nos debe dar una medida de bondad de los
individuos para la solución del problema. Esta puede ser en la mayoría de los problemas la función a
optimizar o puede ser una función parecida a la función que se desea optimizar pero mejorada para
adecuarla a los métodos de resolución de algoritmos genéticos. La entrada de la función de fitness deberá
ser un número real por lo tanto se deberá decodificar el genotipo para obtener a partir de este un real.
Si la función a optimizar es una minimización debemos cambiar la función de fitness para transformarlo
en un problema de maximización. Existen dos formas de hacer esto. Una es invertir la función de fitness,
pero debemos tener precaución porque al invertirla podemos acortar el rango de valores lo que puede
traer aparejada convergencia prematura. Otra forma es cambiarle el signo. Sin embargo esto puede traer
problemas según el tipo de selección utilizada y las medidas que se van tomando a lo largo del
procesamiento genético.
En primer lugar debemos tener especial precaución cuando la función de fitness es negativa. En estos
casos lo que es conveniente hacer es sumarle una cantidad Cm para que la función siempre sea positiva.
Este valor puede ser el opuesto al mínimo de la función.
Otro punto importante a tener en cuenta son las restricciones que pueden haber al problema de
maximización. Para esto se pueden aplicar penalizaciones a aquellas soluciones que queden por fuera de
la región permitida. Esto es restarle una cantidad ponderada a la función de fitness para aquellos valores
que cumplan determinada condición p*Cond(Xi).
También tenemos que estudiar el problema a resolver para ver si es necesario el escalado de la función de
fitness. Existen varios métodos de escalado aquí solo vamos a describir el escalado lineal. Este método es
necesario para evitar dos tipos de problemas:
A) Convergencia prematura y/o dominancia al inicio de la evolución , cuando pocos individuos muy
“superiores” al resto pueden dominar el número de selecciones ,eliminando a aquellos individuos
menos adaptados.
B) Caminata aleatoria entre individuos buenos y mediocres cuando el fitness máximo es parecido al
fitness promedio muy avanzada la ejecución..
De esta manera modificamos la función de fitness por la escalada f’ haciéndo

f’=a*f+b a y b pueden ser escogidos de varias maneras pero generalmente lo que queremos es que el
fitness promedio escalado sea igual al fitness promedio sin escalar porque queremos asegurar que
cada miembro promedio de la población contribuya con un descendiente en la próxima generación.
Luego para controlar el número de copias dado para un integrante de la población de máximo fitness
, escogemos otra relación de escalado para obtener un fitness máximo
f’max=Cmult*favg. , donde Cmult es el número de descendientes esperados o deseado del mejor
individuo de la población.
Luego se deben escoger los operadores de selección, cruzamiento , mutación ,etc. Para esto no hay receta.
Todo es dependiente del problema. Por lo general se aplica cruzamiento de un punto con probabilidad de
cruzamiento alta, selección por ruleta , y mutación con probabilidad muy baja (<0.01). Sin embargo no
hay nada probado sobre esto por lo tanto no habrá una estrategia que sea mejor que otra sin depender del
problema.
1.4.11Dominancia y Diploides
Hasta el momento en este documento solamente hemos hablado de individuos cuyo genotipo se encuentra
formado por un solo cromosoma, pero ese genotipo (denominado haploide) corresponde al más simple
encontrado en la naturaleza. Individuos más complejos como plantas o animales poseen una estructura
cromosómica mas complicada, denominada diploide. En este tipo de estructura, un genotipo posee uno o
más pares de cromosomas (denominados cromosomas homólogos) conteniendo información para las
mismas funciones, por lo tanto un estructura diploide posee redundancia de información. Solamente a
modo de acotación vale la pena mencionar que el ser humano posee una estructura genotípica formada
por 23 pares de cromosomas homólogos.
Para comprender mejor el porque y como es un estructura diploide supongamos que tenemos el siguiente
genotipo:
A b C D e
a B C d e
El cual se encuentra constituido por los cromosomas homólogos AbCDe y aBCde.

Como se puede observar, para cada locus existen dos posibles alelos, de los cuales solamente uno será
expresado en el fenotipo. En la naturaleza, cada alelo podría representar características fenotípicas
diferentes, es decir por ejemplo el alelo D podría ser ojos negros, mientras que d ojos verdes.
Surge de esta manera la necesidad de contar con un elemento de decisión para saber cual de los dos alelos
posibles para cada locus es el que será expresado fenotipicamente, y así se introduce el operador
genético dominancia. En donde para cada locus existe un alelo (denominado alelo dominante) que toma
precedencia sobre el otro alternativo alelo (denominado alelo recesivo) para este locus. Es decir un alelo
es dominante si siempre se expresa en el fenotipo cuando aparece junto con otro alelo en un determinado
locus.
En el ejemplo dado si asumimos que los alelos correspondientes a letras mayúsculas son dominantes, y
todos los alelos correspondientes a letras minúsculas son recesivos, el mapeo del genotipo a fenotipo (a
través de dominancia) se da de la siguiente manera:
A b C D e A B C D e
a B C d e 
De lo anterior se puede concluir que las características dominantes se expresan en homocigotos (AAA)
y en heterocigotos (AaA) mientras que las características recesivas solamente se expresan en
homocigotos (aaa)
Luego de explicar como funciona la dominancia en genotipos diploides resta todavía una gran pregunta
por responder: Que ventajes me introduce en mi búsqueda contar con estructuras diploides ?
En primer lugar, provee en mecanismo para recordar (“memoria”) alelos y combinaciones de estos que
anteriormente fueron útiles, dado que mediante la dominancia se puede defender a dichos alelos de una
selección “maliciosa” en entornos hostiles y dinámicos. Es decir este método es especialmente utilizado
cuando tenemos una función de fitness que varía dinámicamente, dado que si no se contara con una
estructura diploide y un operador de dominancia (también cambiante por supuesto, no estático como se
vio en el ejemplo de arriba) , aquellos alelos que en un momento fueron buenos (y que posteriormente
podrían llegar a serlo) serían eliminados causando una pérdida importante de características genéticas.
Esto es justamente lo que ocurre en la naturaleza, donde los organismos más efectivos son aquellos que se
pueden adaptar mas rápidamente al entorno cambiante. Dichos organismos son más capaces de sobrevivir
porque su constitución genética no olvida fácilmente las “lecciones” aprendidas previamente del entorno
cambiante y hostil.
En segundo lugar la memoria redundante de diploides permite tener múltiples soluciones alternativas para
el mismo problema estar en abyección junto con una única solución expresada fenotípicamente,
aumentando la diversidad y evitando la pérdida de características de manera permanente.
Cabe destacar que la idea detrás de genotipos diploides junto con dominancia es extendida sin
inconvenientes a genotipos multiploides
2 Paralelismo
En este capítulo describiremos los modelos más importantes de algoritmos genéticos paralelos. Existen
muchos modelos de paralelismo y lamentablemente no existe una estandarización en la clasificación y el
nombre de los mismos por lo tanto utilizaremos la clasificación más común que se encuentra en la
mayoría de los libros y papers.
Para comenzar veremos las desventajas de los algoritmos genéticos secuenciales y para que sirve la
paralelización. Luego presentaremos los tipos de algoritmos genéticos paralelos más simples, maestro-
esclavo , islas, y celulares. Por último hablaremos de algunos modelos paralelos más complejos como lo
son el modelo jerárquico y los algoritmos genéticos incrementales.
2.1 ¿Porqué paralelizar?
Los algoritmos genéticos secuenciales han sido muy exitosos en la resolución de una gran cantidad de
problemas sin embargo existe un conjunto de desventajas en su utilización. Estás son:
 Usualmente son ineficientes

 Las evaluaciones de la función de fitness consumen mucho tiempo
 Las poblaciones necesitan ser muy grandes en una cantidad de problemas.
Para resolver estas desventajas y también para estudiar nuevos modelos de mayor eficiencia y eficacia ,
varios modelos de algoritmos genéticos paralelos han sido revisados y estudiados.
Un aspecto muy importante de la paralelización es que un algoritmo genético paralelo no es solamente
una extensión del algoritmo genético secuencial sino que es un algoritmo genético totalmente diferente,
en el sentido que realiza distinto trabajo de búsqueda.
Por lo tanto nosotros no solo esperamos que el algoritmo genético paralelo sea más eficiente sino que
también necesite un número menor de evaluaciones de la función de fitness.
En la siguiente sección comenzaremos a describir los diferentes modelos de paralelismo del algoritmo
genético.
El primero es el modelo más antiguo de todos y no representa una ventaja importante en cuanto al
algoritmo aunque resuelve el problema de la evaluación de la función de fitness en el caso de que
consuma mucho tiempo.
2.2 Modelo Maestro – Esclavo

En el comienzo de la paralelización de los algoritmos genéticos el modelo maestro esclavo fue el primero
en ser utilizado.
El modelo general se basa en delegar la evaluación de la función de fitness a otro procesador llamado
esclavo.
Las variaciones a este modelo dependen según quién se encargue de realizar otras operaciones propias del
algoritmo genético. En la mayoría de los modelos maestro –esclavo lo único que se delega a un esclavo es
la evaluación de la función de fitness pero existen otros modelos en los que también se le delegan al
esclavo otros operadores como el cruzamiento y/o mutación ,etc. A continuación se muestra un esquema
del modelo maestro –esclavo.
MAESTRO
Individuo i
Esclavo n
fintess i 2srdsdf11
11111111
Esclavo Esclavo Esclavo Esclavo 1111111
1 2 3 4
2srdsdf1 2srdsdf1 2srdsdf1
1111111general: Modelo Maestro
Figura 2.1 Esquema 1111111 – Esclavo 1111111
1111111 1111111 1111111
11 Maestro 11 11
El modelo maestro-esclavo es utilizado sobretodo cuando la evaluación de la función de fitness es

P,MP:Poblacion
costosa. Lamentablemente presenta un conjunto importante de desventajas.
t:generación
En primer lugar el maestro deberá esperar por que sus esclavos le retornen la evaluación de la función de
t=0
fitness para continuar,
Inicializar estando inactivo en todo ese intervalo el cuál puede ser muy grande sobretodo
(P(t));
cuando el tiempo que requiere el cálculo de la función de fitness es diferente para distintos individuos.
A continuación
While presentamos un código de un determinado tipo del modelo maestro escalvo. En este
Not (Condicion_de_Finalización(P(t)))
modelo lo único que se le delega al esclavo es la evaluación de la función de fitness. Se puede ver
fácilmente
{ en el código el problema mencionado anteriormente donde el maestro no podrá continuar hasta
tanto no Por
tener la evaluación
cada de la función
individuo de fitness
en P(t) de todos sus individuos.
hacer:
Enviar individuo a esclavo para evaluación de función de
fitness
Hasta no recibir el fitness de todos los individuos de la población:
Recibir(i,fitness(i))
ActualizarFitness(i)
t=t+1
Esclavo:
{
While(not fin)
Recibir(Individuo,i)
Evaluar(Individuo)
EnviarIndiviuo(i,fitness(i))
}
2.3 Modelos de grano grueso
Típicamente los modelos de grano grueso consiste en un conjunto de poblaciones paralelas que
evolucionan independientemente una de otra y periódicamente pueden intercambiar individuos entre
ellas. Cada una de estas poblaciones es denominada isla.
Estos modelos se pueden caracterizar según diferentes parámetros. El modelo de migración que determina
como y cuando se realiza el intercambio de individuos , diferenciando entre el modelo aislado , donde las
poblaciones evolucionan independientemente sin existir comunicación , y los modelos de migración .
Estos modelos de migración pueden ser sincrónico ( cada ciertas generaciones las poblaciones envían su
población y quedan esperando por recibir una población de otra isla) o asincrónico (cada ciertas
generaciones las poblaciones envían su población pero no quedan esperando para recibir una población de
otra , pudiéndola recibir en cualquier momento).
El esquema de conectividad entre las poblaciones, que puede ser estático , basado en las topologías de los
multicomputadores , o dinámico , un enfoque en el cual la topología de conexión varía durante la
evolución.
El otro criterio es el de homogeneidad de las poblaciones. Un AGP homogéneo utiliza los mismos
mecanismos de codificación, selección, cruzamiento y reemplazo en sus poblaciones. Un AGP no
homogéneo permite utilizar diferentes mecanismos evolutivos, con criterios propios para seleccionar
parámetros y codificaciones para las soluciones.
También existen modelos en las que cada isla utiliza una diferente representación de sus individuos.
Generalmente utiliza diferentes resoluciones (largo de representación) para las codificaciones en cada
población y su mecanismo de migración es de “una vía”, exclusivamente desde poblaciones de baja
resolución a poblaciones de alta resolución. Aquí se puede definir un mecanismo de “refinamiento” de
soluciones.
Esto sirve cuando una isla realiza una búsqueda rápida y luego se pasan los individuos a otra isla para que
refinen dicha solución.
El modelo de islas es el más utilizado. Se han hecho varios estudios sobre diferentes ejecuciones de
distintos modelos de algoritmos genéticos de grano grueso para diversos problemas y variando los
parámetros pero no se han llegado a conclusiones obvias de qué tipo de modelo es mejor que otro.
Podemos decir que para un mecanismo de migración, es mejor una migración asincrónica que sincrónica
debido a que así evitamos cuellos de botella. Esto es debido a que las islas deberán detener su proceso
genético para esperar la recepción de individuos por parte de la otra, generando pérdidas de tiempo
innecesarias .
El modelo de grano grueso más utilizado es con migración asincrónica, homogéneo y una topología de
anillo.
Población(8)
Isla
Isla
Población(1) Isla
8
1
Isla 7
Isla
2
6
Isla Isla
3 Isla 5
4
Figura 2.2 Esquema Migración asincrónica
La flecha indica el sentido de las migraciones. En cada migración no son todos los individuos que se
envían. Sino que cada isla, selecciona un conjunto de individuos a ser enviados a otra. La isla receptora,
puede hacer varias cosas con la población recibida. Una es utilizar una política de reemplazo para
reemplazar parte de su población por la nueva, o solamente reemlpazar si los individuos recibidos son
mejores que los que seleccioné para reemplazar.
A continuación se presenta un pseudocódigo de un algoritmo genético de grano grueso. En particular es
un modelo de islas con migración asincrónica.
Isla:
/* Check_asynchronous: cada cuantas generaciones chequear por recibir

mensajes de otra isla.*/
/* Migration_Rate: Cada cuantas generaciones migrarán los individuos*/
/*Migration_Size: Cantidad de individuos que van a migrar.*/
/* destino: Indica la isla a la cual se va a migrar.*/
/* fuente: Indica la isla de la que va a recibir individuos*/
P,MP:Poblacion
t:generación
t=0
Inicializar (P(t));
While Not (Condicion_de_Finalización(P(t)))
{
Evaluar(P(t));
if(t % migration_rate ==0)
Pmig=selecciono de P(t+1) selection_size individuos para que
migren.
Envio(destino,Pmig)
If (hay_población_esperando)
Recibo(fuente,Pmig)
Prem=Selecciono de P(t+1) individuos para reemplazar por la
población que llegó.
Reemplazo Pmig por Prem.
If (t % check_asynchronous ==0)
If (hay_población_esperando)
Recibo(fuente,Pmig)
Prem=Selecciono de P(t+1) individuos para reemplazar por la
población que llegó.
Reemplazo Pmig por Prem.
t=t+1
}
2.4 Modelos celulares

Los algoritmos genéticos celulares , también conocidos como masivamente paralelos utilizan una
distribución espacial de individuos en una única población. Esta población está dividida en nodos. Estos
nodos contienen muy pocos individuos , (muchas veces sólo uno). Los operadores genéticos son
ejecutados en paralelo por cada nodo de la población pero cada individuo interactúa solamente con su
vecindad. Por lo tanto , selección , cruzamiento y mutación se lleva a cabo considerando solamente los
individuos adyacentes.
La política de reemplazo puede variar pero usualmente destruye el individuo actual (o los individuos
actuales para nodos con más de un individuo) siendo estos sobrescritos por el/los nuevos individuos.
Algunas variaciones en este modelo es según el tipo de distribución y conexión entre los nodos. El
modelo más común es el de grilla que se mostrará en la siguiente figura.
figura 2.3 Esquema Algoritmo genético paralelo
El modelo celular presenta varias ventajas,. En los algoritmos la soledad de individuos con respecto a
individuos distantes (no vecinos) permite una alta diversidad dado que la presión de selección se debilita
debido a la selección local que se lleva a cabo.
El balance entre explotación y exploración es en varias aplicaciones muy bien desarrollado por este
modelo de algoritmo genéticos paralelo.
En este modelo los buenos individuos se van a ir difundiendo por toda la topología a lo largo de diferentes
generaciones.
A continuación se presenta el pseudocódigo para un tipo de algoritmo genético celular.
En este caso cada nodo contiene un único individuo, el proceso de selección se efectúa sólo sobre sus
vecinos y se escoge un solo individuo para cruzarse con el actual. Luego de obtener el nuevo individuo
este destruye al viejo solamente si es mejor.
Individuo(i):
{
While Not (Condicion_de_Finalización)
Evaluar individuo i
Seleccionar de la vecindad un individuo k
L=Cruzamiento(i,k)
Lm=Mutación(L)
L “mejor que i”
i=L
2.5 Modelos particulares
En esta sección se presentan algunos modelos que están basados en los tres descritos anteriormente.
Estos son modelos particulares y a continuación se dará una breve descripción de los mismos.
2.5.1 Adaptive Hierarchical Fair Competition Model for Parallel

Evolutionary Algorithms:
También conocido como modelo jerárquico. Propuesto por Jianjun Hu, Eric D. Goodman , Kisung Seo y
Min Pei . Este modelo se basa en varias subpoblaciones. Pero con una relación jerárquica entre ellos.
Cada subpoblacion se encuentra en un determinado nivel. Para que un individuo este en determinado
nivel deberá tener un fitness superior al mínimo fitness permitido en ese nivel y un fitness menor al
máximo permitido en dicho nivel. Cada isla evoluciona y luego de un paso de evolución aquellos
individuos que posean un fitness superior al máximo permitido son enviados a otro nivel.
Este modelo es dinámico ya que el número de niveles varía durante la evolución. Inicialmente existe un
solo nivel en el que están todos los individuos y cada determinadas generaciones se van creando nuevos
niveles ,cambiando los límites máximo y mínimo de cada uno.
Este modelo ayuda a mantener la diversidad de la población , ya que los peores individuos son
mantenidos a la espera de poder explorar el espacio de búsqueda y al mismo tiempo los mejores
individuos son tratados rápidamente manteniendo el equilibrio de explotación/exploración necesario en
todo algoritmo genético.
2.5.2 Algoritmos genéticos incrementales:
Este modelo fue propuesto por Alba y Toya. Este modelo está basado en el modelo de islas pero sin
migraciones. De esta forma esta compuesto por dos tipos de procesos. Un proceso principal llamado
monitor y otro conjunto de procesos que ejecutan algoritmos genéticos secuenciales. Todas las islas del
sistema progresan en paralelo. Los algoritmos genéticos secuenciales se comunican con el monitor central
y viceversa.
Una de las diferencias fundamentales con respecto a los modelos migratorios tradicionales es que el
monitor recibe los individuos desde los AGs de manera asíncrona y genera una macro- población de
individuos (idealmente los mejores entre los mejores pero haciéndolo de manera incremental y no
determinista). Dicha población tiene la particularidad de que ha sido generada incrementalmente por los
AGs secuenciales y la mezcla resultante no guarda un orden determinado respecto a los procesos que los
crearon. Los AGs secuenciales no trabajan siempre sobre la misma población. En algún punto de su
evolución recibirán una nueva población que les entrega el monitor para que trabajen sobre ella. Para
evitar degradaciones importantes todo el sistema debe realizar una evolución elitista, es decir , en
cualquier momento se tiene en cuenta al mejor individuo calculado hasta hora.
De esta manera se espera mejorar notablemente la diversidad (poblaciones independientes y mezcla
incremental), aumentar la exploración (búsqueda separada seguida de puesta en común y vuelta a
empezar sin esperas) y al mismo tiempo acelerar la obtención de soluciones adaptables.
Dentro de este modelo se distinguen 4 tipos de algoritmos genéticos incrementales según la actividad
genética que lleve a cabo el monitor y según que el número de algoritmos genéticos secuenciales sea
estático o pueda variar dinámicamente conforme la computación progresa.
Los modelos son:
Modelo Estático – Pasivo: El monitor no realiza trabajo genético sobre los individuos. El número
de AGs se difine al iniciar el trabajo y permanece constante hasta la terminación.
Modelo Estático – Activo: El monitor sí realiza trabajo genético (como si se tratase de un nuevo
AG secuencial) y el número de AGs permanece constante hasta la terminación.
Modelo Dinámico – Pasivo: El monitor no realiza trabajo genético y además los AGs secuenciales
que comienzan el trabajo pueden llegar a morir (disminuyendo así su número) y también el número de
algoritmos genéticos es variable dependiendo de las características del entorno de ejecución.
Modelo Dinámico – Activo: El monitor sí realiza trabajo genético y además los AGs secuénciales
que comienzan el trabajo pueden llegar a morir (disminuyendo así su número) y también es posible que
aparezcan nuevos AGs que realicen nuevas tareas de búsqueda.
2.5.3 Otros modelos
Existen muchísimos otros modelos de algoritmos genéticos. No necesariamente tienen que basarse en
grano fino, grano grueso, maestro – esclavo. También existen algoritmos genéticos que poseen ambos
modelos denominados híbridos. El más común es el de un conjunto de islas con migración como ya
vimos, pero que cada isla realice sus pasos evolutivos mediante otro modelo que puede ser el maestro
esclavo o el celular.
2.6 Conclusión final:
Si uno piensa seguir la metáfora biológica inmersa en los AG, los AG paralelos aparentan ser más
naturales que los secuenciales. Cuando son implementados en un cluster de computadoras, y /o
computadoras paralelas toman la ventaja de el incremento en la performance debido a la ejecución de
trabajo simultaneo en diferentes máquinas.
Por otra parte , hay evidencia experimental de que los algoritmos genéticos paralelos comunes como el
modelo de islas o el celular, pueden ser más efectivos para resolver problemas . Esto se debe a diversos
factores como puede ser la exploración simultánea e independiente de diferentes porciones del espacio de
búsqueda. , el poder tener poblaciones más grandes, y la posibilidad de transmitir la información por
migración o difusión de individuos.
Estas afirmaciones no han sido totalmente estudiadas y confirmadas por los pocos estudios teóricos que
ha hubieron hasta la fecha. Es muy poco claro como un problema se puede beneficiar de ciertos modelos
de paralelismo.
Una de las desventajas de los algoritmos genéticos paralelos es que son mucho más complicados que su
versión secuencial Debido a que un número importante de nuevos parámetros deben ser introducido como
son : topologías de comunicación y migración o difusión , el modelado matemático y los dinamismos de
estos algoritmos son muy difíciles.
La efectividad de los algoritmos genéticos paralelos se ha visto en la práctica en un gran número de
aplicaciones industriales y comerciales.
Los algoritmos genéticos paralelos han sido utilizados exitosamentes en operaciones de búsqueda,
ingeniería y manufactura, finanzas y problemas de telecomunicaciones entre otros.
En los próximos años , se espera que se encuentre primero un criterio común para clasificar los
algoritmos genéticos paralelos , ya que actualmente las clasificaciones dependen de el investigador. Y se
espera también en un futuro no muy lejano la completa formalización matemática de los algoritmos
genéticos paralelos así como pruebas matemáticas que determinen que modelo de paralelismo es mejor
para determinado problema.
Modelos de paralelismo pueden seguir apareciendo nuevos aunque estarán basados en los conceptos
básicos de islas y modelos celulares por lo tanto no habrá un cambio importante en este aspecto.
3 Bibliotecas de algoritmos genéticos
3.1 Introducción
A continuación presentaremos un conjunto de bibliotecas de algoritmos genéticos. Como se verá en este

documento se han implementado muy pocas bibliotecas . Nuestra intención es realizar un análisis de las
mismas haciendo énfasis en los modelos de paralelismo que implementan. Se han incluido de todas
formas bibliotecas que no implementan modelos de paralelismo simplemente para documentar su
existencia. Así mismo nos hemos basado en bibliotecas programadas en C/C++, pero también hemos
incluido alguna en otro lenguaje(Lisp) para mostrar que existen implementaciones en varios lenguajes. De
todas formas el lenguaje más común en el que están implementadas estas bibliotecas son C,C++ y
Fortran.
Esta reseña de bibliotecas se ha realizado en base a la documentación de las mismas. Nuestra intención es
que estas reseñas sobre bibliotecas cubran los mismos aspectos, sin embargo nos ha sido imposible
debido a el diferente enfoque de cada documentación Algunas documentaciones no dicen nada de
determinados aspectos que nos hubiera gustado incluir.
Esta es una reseña de el trabajo que se ha realizado en materia de implementación de algoritmos
genéticos. Nuestra intención para no perder claridad es dar una vision lo más global posible del
funcionamiento de cada biblioteca.
Sobre cada biblioteca se cubrirán los siguientes aspectos:
1. Presentación: Presentación de la biblioteca. Está orientado a quienes son los autores, donde se
desarrollo, algunos conceptos generales de la misma como por ejemplo en que lenguaje está
implementada , si es orientada a objetos o no, etc.
2. Funcionalidades: En funcionalidades nos referimos a todas las capacidades que posee dicha
biblioteca. Esto puede ser una breve descripción de la jerarquía de clases para una biblioteca
orientada a objetos. También se destaca que pasos debe seguir el usuario en caso de desear
utilizarla. Además tenemos un especial interés en describir el modelo de paralelismo que
implementa. En algunos casos , si la documentación provee dicha información nos interesará
saber cómo lo implementa.
3. Ventajas y desventajas: Aquí se colocan las principales ventajas y desventajas que tiene la
utilización de dichas bibliotecas. A continuación haremos una reseña de las propiedades más
importantes que debería tener una biblioteca. La presencia de esta propiedad es considerada
como una gran ventaja, la ausencia de estas una gran desventaja. Después tenemos las
propiedades secundarias que son propiedades que desearíamos que posea una biblioteca aunque
su ausencia no es tan importante. Propiedades importantes:
 Ser una
biblioteca orientada a objetos.
 Proveer de un modelo de paralelismo. En especial el
modelo de islas con migración asincrónica.
 Permitir al usuario extenderla, para que este pueda
construir por ejemplo sus propios tipos de migración, mutación, cruzamiento ,etc.
Incluso que el usuario pueda crear su propia representación de individuos.
Propiedades secundarias interesantes:

 Proveer otros operadores genéticos por ejemplo
inversión y otras funcionalidades propias de estos como escalado de la función de
fitness.
 Que su modelo de paralelismo pueda ser ejecutado
en plataformas heterogéneas.
 Proveer al usuario de codificaciones típicas de
individuos (bits, Strings, etc).
3.2 GALLOPS
3.2.1 Presentación
La sigla Gallops significa The “Genetic Algorithm Optimized for Portability and Parallelism” System .
Este es el resultado del trabajo de “Genetic Algorithms Research and Aplication Group (GARAGe) ,
Intelligent Systems Laboratory, Department of computer Science , and Case Center For Computer-Aided
Engineering And Manufacturing from Michigan State University, East Lansing .
Están basados en la definición de SGA (Algoritmo genético simple) descrito en el libro de David
Goldberg ,Genetic Algorithms in Search ,Optimization, and Machine Learning.
La biblioteca está escrita en C y ha sido probada en diversas plataformas con diferentes tipos de
compiladores.
La biblioteca no es orientada a objetos sino que está basada en funciones y estructuras.
3.2.2 Funcionalidades
Debido a que está directamente guiada a los algoritmos genéticos provee una gran cantidad de operadores
propios de estos. Podemos destacar métodos por ejemplo reducción de incesto ,escalado automático de la
función de fitness ,posibilidad de hacer una selección elitista donde siempre el mejor individuo
permanezca en la nueva generación, etc.
Para poder utilizar la biblioteca Gallops el usuario lo mínimo que tiene que hacer es implementar la
función de fitness. Para poder evaluar la función de fitness , Gallops provee varias funciones para ayudar
al usuario a decodificar un cromosoma.
También el usuario puede editar diferentes archivos de texto donde podrá escoger diferentes ejecuciones
del algoritmo genético.
Allí entre otras cosas el usuario puede escoger si utilizar elitismo o no , si la función de fitness es
estocástica o no, si se optará por ingresar código para iniciar el algoritmo genético , le da la posibilidad
también de escribir código para migrar individuos entre subpoblaciones , si se va a utilizar inversión, la
posibilidad de elegir como y cuando se va a desplegar la salida, que resultados de interés mostrar al final
de la ejecución , etc.
Gallops implementa la ejecución de algoritmos genéticos paralelos basados en el modelo de islas. El
paralelismo es provisto por esta biblioteca de tres maneras:
1) Paralelismo serial simulado (“Serial simulated parallelism”):
Uno puede simular cualquier número de subpoblaciones utilizando solamente una única computadora
, en estos casos las subpoblaciones son simuladas en turnos por un número de generaciones llamadas
ciclos. Al final de cada ciclo la población es descargada a un archivo para luego volver a comenzar.
Cada población recibe un turno por ciclo; y al comienzo de cada turno, y de acuerdo a una tabla
provista por el usuario lee uno o más individuos de cada una de las poblaciones vecinas. Cabe
destacar que en este modelo de islas cada subpoblación puede tener un tamaño diferente.
2) Paralelismo simulado por múltiples procesos (“Múltiple-process simulated paralellism”):

Esto puede ser ejecutado en cualquier sistema que le permita al usuario poder correr varias copias de
Gallops/ManyPops al mismo tiempo y que todos los procesos compartan un mismo archivo. En
dicho archivo se le dice a todos los procesos que debe ser comunicado entre subpoblaciones
Contrariamente con el paralelismo serial simulado; en este caso es el sistema operativo el que se
encarga de escoger que proceso es el que debe ejecutarse en un tiempo dado. La operación entre
subpoblaciones ya no es sincrónica como en el caso anterior. Cada ciertas generaciones los procesos
escriben su población en un archivo y luego si es tiempo de migrar intentan leer la población de otra
isla. Accesos simultáneos al mismo archivo es controlado por un protocolo de loqueo el cual controla
accesos a los archivos y la sobre escritura de la información que está siendo leída por otro proceso. Si
sucede que un proceso fracasa varias veces en leer un archivo para el caso de las migraciones , el
proceso puede continuar sin realizar esa migración particular.
También existe otro archivo al que todos los procesos tiene acceso . Es un archivo en el que
mantienen las estadísticas del algoritmo genético global. Al finalizar cada ciclo un proceso accede a
leer los datos de ese archivo y luego colocar los suyos.
3) Ejecución paralela real( True Parallel Execution):
En este caso varios procesadores ejecutan su propia copia (o propias copias utilizando el segundo
método) . Otra vez , todos los procesadores que cooperan deben compartir un mismo archivo. Un
archivo principal determina las vecindades y migraciones . El mecanismo de loqueo es el mismo
descrito en el punto 2. Y es muy importante cuando múltiples procesadores son utilizados.
Como el paralelismo en Gallops puede ser realizado sin la necesidad de realizar una comunicación
directa entre procesos, es muy fácil conectar subpoblaciones incluso en un gran número de PCs
conectadas por una red de PC típica.
3.2.3 Ventajas y desventajas
Gallops es una biblioteca que está exclusivamente orientada a los algoritmos genéticos por lo cual provee
funcionalidades propias de este método evolutivo. Por ejemplo la inversión, métodos de reducción de
incesto , escalado de la función de fitness , etc. A su vez provee varias funcionalidades típicas para
codificaciones comunes de algoritmos genéticos además de distintos tipos de cruzamiento ,mutación y
selección.
La mayor ventaja sin embargo se encuentra en su portabilidad. Debido que para realizar una ejecución
paralela solo se necesita compartir archivos, un mismo algoritmo genético paralelo puede ser corrido en
diferentes plataformas, siempre y cuando el largo de las palabras y el órden de los bytes sean los mismos.
Entre desventajas, la mayor, es que está orientado a estructuras y no a objetos. Esto provoca que el código
sea difícil de comprender y que sea difícil de extender para un usuario cuya intención sea crear otra
biblioteca a partir de esta .
Otra desventaja es que para el procesamiento paralelo la biblioteca no se encarga de equiparar la carga
entre los distintos procesadores sino que es el usuario el que debe controlarlo.
Por último el mecanismo de comunicación de procesos paralelos enlentece las migraciones , ya que se
debería bajar a disco y levantar del mismo , esto en algunos casos podría llegar a ser lento y tedioso.
En conclusión la biblioteca presentada provee muy buenas funcionalidades para los algoritmos genéticos
destacándose su portabilidad, pero es difícil de utilizar y de modificar o extender debido a que no está
hecho con un lenguaje orientado a objetos.
3.3 EO
3.3.1 Presentación:
Eo significa Evolving Objects Library . Es una biblioteca basada en computación evolutiva , orientada a
objetos en base a templates , desarrollada en C++.
La misma provee una amplia cantidad de técnicas de computación evolutiva.
EO fue iniciado por el Genura Team en la Universidad de Granada dirigido por JJ. Merelo. El equipo de
desarrollo fue luego reforzado por Maarten Keijzeer y Marc Schoenauer. Luego vinieron Jeroen
Eggermont y recientemente Sébastien Cahon desarrollando la versión paralela de EO.
EO fue testeado en una amplia cantidad de plataformas, entre estas se destacan Linux, con diferentes
compiladores, Solaris, y Windows 95/NT con el Cygwin y Visual C++ versión 6.0 .
3.3.2 Funcionalidades:
Entre todos los métodos de computación evolutiva que presenta , se encuentran los algoritmos genéticos.
En los mismos, provee al usuario codificaciones típicas de los individuos (array de bits, array de
enteros,etc) , además de la posibilidad de que el usuario escriba su propia codificación de los mismos.
Lo mínimo que debe hacer el usuario para utilizar la biblioteca es escribir el código para evaluar la
función de fitness.
Si la codificación no es una codificación típica , se deberá implementar la mutación, el cruzamiento, etc.
Esta biblioteca provee además una amplia gama de configuraciones para el procesamiento en paralelo . El
procesamiento paralelo se hace sobre la biblioteca MPI (message passing interface). Aquí se puede
implementar el modelo de islas. Donde cada isla contiene una subpoblacion, y se realizan intercambios
mediante los operadores de migración. La migración puede ser sincrónica o asincrónica.
También es posible implementar un modelo maestro-esclavo donde hay una única población y se le
asigna a otros procesos la evaluación de la función de fitness de los individuos y el modelo celular donde
cada individuo entra en contacto con solamente una vecindad.
Podemos aproximar aquí la arquitectura de EO con el siguiente diagrama:
eoEasyEA es el algoritmo genético simple. Posee entre otras cosas la condición de parada del algoritmo ,
la evaluación de la función de fitness , los operadores de selección cruzamiento , mutación ,etc. La
política de reemplazo dentro de una nueva generación ,etc.
Para el modelo de islas , podemos ver la arquitectura de la siguiente manera:
Donde hay un string que identifica a la isla, una referencia a la clase eoEasyEA, la clase eoContinue que
te indica cada cuanto es necesario realizar una migración. La clase eoSelect que te indica que individuos
de la población enviar a otra isla y la clase eoReplacement que te indica que individuos de la población
reemplazar debido a la llegada de una nueva población.
La clase eoListener le permite a la clase eoIslandsEasyEa observar el estado global del modelo paralelo ,
permitiendo la identificación de agentes distribuidos.
Aporta los servicios de envió y recepción de objetos.
La clase eoConnectivity es una clase abstracta la cuál define la topología de comunicación entre islas.
Para el modelo de procesamiento paralelo maestro – esclavo la relación entre los componentes es un
tanto diferente. Según vemos aquí:
eoDistEvalEasyEA contiene una lista de Strings siendo estos los identificadores de los nodos esclavos en
la evaluación de la función de fitness.
Aquí tenemos el nodo que se encarga de evaluar la función de fitness.
Esta biblioteca permite la implementación de modelos híbridos o sea islas y dentro de ellas un modelo
maestro esclavo.
Para el modelo celular la arquitectura es la siguiente:

Donde tenemos varias aplicaciones de la función SelectOne. Uno es para seleccionar entre la vecindad,
otro para seleccionar los hijos según cual sea la política de reemplazo y otro método para seleccionar
entre el viejo(el individuo que se encontraba en ese nodo) y el nuevo individuo.
3.3.3 Ventajas y desventajas:
Una gran ventaja es que está orientado a objetos por lo tanto la biblioteca relativamente más fácil de
comprender y más fácil de reutilizar.
Otra ventaja es que permite implementar una gran gama de modelos de procesamiento paralelo , además
de modelos híbridos.
Desventajas, no está 100% orientado a algoritmos genéticos por lo cual no provee ayudas como la
inversión , escalado de fitness ,etc.
No permite ser utilizado en plataformas heterogéneas.
3.4 Galib
Galib (A C++ Library of Genetic Algorithm Components) fue desarrollado por Matthew Wall
perteneciente al “Mechanical Engineering Department “ de la “Massachussets Institute Technology”. Es
una biblioteca de algoritmos genéticos orientada a objetos desarrollada en C++.
Esta biblioteca ha sido probada en las siguientes plataformas Dos/Windows , Windows NT/95, MacOS, y
Unix. Galib compila en la mayoría de los compiladores de estas plataformas sin dar warnings.
Existen tres puntos importantes que uno debe hacer a la hora de resolver un problema utilizando
algoritmos genéticos. El primero es definir una representación de los individuos , el segundo definir los
operadores genéticos, y por último definir la función de fitness. Para las dos primeras Gallops provee
ejemplos y ayudas para crear representaciones y operadores. La tercera deberá ser implementada por el
usuario.
Las ayudas para los dos primeros puntos son tipos ya predefinidos que ofrece la biblioteca, estas son
Listas, árboles ,vectores y Strings de bits. El usuario podrá crearse si así lo desea su propia estructura.
Esta biblioteca provee funcionalidades interesantes como selección elitista y escalado de fitness.
En general la biblioteca permite implementar cuatro tipos básicos de algoritmos genéticos: simple, de
estado estacionario , incremental y de vecindades.
El algoritmo genético simple es aquel descrito en el libro de Goldberg. Este algoritmo utiliza poblaciones
no solapadas y elitismo opcional. O sea en cada generación el algoritmo genético crea una nueva
población. Reemplazando la totalidad de la anterior.
El segundo tipo es de estado estacionario. En este caso utiliza poblaciones solapadas o sea ,uno puede
especificar qué porcentaje de la población vieja va a ser reemplazado por la nueva.
En la tercer variación cada generación consiste únicamente en uno o dos hijos. Este algoritmo le permite
al usuario escoger métodos de reemplazo para definir como una nueva generación puede ser integrada a la
nueva población.
El algoritmo genético basado en islas va evolucionando múltiples poblaciones en paralelo utilizando un
algoritmo de estado estacionario. En cada generación el algoritmo migra alguno de los individuos de cada
población a alguna otra población.
También Galib define los componentes que el usuario deberá necesitar para derivar sus propias clases de
algoritmos genéticos. Esto incluye un algoritmo genético que utiliza múltiples poblaciones y migración
entre poblaciones en múltiples CPUs.
Para el procesamiento paralelo utiliza PVM (Parallel Virtual Machine).
La mayor de las ventajas es que está escrito en un lenguaje orientado a objetos. Además provee varias
funcionalidades y clases creadas especialmente para que sean extendidas por el usuario. Es orientado
únicamente a los algoritmos genéticos por los que se le ofrecen al usuario importantes funcionalidades
que lo ayudarán a crear sus propias clases para que se adapten al problema a modelar.
Una de las mayores desventajas es que si bien se proveen ayudas para la implementación paralela en
múltiples procesadores es en definitiva el usuario el que deberá adaptar el modelo de islas pensado para
ser ejecutado en un procesador a ejecutarlo en una red o múltiples procesadores.
No es posible ejecutar su modelo paralelo en plataformas heterogéneas, etc.
3.5 PGAPACK
PGAPACK(Parallel Genetic Algorithm Library) es una biblioteca desarrollada por David Levine
integrante de la Mathematics and Computer Science División con el apoyo de la Mathematical ,
Information, and Computational Sciences División subprogram of the Office of Computational and
Technology Research , en el U.S. Department of Energy.
Esta biblioteca está escrita en C. Su diseño fue hecho en base a estructuras de datos orientadas a objetos.
PGA está basado en estructuras de individuos basados en un genotipo formado por un conjunto de alelos.
Los tipos de datos que posee un alelo son : Binario, entero, real , carácter.
El usuario podrá extender los tipos de datos de los alelos.
Provee varios operadores de selección, mutación , cruzamiento y la opción del usuario para poder
implementar algún otro operador.
Un usuario puede enfrentarse a la biblioteca de varias maneras.
En el modo más simple el usuario lo único que deberá hacer es implementar la función de fitness, escoger
el tipo de datos de los alelos para su representación, escoger el largo del String (cantidad de alelos de un
individuo), y seleccionar una dirección de optimización (maximizar o minimizar).
En otro modo más complejo el usuario podrá optar por escoger operadores de Selección , Cruzamiento ,
Mutación y/o implementar otros nuevos.
Esta biblioteca permite hibridizar el algoritmo genético con otras técnicas eurísticas como por ejemplo
hill-climbing.
PGA permite la ejecución en paralelo en varios procesadores. Nos permite utilizar el modelo maestro-
esclavo, donde el maestro es el proceso principal que realiza todo el trabajo genético pero delega la
evaluación de la función de fitness a sus esclavos.
Para la implementación paralela utiliza la biblioteca MPI (message passing interface).
Como ventajas podemos destacar la posibilidad de hibridizar el algoritmo genético , con otras técnicas
como hill-climbing. Ya ofrece implementado los operadores de cruzamiento y mutación.
Sin embargo está plagado de desventajas. Si bien el diseño está pensado orientado a objetos el programa
no fue escrito en un lenguaje orientado a objetos. Por lo tanto no es muy fácil de comprender, ni de
extender.
Si bien da una gran facilidad a la hora de crear nuevos tipos para codificar individuos , está pensado para
cromosomas aploides. La utilización de modelos nploides o incluso de individuos cuya codificación no
está dada por un cromosoma es difícil y compleja.
En general hay muchas restricciones sobre la escritura de código de un usuario que pretenda utilizar la
biblioteca.
El modelo paralelo solamente implementa el maestro- esclavo. Esta biblioteca no provee otros modelos
de paralelismo importantes como por ejemplo el de islas.
3.6 GECO
Geco (Genetic Evolution through Combination of Objects) es un framework extensible orientado a

objetos , para prototipar algoritmos genéticos en Common Lisp.
Geco hace extensivo la utilización de CLOS (the Common List Object System) para implementar sus
funcionalidades.
Las abstracciones provistas por las clases fueron escogidas con la intención de que se fácil de comprender
para cualquier persona que este familiarizada con el paradigma de los algoritmos genéticos , y de proveer
al desarrollador del algoritmo con la habilidad de adaptar la biblioteca a sus propias necesidades. El
interés en la utilización de Lisp es porque es el lenguaje más utilizado en el área de inteligencia artificial.
3.6.2 Funcionalidades
Geco está escrito en un lenguaje funcional orientado a objetos. Las clases más importantes que utiliza
son :
Ecosystem: Combinación de las poblaciones que están evolucionando y el plan genético que controla la
evolución.
Population: Conjunto de organismos que evolucionan.
He aquí una vista de la arquitectura general de GECO.

Una población está formada por un conjunto de organismos , cada uno de los cuales posee uno o varios
cromosomas.
Cada organismo se puede evaluar mediante una función de fitness.
El usuario deberá darle un valor a la misma para poder utilizar esta biblioteca.
Genetic Plan: Contiene la estrategia que determina como un ecosistema se regenera, por ejemplo como
nuevos organismos son creados a partir de viejos organismos. Esto incluye los esquemas de selección de
los organismos para la reproducción, reemplazo y manipulación por operadores genéticos.
Population Statics: Información acumulada sobre (al menos) los valores de la función de fitness de los
miembros de la población ,etc. Una instancia de esta clase es un componente de cada población.
Al usuario se le proveen varios tipos de selección , mutación y cruzamiento. El usuario si lo desea podrá
agregar su propio tipo de selección, mutación o cruzamiento.
Además de la función de fitness , el usuario deberá implementar los métodos de la clase organism para
realizar la codificación de su individuo. Muchas veces no será necesario ya que la biblioteca ofrece
implementaciones de esta clase para tipos comunes (array de bits, enteros, etc).
Esta biblioteca permite manejar varias poblaciones, sin embargo de manera totalmente paralela. Sin
migraciones ni ningún operador que vincule conjuntos de poblaciones.
Un área de aplicación de los algoritmos genéticos es la inteligencia artificial. La mayoría de los

programas de inteligencia artificial están implementados en Lisp , por lo tanto es una gran ventaja tener la
biblioteca de algoritmos genéticos implementada en Lisp de manera que la interacción sea inmediata.
Como otra ventaja, debido a la orientación a objetos es fácil de entender y de comprender su
funcionamiento.
Sin embargo debido a que Lisp es un lenguaje funcional, se hace complicado de extender para el
programador. Debido a que es un lenguaje funcional , no existe un mapeo directo entre la teoría de
orientación a objetos y la orientación a objetos que hay en Lisp. Con Lisp solamente se pueden ejecutar
modelos de algoritmos genéticos secuenciales, lo que restringe mucho su utilización para diversos
problemas.
3.7 SUGAL
SUGAL (Sunderland Genetic Algorithm package) fue realizado por el Dr Andrew Hunter en la
Universidad de Sunderland Inglaterra.
Esta biblioteca fue escrita en C, y ha sido diseñada para la experimentación con algoritmos genéticos.
Existen implementaciones en diversas plataformas MS-DOS , Unix, etc.
El principal objetivo de Sugal es ayudar al usuario a extender la biblioteca con una mínima intervención
de este en el código fuente existente. En el caso más simple el usuario sólo tiene que implementar la
función de fitness.
El usuario también puede a través de archivos de configuración escoger que tipo de selección,
cruzamiento , y mutación desea. De todas formas , este puede implementar su propia mutación,
cruzamiento y selección.
Sobre la estructura de los individuos , el usuario puede crearse su propia estructura.
Sin embargo esta biblioteca ya provee codificaciones típicas de individuos de la población (bit, entero sin
signo,real, etc).
Además Sugal provee métodos de normalización de fitness.
También provee implementaciones de los problemas de De Jong.
Sugal fue hecho pensando en un algoritmo secuencial. No puede ser utilizado para algoritmos genéticos
paralelos. Solamente para Unix ofrece la posibilidad de correr en una red varios algoritmos genéticos
secuenciales pero sin intercambio de material genético entre ellos.
Como máxima ventaja está orientado a algoritmos genéticos por lo tanto provee un gran número de
operadores propios de los algoritmos genéticos ya implementados.
Posee también el conjunto de pruebas de DeJong , para que el usuario puede experimentar con él.
La mayor desventaja es que está escrito en C, no es orientada a objetos , por lo tanto pierde claridad, y
no será fácil de extender.
Otra desventaja que no permite el procesamiento en paralelo por lo tanto es solamente para aplicarlo a
algoritmos genéticos secuenciales.
3.8 MALLBA
El proyecto Mallba es un esfuerzo desarrollado, en una manera integrada, es una biblioteca de esqueletos
para la optimización combinatoria (incluyendo métodos exactos, heurísticos y métodos híbridos) que se
puedan tratar con paralelismo de una forma eficiente y amigable. Entre estos métodos se encuentran los
algoritmos genéticos.
Está escrita en C++ y es orientada a objetos.
Mallba es una biblioteca que no está orientada exclusivamente a algoritmos genéticos. Provee varios
métodos exactos, híbridos y eurísticos. Entre los eurísticos se destacan los algoritmos genéticos.
El conjunto de los componentes de software que se especializan en uno de estos métodos es denominado
esqueleto.
Cada esqueleto está basado en la separación de dos conceptos. El problema concreto a ser resuelto y el
método general de resolución utilizado. Lo relacionado con la resolución general escogida y su
interacción con el problema concreto son implementados por el esqueleto mientras que aspectos
relacionados con el problema particular deberán ser implementados por el usuario.
Podemos decir que las clases Mallba están divididas en dos clases principales : las requeridas (required) y
las provistas(provided). Las clases requeridas son las que el usuario deberá implementar para poder
representar su problema. Las provistas son las ya implementadas por el esqueleto.
Por ejemplo la selección que no depende del problema a resolver es una clase provided por el esqueleto
mientras que el cruzamiento y la mutación (dependiente del problema) son required y por lo tanto deberán
ser implementadas por el usuario.
El paralelismo está implementado sobre MPI (message passing interface). Existe una clase NetStream que
se encarga de ocultar la utilización de dicha biblioteca.
El modelo de paralelismo de algoritmo genético provisto por Mallba es el de islas. Donde cada población
evoluciona por separado y cada determinado tiempo se efectúan migraciones de individuos de una isla a
la otra. Esta migración puede ser sincrónica o asincrónica , según el usuario lo desee.
Por más información consultar con MalbaClases, InteracciónClases.
Las principales ventajas es que es una biblioteca escrita en un lenguaje orientada a objetos. Además
cumple con varios principios básicos de diseño , alto acoplamiento y baja cohesión. Otra ventaja es que
permite la ejecución de algoritmos genéticos paralelos en particular el modelo de islas con migraciones
asincrónicas.
Desde el punto de vista de la optimización, Mallba ha sido diseñada pensando en que sea una biblioteca
eficiente lo que trae como contrapartida una pérdida de claridad en el código y no respetar ciertos
patrones de diseño.
Otra desventaja importante es que esta biblioteca aún está en construcción, y la documentación que
provee es solamente a nivel de usuario y no de una persona que quiera extender la misma.
Solo implementa el modelo de paralelismo de islas, no implemente el maestro esclavo y el celular.
3.9 Conclusiones finales:
Recorriendo las bibliotecas de algoritmos genéticos nos sorpendió la cantidad de estas que estaban
escritas en C. Si bien C es un buen lenguaje en cuanto a implementaciones donde la performance es un
requisito importante , no debemos olvidar que todo programa está expuesto a cambios y esos cambios
deben ser realizados con el menor impacto posible en el código. O sea necesitamos un código mantenible.
Con C podemos quedarnos cortos con esos requisitos. En nuestro caso queremos reutilizar estos
componentes y en C puede ser muy complicado. Por eso es una gran ventaja que una biblioteca este
orientada a objetos. C++ es un lenguaje orientado a objetos y además posee casi las mismas cualidades
que C en cuanto a su buena performance. Lisp es un lenguaje funcional ; los lenguajes funcionales si bien
han probado su éxito en áreas como la inteligencia artificial son muy difíciles de mantener y reutilizar.
En la introducción a la presentación de la biblioteca habíamos resaltado un conjunto de propiedades
importantes que debería cumplir una biblioteca de algoritmos genéticos.
Estas propiedades son fundamentales para el tipo de algoritmo genético que debemos implementar.
De las bibliotecas algunas ni siquiera presentaban un modelo de paralelismo. Una gran cantidad de
bibliotecas solamente se limitaron al modelo maestro esclavo, modelo que puede ser imprescindible para
muchas aplicaciones donde el tiempo de demora de evaluación de la función de fitness es importante ,
pero es muy limitado en cuanto a que debemos manejar una sola población.
Por otra parte solamente una biblioteca provee el modelo celular(EO). Este modelo es interesante pero no
es lo que estamos buscando.
Una biblioteca que nos sorpendió fue Gallops la cual proveía independencia de la arquitectura de la
computadora. Podíamos ejecutar un algoritmo genético paralelo mezclando computadoras con Linux y
Windows. Lamentablemente esta biblioteca está escrita en C.
De todas las bibliotecas presentadas las únicas que se adaptan a las propiedades interesantes descritas en
la conclusión son: EO, Galib y Mallba.
EO aparenta ser una biblioteca ampliamente utilizada, con bastante documentación y un buen diseño. EO
provee varios modelos de paralelismo interesantes. De Galib en cambio la parte de paralelismo no está
muy documentada y aparenta que su implementación no es directa en el sentido de que no es fácil de
hacer.
Mallba no provee documentación, sin embargo el código fuente cumple los más rigurosos estándares de
escritura de código. Su diseño es bueno , cumple con los criterios de diseño más importantes ; Alta
cohesión y Bajo acoplamiento entre módulos. La única falla en el diseño de este biblioteca es la no
explotación de la herencia. Muchas veces el buen diseño va en contrapartida con la performance. En este
caso Mallba optó por no explotar demasiado la herencia a favor de mantener una buena performance.
4 Referencias
[1] Darrell Whitley , A Genetic Algorithm Tutorial, Statistics and Computing Volume 4, pp. 65-85, 1994
[2] D. E. Goldberg.,Genetic Algorithms in Search, Optimization and Machine Learning, Addisson Wesley,
1989
ISBN 0-20115767-5.
[3] Sergio Nesmachnow ,Aplicación de las Técnicas de Procesamiento de Alta Performance a la

Implementación de Algoritmos
Genéticos, TR 02-06, Julio 2002
[4] E. Alba, J. Troya. Algoritmos Genéticos Incrementales. Informe técnico, Noviembre 1995
[5] C. Thornton,The Building Block Fallacy, BN1 9QH, 1997
[6] E. Alba, J. Troya., An Analysis of Synchronous and Asynchronous Parallel Distribuited Genetic
Algorithms with Structured and Panmictic Islands, 1997
[7] R. Bianchini, C. M. Brown, M. Cierniak, y W. Meira,Combining Distributed Populations And

Periodic Centralized Selections in Coarse-Grain Parallel Genetic Algorithms, 1995
[8] J. J. Merelo , Informática evolutiva: Algoritmos genéticos, http://geneura.ugr.es/~jmerelo/ie/ags.htm,

visitada 3/9/03
[9] The EvoNet Online Tutorial,

http://146.176.162.36/evoweb/resources/flying_circus/tutorials/online_tutorial/, visitada 4/9/03
[10] Jian Qian, Xiangyuan Wang, Ruixin Wu, Min.Pei., Adaptive Hierarchical Fair Competition (AHFC)
Model for Parallel Evolutionary Algorithms, 2002
[11] M. Tomassini, Parallel and Distributed Evolutionary Algorithms: A Review, 1998
[12] H. Muhlenbein, Parallel genetic algorithm in combinatorial optimization, 1988
[13] Enrique Alba, José M. Toya Analyzing Synchronous and Asynchornous Parallel Distributed Genetic
Algorithms, Dpto de Lenguajes y Ciencias de la Computación , Univ de Málaga. Visitada 08/2003.
[14] JianJun Hu* , Eric D. Goddman*, Kisung Seo*, Min Pei*, Adaptive Hierarchical Fair Competition
(AHFC) Model for Parallel Evolutionary Algorithms. Visitada 09/2003.
[15] Sergio Nesmachnow , Evolución en el diseño y clasificación de Algoritmos Genéticos Paralelos.

Universidad de la república , instituto de computación. Visitada 07/2003.
[16] EO Evolutionary Computation Framework: http://eodev.sourceforge.net/ Visitada 08/2003.
[17] Gallops http://garage.cps.msu.edu/software/galopps/galopps.general.description.html Visitada

08/2003.
[18] PGA Pack Library

http://www-fp.mcs.anl.gov/CCST/research/reports_pre1998/comp_bio/stalk/pgapack.html Visitada
08/2003.
[19] Página de Mallba, http://neo.lcc.uma.es/mallba/easy-mallba/html/mallba.html, visitada 8/2003.
[20] SUGAL, http://www.dur.ac.uk/andrew1.hunter/Sugal/, visitada 8/2003.
[21] Geco , Código fuente, ftp://ftp.aic.nrl.navy.mil/pub/galist/src/GECO-v2.0.tar.Z , visitada 8/2003.
[22] Galib , http://lancet.mit.edu/ga/, visitada 8/2003

Estado Del Arte Final

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Estado Del Arte Final

Cargado por

Copyright:

Formatos disponibles

Proyecto Algoritmos genéticos incrementales

Federico Dominioni - Pablo Musso

Estado del arte

Proyecto Algoritmos Genéticos Incrementales

Federico Dominioni - Pablo Musso

1.2 Definiciones y Siglas

En el capítulo 1 introducimos al lector en los algoritmos genéticos secuenciales, de dónde provienen, la

1.4.2 Computación evolutiva:

Figura 1: Patrón de la evolución acumulativa

Formalizando un poco lo dicho anteriormente y a modo de resumen, las técnicas de computación

De esta manera un EA basa su funcionamiento en generar aleatoriamente una población inicial de

Los EA abarcan tres etapas fundamentales: selección, recombinación y reemplazo.

a) Basadas en poblaciones: A diferencia de muchas otras técnicas heurísticas, se caracterizan por

b) No operan sobre el espacio real: Debemos construirnos un “especio de representaciones” que

d) Un mecanismo de selección para simular la supervivencia de aquellos individuos más aptos al

1.4.3 Algoritmo Genético Simple

El esquema general del mismo es el siguiente:

While Not (Condicion_de_Finalización(P(t)))

A partir de lo anterior se destacan 3 etapas fundamentales:

 Selección: Luego de evaluar a los individuos de la población actual, se realiza un

 Reemplazo: En el AGS el reemplazo es generacional, por lo tanto una nueva

max/ min f(x 1 , x 2 ,....x n )

Una vez parametrizado el problema en las variables x 1 , x 2 ,....x n , debemos codificarlas en un

 Genotipo: Es la representación a nivel de cromosomas de un individuo. Puede ser por ejemplo

Definimos formalmente un AG mediante la siguiente tupla de parámetros:

AG (, G,  , f,  , , S, Gap, , R, )

  es denominado espacio de búsqueda, y es aquel espacio en el cual el AG trabaja (a nivel

  :G   es la función de representación, dicha función es la que expresa un genotipo

 f:  R  es la función de fitness, es decir esta función mide cuan adaptado se

  :   P () representa a la función de inicialización, es decir aquella función que

 S es el mecanismo de selección utilizado, como veremos mas adelante ruleta, torneo,

 Gap corresponde al porcentaje de la población que será manipulada en cada

  representa el conjunto de operadores genéticos utilizados. Dependiendo del

 R corresponde a la política de reemplazo utilizada para generar una nueva

 es la condición de finalización del algoritmo, la cual puede ser un numero determinado

1.4.4 Operadores de Selección

1.4.5 Operadores de Cruzamiento y Mutación

El cruzamiento de un punto es el tipo más común de cruzamiento. En el ,dado una codificación de

Sean los Strings:

El largo de cada String es 12. Escojo aleatoriamente un número entre 1 y 11.

Los Strings finales serán los siguientes:

Cruzamiento de dos puntos:

Intercambio los segmentos y obtengo:

Al realizar el cruzamiento obtenemos:

A’= 1234| 4368

B’= 1265| 5678

Luego los huevos son desplazados.

Este tipo de cruzamiento es diferente.

Suponemos que tenemos

Así sucesivamente hasta que se termina el ciclo.

1.4.7 La base de su funcionamiento: Definiciones Previas

de forma que pueda machear con cualquier valor del alfabeto .

1.4.8 El Teorema de los Esquemas

Siendo p m la probablidad de mutación de un gen se demuestra que:

A continuación se mostrará como funciona de manera cualitativa el proceso de búsqueda de un AG

Si consideramos un espacio de búsqueda tridimensional, el AG muestreará distintos hiperplanos

Figura 2: Cubo tridimensional correspondiente al espacio de representaciones

1.4.9 Paralelismo Implícito y Desventajas de la Teoría

1.4.10 Como hacer para resolver mi problema con un AG

De esta manera modificamos la función de fitness por la escalada f’ haciéndo

El cual se encuentra constituido por los cromosomas homólogos AbCDe y aBCde.

2.1 ¿Porqué paralelizar?

 Usualmente son ineficientes

2.2 Modelo Maestro – Esclavo