Metodologia para incorporar algoritmos poblacionales a ECJ
84
Universidad Central “Marta Abreu” de Las Villas Facultad de Matemática, Física y Computación Trabajo para optar por el Título de Licenciado en Ciencia de la Computación Metodología para la incorporación de Algoritmos Poblacionales a la plataforma de optimización ECJ Autor: Magdiel A. Docando Vázquez Tutores: Lic. Gonzalo Nápoles Ruiz Dr. Rafael Bello Pérez 2013
Transcript of Metodologia para incorporar algoritmos poblacionales a ECJ
Universidad Central “Marta Abreu” de Las Villas
Facultad de Matemática, Física y Computación
Trabajo para optar por el Título de
Licenciado en Ciencia de la Computación
Metodología para la incorporación de
Algoritmos Poblacionales a la plataforma de
optimización ECJ
Autor:
Magdiel A. Docando Vázquez
Tutores:
Lic. Gonzalo Nápoles Ruiz
Dr. Rafael Bello Pérez
2013
Hago constar que el presente Trabajo para optar por Título de Licenciado en Ciencia de la
Computación ha sido realizado en la facultad de Matemática, Física y Computación de la
Universidad Central “Marta Abreu” de Las Villas (UCLV) como parte de la culminación
de los estudios de Licenciatura en Ciencia de la Computación, autorizando a que el mismo
sea utilizado por la institución para los fines que estime conveniente, tanto de forma total
como parcial y que además no podrá ser presentado en eventos ni publicado sin la previa
autorización de la UCLV.
______________________________
Firma del Autor
Los abajo firmantes, certificamos que el presente trabajo ha sido realizado según acuerdo
de la dirección de nuestro centro y que el mismo cumple con los requisitos que debe tener
un trabajo de esta envergadura referido a la temática señalada.
____________________ ____________________
Firma del Tutor Firma del Tutor
Lic. Gonzalo Nápoles Ruiz Dr. Rafael Bello Pérez
Dedicatoria
A mis padres por su incansable lucha,
por su infinito amor e incondicional apoyo.
Agradezco sinceramente:
A mis tutores Lic. Gonzalo Nápoles Ruiz y Dr. Rafael Bello Pérez por constituir
ejemplos de profesionales a seguir.
A Jorge L.Toro por su incondicional apoyo para la realización de esta tesis sin
conocerme apenas.
A toda mi familia por su ánimo y confianza, en especial a mis padres que hicieron
de mi carrera la suya también, a mis hermanos, a mis abuelas y a mis tías y primos.
A mi tía Saily, mi tío Jorge y mi prima Lianet por acogerme en su casa tantos fines
de semana.
A mi amor por todo su apoyo, por creer en mí, por darme su amor incondicional
durante todo el camino que hemos recorrido juntos, para ti mi infinito
agradecimiento.
A los amigos de la carrera por ayudarme en todo momento; especialmente a Sergito
R. y a Víctor Marrero.
A mis profesores de clases que con tanta sabiduría me prepararon para ser un buen
profesional.
A todas aquellas personas que de una forma u otra, ayudaron a la realización de este
trabajo.
“Educar no es dar carrera para vivir,
sino templar el alma para las dificultades de la vida”
Pitágoras
RESUMEN
En los últimos años los algoritmos de optimización poblacionales han ganado bastante
atención entre los investigadores. Estos algoritmos son aproximados y no garantizan
encontrar el óptimo global. Sin embargo, son capaces de estimar buenas aproximaciones en
un tiempo razonable, a diferencia de los métodos directos de Programación Lineal donde el
tiempo de cómputo es en ocasiones impracticable. Los enfoques meta-heurísticos se han
aplicado a muchos problemas de aplicación relacionados con la ingeniería, diseño,
optimización de procesos industriales, en la estimación de parámetros de otros algoritmos,
etc. A pesar de su éxito, existen pocas bibliotecas que agrupen a los enfoques más
utilizados. Una de estas plataformas es ECJ (Evolutionary Computing in Java) la cual fue
especialmente concebida para agrupar a los principales métodos evolutivos, aunque más
tarde ha sido extendida a otros enfoques. Sin embargo, adicionar un nuevo algoritmo a esta
biblioteca no es trivial. En este trabajo se propone una metodología para incorporar nuevos
algoritmos poblacionales (evolutivos y basados en Inteligencia Colectiva) a la plataforma
ECJ, incrementando de esta forma su usabilidad. Adicionalmente, se explica el principio de
funcionamiento de la biblioteca, ofreciendo a los usuarios un entendimiento más natural del
esquema establecido para la interacción con la herramienta.
ABSTRACT
In recent years the population-based algorithms have gained a lot of attention among
researches. Such algorithms are approximate and the does not guarantee to find a global
optimum. However, they are able to estimate good approximations in a reasonable time,
which is the main difference with respect to direct methods of Lineal Programming, where
the execution time in some cases is unreasonable. The metaheuristic approaches have been
successfully applied to an extensive range of real-world problems including engineering,
design, for optimizing industrial process, for estimating some parameters in other
algorithms, etc. Despite their success, there ere a few libraries for gathering the most
widely used approaches. For example, ECJ (Evolutionary Computing in Java) was
specially designed to gathering the main evolutionary algorithms, but latter it was extended
to other approaches. Nevertheless, adding a new algorithm to ECJ it is no trivial for users.
This work proposes a methodology for adding new population-based algorithms
(evolutionary and Swarm Intelligence) to the framework ECJ, thus enhancing its usability.
In addition, it is explained the main ideas about the library, offering to users better
understanding.
TABLA DE CONTENIDOS
INTRODUCCIÓN ............................................................................................................ 1 Capítulo 1 META-HEURÍSTICAS POBLACIONALES ................................................ 6
1.1 Algoritmos Evolutivos ............................................................................................ 6 1.2 Inteligencia Colectiva ............................................................................................. 9 1.3 Descripción de las principales meta-heurísticas ................................................... 10
1.3.1 Algoritmos Genéticos .................................................................................... 10 1.3.2 Evolución Diferencial .................................................................................... 14
1.3.3 Optimización de Enjambre de Partículas ....................................................... 16 1.3.4 Optimización de Colonias de Hormigas ........................................................ 19
1.3.4 Optimización de Mallas Variables ................................................................. 20 1.4 Conclusiones parciales .......................................................................................... 23
Capítulo 2 METODOLOGÍA PARA LA INCORPORACIÓN DE ALGORITMOS A LA
PLATAFORMA DE OPTIMIZACIÓN ECJ ................................................................. 25
2.1 ¿Qué es ECJ y cómo funciona? ............................................................................ 25 2.1.1 Parámetros y Fichero de Parámetros ............................................................. 30
2.1.2 Proceso Evolutivo .......................................................................................... 36 2.1.3 Objeto SimpleEvolutionState ........................................................................ 37 2.1.4 Objeto SimpleStatistics .................................................................................. 39
2.1.5 La Clase Population y algunas de sus subclases ............................................ 40 2.1.6 Procedimiento de Breeding en ECJ ............................................................... 41
2.1.7 Definiendo el Problema ................................................................................. 43
2.2 Metodología para incorporar nuevos algoritmos a ECJ ........................................ 44
2.3 Incorporando la meta-heurística VMO a ECJ ....................................................... 46 2.4 Conclusiones parciales .......................................................................................... 49
Capítulo 3 VERIFICACIÓN DE LOS RESULTADOS................................................. 50 3.1 Especificaciones del experimento ......................................................................... 50 3.2 Análisis de los resultados ...................................................................................... 64
3.3 Conclusiones parciales .......................................................................................... 66 CONCLUSIONES .......................................................................................................... 67
RECOMENDACIONES ................................................................................................. 68 REFERENCIAS BIBLIOGRÁFICAS ........................................................................... 69
ANEXOS ........................................................................................................................ 71 Anexo 1: Gráficas de las Funciones experimentales .................................................. 71
Anexo 2: Resultados del test de Wilcoxon ................................................................. 75
1
INTRODUCCIÓN
Muchos de los problemas científicos, ingenieriles o industriales de optimización, pueden
ser solucionados utilizando técnicas computacionales. Frecuentemente estos problemas no
tienen solución algorítmica conocida o es tan compleja que no tienen una implementación
práctica computacional. De hecho, la mayoría de los problemas de decisión que
normalmente se presentan en la vida empresarial e industrial pueden ser considerados como
verdaderos retos desde el punto de vista de optimización. Por otra parte, la formulación de
estos problemas por los expertos del dominio de aplicación, normalmente consideran una
serie de recursos limitados (materias primas, presupuesto, tiempo, factibilidad, etc.) o bien
requisitos mínimos que hay que cumplir, y que condicionan la elección de la estrategia más
adecuada. Sin perder la generalidad, el objetivo final del proceso de toma de decisión es
llevar a cabo el plan propuesto de manera óptima (incurriendo en mínimos costos o bien
buscando el máximo beneficio).
Para lidiar con estos problemas, en los últimos años varios enfoques computacionales han
sido propuestos por los investigadores de todo el mundo. Estas técnicas pueden ser
clasificadas como técnicas exactas o técnicas aproximadas. Sin embargo también han
surgido nuevos problemas de optimización que resultan difíciles de resolver mediante las
estrategias existentes. Tal vez el ejemplo más representativo de la familia de técnicas
exactas es la llamada Programación Lineal (Vanderbei, 2001, Luenberger and Ye, 2008),
siendo el algoritmo Simplex el punto de referencia de la misma. Sin embargo, como ocurre
en muchas ocasiones la cantidad de variables que intervienen en el modelo hacen que la
aplicación del Simplex no resulte eficiente ya que la complejidad computacional asociada
es excesivamente alta, incluso para los grandes supercomputadores. Es importante aclarar
que el método Simplex es capaz de encontrar el óptimo deseado, pero como fue
mencionado su tiempo de respuesta no es operativo.
Por otra parte, la existencia de una gran cantidad y variedad de problemas de optimización,
que surgen de necesidades prácticas y que necesitan ser resueltos de forma eficiente,
Introducción
2
impulsó el desarrollo de nuevos procedimientos alternativos para encontrar buenas
soluciones aunque no fueran óptimas. Estos métodos, en los que la rapidez del proceso es
tan importante como la calidad de la solución obtenida, se denominan heurísticos o
aproximados. En la bibliografía (Hooker, 1995, Müller-Merbach, 1981) es posible
encontrar una amplia variedad de definiciones de algoritmo heurístico. En la resolución de
problemas específicos han surgido procedimientos heurísticos exitosos. Precisamente las
ideas y formulaciones más generales se han extendido a problemas cada vez más diversos.
De esta forma se han obtenido estrategias generales de diseño para procedimientos
heurísticos de resolución de problemas. Estas estrategias para la construcción de algoritmos
más generales son denominadas meta-heurísticas. En este Trabajo de Diploma se utiliza la
definición de meta-heurística propuesta por los autores (Glover and Kochenberger, 2003):
“Los procedimientos meta-heurísticos son una clase de métodos aproximados que están diseñados
para resolver problemas complejos de optimización, en los que los heurísticos clásicos no son
efectivos. Los algoritmos meta-heurísticos proporcionan un marco general para crear nuevos
métodos híbridos combinando diferentes conceptos derivados de la inteligencia artificial, la
evolución biológica y los mecanismos estadísticos”.
Más informalmente, la meta-heurísticas se define como herramientas para diseñar
procedimientos heurísticos más complejos. Por tanto, los tipos de meta-heurísticas se
establecen por características que presentan los métodos, dando lugar a biparticiones del
conjunto de meta-heurísticas. Dependiendo de la cantidad de soluciones que se mantienen
en una misma iteración dos grandes clasificaciones son extraídas y brevemente resumidas
de (Puris, 2009) como se muestra a continuación:
meta-heurísticas de trayectoria simple: se utiliza el término de trayectoria simple
porque el proceso de búsqueda que desarrollan estos métodos se caracteriza por una
trayectoria en el espacio de soluciones; es decir, que partiendo de una solución inicial,
son capaces de generar un camino o trayectoria en el espacio de búsqueda a través de
operaciones de movimiento. En este tipo de meta-heurísticas se destacan: la Búsqueda
Tabú (Tabu Search)(Glover and Laguna, 1997), Recocido Simulado (Simulated
Annealing)(Kirkpatrick et al., 1983) entre otros.
Introducción
3
meta-heurísticas poblacionales: Las meta-heurísticas basadas en población, o meta-
heurísticas poblacionales, son aquellas que emplean un conjunto de soluciones
(población) en cada iteración del algoritmo, en lugar de utilizar una única solución
como las meta-heurísticas del grupo anterior. Estas proporcionan de forma intrínseca un
mecanismo de exploración paralelo del espacio de soluciones, y su eficacia depende en
gran medida de cómo se manipule dicha población. Dentro de esta clasificación se
destacan los Algoritmos Evolutivos (Bäck, 1996) y los algoritmos basados en
Inteligencia Colectiva (Bonabeau, 1999).
Problema Científico
Muchos problemas de la vida real pueden ser modelados como clásicos problemas de
optimización, que han sido abordados históricamente con métodos matemáticos. Como
alternativa a la alta complejidad computacional de estas técnicas, surgen los algoritmos
aproximados. Estos ofrecen soluciones aceptables, en menor tiempo. Sin embargo, son
pocas las plataformas (bibliotecas) que agrupen estas técnicas desde un punto de vista
homogéneo. Una de las plataformas más completas basada en el paradigma de Software
Libre es la biblioteca ECJ (Evolutionary Computing in Java) que agrupa alguno de los
algoritmos poblacionales más populares, aunque estas algoritmos son escasos o están
desactualizados, y la incorporación de nuevos algoritmos no es trivial.
Objetivo general
Formalizar una metodología computacional que permita incorporar nuevos algoritmos
meta-heurísticos poblacionales de optimización (evolutivos y de inteligencia colectiva) a la
biblioteca ECJ, utilizando Java como lenguaje de programación.
Objetivos específicos
1. Formalizar los pasos necesarios, a través de una metodología computacional, para
agregar algoritmos poblacionales de optimización a la plataforma ECJ.
2. Validar la factibilidad de la metodología propuesta a través de la incorporación de una
meta-heurística poblacional (Variable Mesh Optimization, VMO)
Introducción
4
3. Verificar el correcto funcionamiento del algoritmo incorporado en la biblioteca ECJ a
través de un estudio estadístico comparativo respecto a los resultados del método
VMO publicados originalmente, utilizando 25 funciones de pruebas.
Justificación
El laboratorio de Inteligencia Artificial de la UCLV ha desarrollado varios algoritmos de
optimización como parte de la producción científica de sus estudiantes de maestría y
doctorado. Sin embargo, estos algoritmos no están agrupados en un único entorno y con el
paso de los años solo son accesibles las publicaciones, por lo que resulta necesaria la
formulación de un marco de trabajo único en el cual los investigadores y profesores del
CEI puedan agrupar los nuevos algoritmos desarrollados.
1. La Relevancia social de este proyecto radica en su dimensión interna, en la contribución
al desarrollo de investigaciones en el área de la optimización, y en su dimensión externa,
en ampliar la herramienta y así permita resolver problemas reales en distintas áreas de la
vida.
2. Implicaciones prácticas se relaciona con el desarrollo de una plataforma que brinda la
posibilidad de ser aplicado para la solución de problemas reales por el grupo de
Inteligencia Artificial del Centro de Estudios de Informática.
3. Utilidad Metodológica se manifiesta a través de que su desarrollo es aplicable a
cualquier algoritmo poblacional.
Hipótesis de investigación
1. Es posible formalizar una metodología que permita incorporar nuevos algoritmos
evolutivos y poblacionales a la biblioteca de optimización ECJ.
Esta hipótesis quedará validada si se comprueba que:
Con la metodología planteada se pueden incorporar satisfactoriamente nuevos
algoritmos evolutivos y poblacionales a la plataforma ECJ.
Introducción
5
Diseño de la Tesis
Después de la Introducción, la tesis está estructurada en tres capítulos. En el primero de
ellos se hace un análisis de las meta-heurísticas poblacionales y sus principales fuentes de
inspiración. El segundo capítulo propone una metodología para la incorporación de nuevos
algoritmos a la plataforma de optimización ECJ. Además se valida esta metodología con la
incorporación de un caso de estudio (VMO). Por su parte, el tercer capítulo realiza la
verificación de los resultados obtenidos a través de un estudio estadístico comparativo para
25 funciones de pruebas. Por último, se formulan las conclusiones y recomendaciones y se
relacionan las Referencias Bibliográficas.
6
Capítulo 1 META-HEURÍSTICAS POBLACIONALES
En este capítulo se presenta un estudio de las meta-heurísticas poblacionales, así como una
descripción de los algoritmos más representativos de esta rama.
1.1 Algoritmos Evolutivos
Los algoritmos evolutivos (AE)(Bäck, 1996) son métodos de optimización y búsqueda de
soluciones basados en los postulados de la evolución biológica. En ellos se mantiene un
conjunto llamado población, cuyos elementos representan posibles soluciones, las cuales se
mezclan, y compiten entre sí, de tal manera que las más aptas son capaces de prevalecer a
lo largo del tiempo, evolucionando hacia mejores soluciones. La población, en el contexto
de la computación evolutiva de forma general se refiere a un conjunto de posibles
soluciones (soluciones factibles) del problema que se desea resolver.
Los AE se caracterizan por operar sobre una población inicial (usualmente generada
aleatoriamente) que sufre un proceso iterativo que conduce a la evolución de dicha
población (a semejanza de la natural), mediante los siguientes pasos (Puris, 2009):
Se aplica un operador de selección que determina la probabilidad de cada individuo de
perdurar en la generación siguiente, construyéndose así una población temporal.
Se aplican operadores evolutivos a la población temporal, con lo que se produce un
conjunto de nuevas soluciones.
Se calcula el valor de la función a optimizar en las nuevas soluciones generadas.
Se obtiene una nueva población a partir de la población temporal y por lo tanto los
nuevos individuos generados.
Dichos pasos son realizados hasta que se cumple un criterio de terminación (por ejemplo,
se alcanza un límite máximo temporal o un número máximo de evaluaciones de la función
objetivo). El procedimiento de crear nuevos individuos a partir de los existentes en la
Capítulo 1
7
población, y en el que los mejores sustituyen a los anteriores, es lo que se denomina
evolución de la población. Construir los nuevos individuos combinando características de
buenas soluciones encontradas hasta el momento (almacenadas en la población) es lo que
permite orientar la búsqueda hacia las regiones más prometedoras.
De forma general, los AE comparten los mismos conceptos básicos, aunque difieren en el
mecanismo empleado para codificar las soluciones y los operadores que emplean para
producir la siguiente generación. Como se muestra en (Bäck and Schwefel, Bäck et al.,
1997) la computación evolutiva puede ser dividida en diferentes modelos, los cuales
comparten todas o algunas de las características antes mencionadas. Cada una de ellos:
Programación Evolutiva (PE), Estrategias Evolutivas (EE), Algoritmos Genéticos (GA) y
Programación Genética (PG) se describen brevemente a continuación.
● Algoritmos Genéticos son una técnica de búsqueda y optimización, altamente paralela,
inspirada en el principio Darwiniano de selección natural y reproducción genética, en la
literatura (Goldberg, 1989) se define como:
“Algoritmos de búsqueda basados en los mecanismos de selección natural y genética natural.
Combinan la supervivencia de los más compatibles entre las estructuras de cadenas, con una
estructura de información ya aleatorizada, intercambiada para construir un algoritmo de búsqueda
con algunas de las capacidades de innovación de la búsqueda humana.”
Características de estos algoritmos
Frecuentemente la representación (codificación) de los individuos se realiza a través
de cadenas binarias.
Utiliza selección proporcional: se elige el mejor individuo con base en una
distribución de probabilidades proporcional a la función objetivo.
El operador principal es la recombinación, mientras que la mutación es solo un
operador secundario aplicado eventualmente.
● Estrategias de Evolución (Beyer, 2001) Estas estrategias fueron originalmente
propuesta por Ingo Rechenberg donde se utiliza la selección, mutación y población de
Capítulo 1
8
tamaño uno. Posteriormente, Hans-Paul Schwefel introdujo el cruce y poblaciones con más
de un individuo (progenitores). Ellas están basadas en el concepto de la evolución donde la
idea fundamental es optimizar el proceso evolutivo utilizando estrategias que lo influencian
por medio de su adaptación en paralelo con la población.
Algunas características son:
La representación para los individuos se basa en la información genética propia del
individuo. Adicionalmente cada individuo tiene un conjunto de parámetros
estratégicos asociado.
Por lo tanto, la mutación se realiza tanto en el material genético como en los
parámetros del algoritmo.
Al igual que la mutación, el cruce de individuos involucra la recombinación de la
carga genética y de las estrategias de los progenitores.
Luego de evaluar las k soluciones hijas, se seleccionan n descendientes de forma
determinística mediante algún método.
● Programación Evolutiva (Langdon and Poli, 2002) Fue propuesta por Lawrence J.
Fogel, como una técnica de búsqueda en un espacio de pequeñas máquinas de estados
finitos. Posteriormente fue utilizada como un procedimiento de optimización. El proceso de
evolución consiste en encontrar un conjunto de comportamientos adecuados de un espacio
de comportamientos observados. La función objetivo calcula el “error en el
comportamiento” de un individuo con respecto al ambiente al cual pertenece.
La programación evolutiva posee las siguientes características:
Utiliza una representación para los individuos adaptada al problema concreto que
trata de resolver.
La mutación se realiza de acuerdo a la representación utilizada y es el único
operador que utiliza para producir nuevos hijos. Generalmente se utiliza un Torneo
Probabilístico para seleccionar los mejores individuos que formarán la próxima
generación (estrategia elitista).
Si bien no se realiza cruce de individuos, la mutación es lo suficientemente flexible
como para producir un efecto similar al del cruce.
Capítulo 1
9
● Programación Genética (Koza, 1992) De forma general la programación genética es
una especialización de los algoritmos genéticos, por lo que también se concentra en la
evolución de los genotipos. Sin embargo, a diferencia de los algoritmos genéticos, los
individuos se representan en este caso como árboles (estructuralmente). En este modelo
cada individuo representa un programa computacional el cual se codifica utilizando una
estructura de árbol. El problema se define mediante el uso de gramáticas. La función de
aptitud depende exclusivamente del problema que se esté tratando. Los operadores de cruce
sobre las estructuras de árbol son implementados seleccionando aleatoriamente un nodo de
cada uno de los árboles padre, y reemplazando el subárbol correspondiente en uno de los
padres por el del otro. Los operadores de mutación eligen un nodo aleatoriamente y lo
reemplazan por otro generado al azar.
1.2 Inteligencia Colectiva
Las meta-Heurísticas basadas en Inteligencia de Enjambre o también conocida como
Inteligencia Colectiva no son más que técnicas bio-inspiradas en el comportamiento
colectivo de diversos sistemas naturales (Bonabeau, 1999). Los sistemas realizados bajo el
enfoque de la inteligencia colectiva se caracterizan por exhibir características que hacen a
las sociedades de agentes (insectos por ejemplo) exitosas en su entorno. Estas técnicas son
generalmente flexibles, de control descentralizado y auto organizativo. Dicho
comportamiento social define los movimientos de las variables de decisión en el espacio de
búsqueda y las orienta hacia soluciones óptimas.
Optimización de Enjambre de Partículas (Particle Swarm Optimization; PSO)
Según (Kennedy and Eberhart, 1995) esta meta-heurística se basa en el modelo psico-
social de entidades colectivas. PSO posee influencia y aprendizaje social que se refleja
en cada agente de la entidad. Los individuos (partículas) en la heurística emulan una
característica simple: adaptan su comportamiento al de los individuos dentro de su
propio vecindario o de la población completa .El algoritmo fue inspirado en los
Capítulo 1
10
patrones de vuelo de algunas aves; imita una bandada corriendo un espacio, probando
diferentes lugares y convergiendo la bandada o cúmulo (swarm) a las mejores regiones,
es decir, aquellas donde se encuentra el objetivo deseado. Una partícula se mueve
dentro del espacio de búsqueda siguiendo una trayectoria definida por su velocidad, y la
memoria de dos buenos valores: el mejor encontrado por ella misma en su pasado y el
mejor valor encontrado por alguna partícula de la población. Estos dos valores generan
una “atracción” hacia los lugares más prometedores, y a esta atracción o fuerza se le
denomina presión social.
Optimización basada en Colonias de Hormigas (Ant Colony Optimization; ACO)
Como se muestra en (Dorigo and Stutzle, 2004) es una técnica de optimización de
propósito general basada en el comportamiento de colonias de hormigas reales,
concretamente en las feromonas que depositan entre la comida y el nido para marcar de
esta forma el mejor camino encontrado. La cantidad de feromonas en un camino
aumenta cada vez que una hormiga lo atraviesa. A medida que esta cantidad
incrementa, la probabilidad de que una hormiga siga ese camino también lo hace, por lo
que la cantidad de feromonas en el camino más corto será mayor después de un
determinado tiempo y, como consecuencia, un mayor número de hormigas tenderán a
seleccionar dicho camino. Sin embargo, la decisión de seguir un camino o no nunca es
determinista, por lo que se permite la continua exploración de rutas alternativas. Estos
algoritmos utilizan también un procedimiento de evaporación que reduce la cantidad de
feromona a lo largo del tiempo, haciendo énfasis en nuevas soluciones para evitar los
estados de estancamiento (Dorigo, 1999).
1.3 Descripción de las principales meta-heurísticas
1.3.1 Algoritmos Genéticos
Los Algoritmos Genéticos(AG) (Goldberg, 1998) surgen como herramientas para la
solución de complejos problemas de búsqueda y optimización, producto del análisis de los
Capítulo 1
11
sistemas adaptativos en la naturaleza, y como resultado de abstraer la esencia de su
funcionamiento. El término Algoritmo Genético se usa por el hecho de que estos simulan
los procesos de la evolución a través del uso de operadores genéticos que operan sobre una
población de individuos que “evoluciona” de una generación a otra. Los Algoritmos
Genéticos son métodos de búsqueda de propósito general basados en los principios de la
genética naturales. En la Tabla 1.1 se muestran una serie de términos “importados” de la
genética natural para el trabajo con AG. Sin embargo no siempre es adecuada la analogía,
pero estos son comúnmente aceptados:
Tabla 1.1 Principales conceptos usados en Algoritmos Genéticos.
Población Conjunto de individuos o cromosomas. Equivale a una muestra aleatoria
del espacio de solución o un conjunto de soluciones alternativas.
Cromosoma Un cromosoma es un portador de la información genética que transmite
cada uno de sus genes. Una posible solución.
Gen Cada uno de los rasgos o características que conforman el cromosoma.
También se les llama parámetros o aspectos. Cada gen equivale a una
variable del problema.
Genotipo En biología se le llama al “paquete” genético total en su forma interna. En
la terminología de AG será la información genética de todo el cromosoma
en forma codificada.
Fenotipo Se le llama en genética al paquete genético tal y como interactúa con el
medio exterior. En los AG artificiales serían los aspectos del cromosoma
decodificados.
Locus Es la posición de un gen en el cromosoma
Alelo Es el valor asociado a un gen
Los AG trabajan a partir de una población inicial de estructuras artificiales que se van
modificando iterativamente durante el proceso de búsqueda, a través de la aplicación de los
siguientes operadores genéticos:
Operador de Selección o Darwiniano
Operador de Cruzamiento o Mendeliano
Operador de Mutación
Capítulo 1
12
Un algoritmo genético puede presentar diversas variaciones, dependiendo de cómo se
aplican los operadores genéticos (cruzamiento, mutación), de cómo se realiza la selección y
de cómo se decide el reemplazo de los individuos para formar la nueva población. Como se
nuestra en la Figura1.2, el pseudocódigo consiste de los pasos:
Inicialización: Se genera aleatoriamente la población inicial, que está constituida por un
conjunto de cromosomas los cuales representan las posibles soluciones del problema. En
caso de no hacerlo aleatoriamente, es importante garantizar que dentro de la población
inicial, se tenga la diversidad estructural de estas soluciones para tener una
representación “uniforme” del espacio de soluciones.
Evaluación: A cada uno de los cromosomas de esta población se aplicará la función de
aptitud para saber cómo de "buena" es la solución que se está codificando.
Condición de término: El algoritmo debe detenerse cuando se alcance la solución
óptima, pero ésta generalmente se desconoce, por lo que se deben utilizar otros criterios
de parada. Frecuentemente se utilizan dos criterios: número máximo de generaciones o
número máximo de evaluaciones de la función objetivo. Mientras no se cumpla alguna
de estas condiciones de parada se hace lo siguiente:
Selección: Después de saber la aptitud de cada cromosoma se procede a elegir los
cromosomas que serán cruzados en la siguiente generación. Los cromosomas con
mejor aptitud tienen mayor probabilidad de ser seleccionados.
Recombinación o Cruzamiento: La recombinación es el principal operador
genético, representa la reproducción sexual, opera sobre dos cromosomas a la vez
para generar dos descendientes donde se combinan las características de ambos
cromosomas padres.
Mutación: modifica al azar parte del cromosoma de los individuos, y permite
alcanzar zonas del espacio de búsqueda que no estaban cubiertas por los individuos
de la población actual.
Reemplazo: una vez aplicados los operadores genéticos, se seleccionan los mejores
individuos para conformar la población de la generación siguiente
Capítulo 1
13
Figura 1.2 Diagrama funcional de un algoritmo genético.
Proceso de Reproducción
(Selección)
Recombinación por cruzamiento
Mutación
Actualización de los individuos de la próxima
generación y evaluación de la población
Generación aleatoria de la Población Inicial
Evaluación de las cadenas de acuerdo a la
Función Fin de la búsqueda
Criterio de Parada para la Optimización Objetivo
Capítulo 1
14
1.3.2 Evolución Diferencial
Evolución Diferencial (Storn and Price, 1997) es una relativamente sencilla pero potente
técnica de búsqueda estocástica basada en meta-heurísticas poblacionales, fue concebida
para la resolución de problemas de optimización global en el dominio de búsqueda
continua. DE genera descendientes con un mecanismo simple de mutación y un operador
de cruce que realiza una combinación lineal de un número de individuos y un padre para
crear un hijo. Para la selección se realiza una comparación entre padre e hijo, que permite
la sustitución de uno de los padres sólo si el descendiente es mejor o equivalente a su
padre. En general el método cuenta con excelentes propiedades de convergencia (Price et
al., 2005) Tiene aspectos en común con algoritmos evolutivos tradicionales. Sin embargo
no utiliza la codificación binaria como un algoritmo genético simple y no utiliza una
función de probabilidad para auto adaptar sus parámetros como en las estrategias
evolutivas.
Principios de Funcionamiento
El algoritmo asume que las variables del problema a optimizar están codificadas como un
vector de números reales. La longitud de estos vectores (n) es igual al número de variables
del problema, y la población está compuesta de NP (Número de padres) vectores. Se define
un vector
, en donde p es el índice del individuo en la población (p = 1...NP) y g es la
generación correspondiente. Cada vector está a su vez compuesto de las variables del
problema ( )
, en donde m es el índice de la variable en el individuo (m = 1...n). Se
asume que el dominio de las variables del problema está restringido entre valores mínimos
y máximos
, respectivamente.
Evolución Diferencial se compone básicamente de 4 pasos:
Inicialización
Mutación
Recombinación
Selección
Capítulo 1
15
La inicialización se realiza al principio de la ejecución de la búsqueda, y los pasos de
mutación-recombinación-selección se realizan repetidas veces, hasta que una condición de
término sea satisfecha (número de generaciones, tiempo transcurrido, o calidad de solución
alcanzada, entre otras).
Inicialización
La población es inicializada (primera generación) aleatoriamente, considerando los valores
mínimos y máximos de cada variable. Para p = 1...NP, m = 1...n, y rand (0,1) un número
aleatorio en el rango [0,1].
n ( ) (
) (1.1)
Mutación
La mutación consiste en la construcción de NP vectores aleatorios ruidosos (noisy random
vectors), los cuales son creados a partir de tres individuos elegidos al azar, llamados
vectores objetivo ( ). De forma general los vectores aleatorios ruidosos ( ) son
obtenidos como muestra la ecuación (1.2). Con p, a, b y c distintos entre sí, y p=1...NP.
Note que F es un parámetro que controla la amplificación de los diferenciales, y se
encuentra en el rango [0,2].
n
( ) (1.2)
Recombinación
Una vez obtenidos los NP vectores aleatorios ruidosos, la recombinación se efectúa de
manera aleatoria, comparándolos con los vectores originales ( ) obteniendo los
vectores de prueba (trial vectors,
) de la siguiente manera:
{n
i ( )
(1.3)
Capítulo 1
16
Para p = 1...NP, m = 1...n. y GR es un parámetro que controla la tasa de recombinación.
Nótese que la comparación se hace variable por variable, por lo que el vector de prueba
será una mezcla de los vectores aleatorios ruidosos y originales.
Selección
Finalmente, la selección se realiza simplemente comparando los vectores de prueba con los
originales, de manera que el vector de la generación siguiente será aquel que tenga el mejor
valor de la función de objetivo (conocida como función de calidad).
1.3.3 Optimización de Enjambre de Partículas
Es una técnica de optimización computacional, estocástica desarrollada por Eberhart y
Kennedy en 1995, la cual se inspira en el comportamiento social de una bandada de pájaros
(Kennedy and Eberhart, 1995, Nápoles et al., 2012) . Partiendo del principio que la
inteligencia no está en los individuos, sino en el colectivo, lo que permite la solución de
problemas de optimización complejos desde un punto de vista distribuido, sin un control
centralizado en un individuo específico. El método cuenta con un conjunto o población de
partículas, las cuales representan diferentes posiciones dentro del espacio de búsqueda y
poseen, además, una velocidad mediante la cual actualizan sus posiciones. Cada posición
dentro del espacio de búsqueda tiene asociado un valor numérico que es cuantificado
mediante la función objetivo, de manera que el óptimo de la función se encuentra en la
posición en la que se toma el valor máximo (o mínimo, dependiendo del caso). Dado que
las partículas tienen la capacidad de “recordar” tanto la mejor posición en la que estuvieron
como la mejor posición hallada por todo el enjambre, se puede usar esta información para
guiar los movimientos de las partículas en la dirección de los óptimos de la función. Por lo
tanto, los enjambres de partículas sobrevuelan el espacio de búsqueda detectando las
regiones más prometedoras.
Capítulo 1
17
Principios de Funcionamiento
Un vector ⃗ que describe la ubicación de la partícula dentro del espacio de soluciones.
El tamaño de este vector depende del número de variables necesarias para resolver el
problema. Cada posición de este vector se denomina dimensión.
Valor objetivo o aptitud (fitness), representa la calidad de la solución representada por
el vector ⃗, obtenido a través del cálculo de la función de evaluación correspondiente al
problema específico.
Un vector ⃗ que representa la velocidad de la partícula. Este vector, al igual que ⃗, se
modifica en cada iteración del algoritmo reflejando así el cambio de dirección que sufre
la partícula dentro del espacio de búsqueda.
Descripción del Método
Los pasos principales del algoritmo genérico PSO serán presentados a continuación. El
paso inicial consiste en: asignar las posiciones iniciales de las partículas ( ) y las
velocidades ( ) correspondientes con una distribución uniforme de números aleatorios.
Seguidamente vector recibirá las mejores soluciones de las posiciones visitadas por las
partículas i y tendrá el conocimiento de la mejor solución encontrada en cualquier
vecindad de la partícula ( ).En el paso encargado de terminar el algoritmo se
realiza una verificación para ver si se cumple alguna de la condiciones de parada como
sería la obtención de una solución lo suficientemente buena, el haber alcanzado una
cantidad determinada de iteraciones o algún otro criterio. El ciclo principal es el encargado
de actualizar las velocidades de todas las partículas y las posiciones de estas, también se
calcula la función de calidad, la mejores posiciones son actualizadas si se encuentra una
mejor solución. Concluido el ciclo principal la mejor solución entre los es asignada a
. En el proceso actualización las partículas ajustan sus posiciones conforme a las
siguientes ecuaciones:
(1.5)
( ) ( ) (1.6)
Capítulo 1
18
El parámetro j denota el j-ésimo elemento del vector, donde , los parámetros
son números aleatorios entre [0,1] y las contantes son constantes positivas
que son llamadas los coeficientes cognitivo y social respectivamente, dependiendo de la
importancia o influencia que se quiera dar al mejor valor de la partícula o al mejor valor de
la bandada. Usualmente toman valores en el rango . El parámetro es llamdo
inercia con . En (Shi and Eberhart, 1998) se propone una actualización al
método con el parámetro inercia definido por la siguiente ecuación (1.7), donde es el
número máximo de iteraciones permitidas y serán definidas por el usuario.
( ) (1.7)
Pseudo-código de Optimización de Enjambre de Partículas
1. Inicialización
a. Inicializar las posiciones de las N partículas tal que
tome un valor aleatorio en el rango [Xmin, Xmax].
b. Inicializar las posiciones de las N partículas tal que
tome un valor aleatorio en el rango [Vmin, Vmax].
c. For i =1,..., m do
d. recibe el min ( )
2. Condición de parada (si se cumple el criterio de parada el resultado que
arrojará el algoritmo será ).
3. For i =1,.., m do
a. Actualizar las velocidades
b. Actualizar las posiciones como las funciones
c. Evaluar la función de aptitud de las partículas i , ( )
d. If ( ( ) ( ) them
4. End For
5. Recibe el min ( )
6. Volver al paso 2
Capítulo 1
19
1.3.4 Optimización de Colonias de Hormigas
El algoritmo ACO después de inicializar la meta-heurística hace un proceso de iteración
sobre tres fases fundamentales: en cada iteración las hormigas construirán un número de
soluciones, las cuales a través de una búsqueda local serán mejoradas (opcional) y por
último las feromonas serán actualizadas.
Construcción de soluciones: La construcción de soluciones administra una colonia de
hormigas que visitan estados adyacentes de un problema considerado. Las hormigas
pueden moverse aplicando una política de decisión estocástica usando la información de
los rastros de feromona y la información heurística. La regla para la selección estocástica
de los componentes de la solución varía en los diferentes algoritmos ACO pero, todos ellos,
están inspirados por el modelo de conducta de las hormigas reales. De esta forma, las
hormigas construyen incrementalmente una solución al problema.
Aplicar búsqueda local: Una vez que se han construido las soluciones, y antes de poner al
día las feromonas, es común mejorar las soluciones obtenidas por las hormigas a través de
una búsqueda local. Esta fase es muy específica del problema a resolver y aunque es
optativa normalmente es incluido en los algoritmos de ACO innovadores.
Actualización de la feromona: La actualización de la feromona es el proceso mediante el
cual los rastros de feromona son modificados. El valor del rastro puede incrementarse
debido a que las hormigas depositan feromona en cada uno de los componentes o
conexiones que usan para moverse de un nodo a otro del problema. Y el valor del rastro
también se puede reducir por medio de la simulación de la evaporación de feromona, lo que
evita una convergencia prematura del algoritmo.
Capítulo 1
20
1.3.4 Optimización de Mallas Variables
Optimización de Mallas Variables (Puris, 2009, Navarro et al., 2009) es una meta-
heurística poblacional con características evolutivas donde un conjunto de nodos que
representan soluciones potenciales a un problema de optimización, forman una malla
(población) que dinámicamente crece y se desplaza por el espacio de búsqueda
(evoluciona). Para ello, se realiza un proceso de expansión, donde se generan nuevos nodos
en dirección a los extremos locales (nodos de la malla con mejor calidad en distintas
vecindades) y el extremo global (nodo obtenido de mejor calidad en todo el proceso
desarrollado); así como a partir de los nodos fronteras de la malla. Luego se realiza un
proceso de contracción de la malla, donde los mejores nodos resultantes en cada iteración
son seleccionados como malla inicial para la iteración siguiente.
Descripción general de la meta-heurística
La esencia del método VMO es crear una malla de puntos en el espacio m dimensional,
donde se realiza el proceso de optimización de una función ( ); la cual se
mueve mediante un proceso de expansión hacia otras regiones del espacio de búsqueda.
Dicha malla se hace más “fina” en aquellas zonas que parecen ser más promisorias. Es
dinámica en el sentido que la malla cambia su tamaño (cantidad de nodos) y configuración
durante el proceso de búsqueda. Los nodos se representan como vectores de la forma
( ).
El proceso de generación de nodos en cada ciclo comprende los pasos siguientes:
Generación de la malla inicial.
Generación de nodos en dirección a los extremos locales (nl).
Generación de nodos en dirección al extremo global (ng).
Generación de nodos a partir de las fronteras de la malla (nf).
El método incluye los parámetros:
Cantidad de nodos de la malla inicial (Ni).
Cantidad máxima de nodos de la malla en cada ciclo (N), donde 3∙Ni ≤ N.
Capítulo 1
21
Tamaño de la vecindad (k).
Condición de parada (M).
Generación de la malla inicial en cada iteración: la malla inicial consta de Ni nodos, los
cuales en la primera iteración son generados de forma aleatoria o por otro método que
garantice obtener soluciones diversas. En las restantes iteraciones del método se realiza un
proceso de contracción de la malla, que se basa en una selección de los nodos con mejor
calidad entre los nodos (N nodos) existentes al final de cada iteración.
Generación de nodos en dirección a los extremos locales: En esta etapa se realiza una
exploración en las vecindades de cada uno de los nodos de la malla inicial. Para esto, se
buscan los vecinos más cercanos de cada nodo n a través de una función de distancia o
semejanza (ej. Distancia Euclidiana). Luego, se selecciona cuál de los vecinos tiene mejor
calidad (evaluación de la función FO) que el nodo actual (denotándose ese mejor nodo por
nl). Si ninguno de los vecinos es mejor, entonces este se considera un extremo local y no se
generan nodos a partir de él en este paso. En otro caso, se genera un nodo (n*) que estará
situado entre el nodo (n) y el extremo local (nl). Los valores de las componentes del nuevo
nodo se calculan usando la ecuación:
( ) ( ( ) ( ) ) (1.8)
En esta ecuación, i representa el i-ésimo componente de cada nodo. La cercanía del nuevo
nodo al actual o al extremo local, depende de un factor (r) calculado en base a los valores
que alcanza la función FO en cada uno de los nodos involucrados. Mientras mayor sea la
diferencia entre los valores de la función FO en los nodos involucrados, mayor será la
cercanía o semejanza de n* a nl, esto lo garantiza el factor r.
Generación de nodos en dirección hacia el extremo global: En este caso se realiza una
exploración global hacia el nodo que mejor calidad ha tenido hasta el momento (extremo
Capítulo 1
22
global, ng). Con este fin se generan nuevos nodos a partir de cada nodo de la malla inicial
en dirección a este, utilizando la ecuación:
( ) ( ( ) ( ) ) (1.9)
Generación de nodos a partir de los nodos más externos de la malla: Este proceso de
generación de nuevos nodos tiene lugar con el objetivo de explorar el espacio de búsqueda
en dirección a las fronteras de cada dimensión. Para ello, se seleccionan los nodos cuyas
posiciones se encuentran en los extremos de la malla inicial (nodos fronteras). El proceso
de detección de este tipo de nodo (nf) se realiza siguiendo algún criterio en dependencia del
espacio solución. La generación de los nuevos nodos se obtiene a través de la ecuación.
( ) ( ( ) ) (1.10)
Donde w se conoce como desplazamiento y tiene como objetivo desplazar los nodos
fronteras en dirección a los puntos más y menos externos del espacio de soluciones
(depende de la definición de las fronteras del problema). Nótese que en este paso se
seleccionan tantos nodos externos como sean necesarios para completar el tamaño de la
malla en el ciclo; en principio, se debe tener (N > 3*Ni) para garantizar que se generen
algunos nodos en este paso.
Diversidad: VMO presenta un mecanismo para fomentar la diversidad, que se basa en
mantener una cierta separabilidad entre cada nodo de la malla inicial. Para ello, se propone
un operador de limpieza adaptativo, que funciona de la siguiente manera: Se ordenan todos
los nodos seleccionados como malla inicial en función de su calidad. De forma secuencial,
se compara cada nodo de la malla con sus sucesores, eliminando aquellos cuya distancia
espacial sea menor que una cota calculada dinámicamente. Este valor de la distancia debe
permitir que el proceso sea decreciente; de manera que se obtenga mayor separabilidad
entre los nodos al inicio que al final de la ejecución del método. El valor adaptativo de la
cota de distancia (cd) le permite al método comenzar con exploraciones más generales y
Capítulo 1
23
luego ir disminuyendo su influencia hasta centrarse en una zona más pequeña del espacio
de búsqueda.
Algoritmo VMO
1. Generación de la malla inicial (Ni) de forma aleatoria.
2. Evaluar los nodos de la malla inicial, seleccionar el mejor ng.
3. Repetir:
Para cada nodo en la malla inicial del ciclo hacer
Encontrar sus k nodos más cercanos.
Determinar el mejor de los vecinos ne.
Si ne es mejor que el nodo actual, entonces
Generar nuevo nodo usando ecuación (1.8).
Fin Si
Fin Para
Para cada nodo en la malla inicial del ciclo hacer
Generar un nuevo nodo usando la ecuación (1.9).
Fin Para
Seleccionar los nodos más externos de la malla.
Generar nuevo nodo usando la ecuación (1.10).
Mientras los N nodos de la malla en el ciclo no se hayan generado
Generar nuevo nodo aleatoriamente.
Construir la malla inicial actual de manera elitista.
Ordenar los nodos de la malla inicial según su calidad.
Aplicar operador de limpieza adaptativo.
4. Hasta M evaluaciones
1.4 Conclusiones parciales
Resulta satisfactorio el aporte científico, económico y en ocasiones social que ofrece el uso
de enfoques aproximados para resolver problemas de optimización. En este sentido los
algoritmos meta-heurísticos han jugado un papel fundamental ya que son capaces de
estimar buenas soluciones, en un tiempo de ejecución razonable. De esta forma es posible
obtener modelos que mejoran la eficiencia y calidad de soluciones propiciando la
Capítulo 1
24
optimización de recursos. Sin embargo, debido a la gran variedad de enfoques y mejoras
existentes reportadas en la literatura, resulta de gran utilidad un ambiente de trabajo que
agrupe los principales algoritmos meta-heurísticos, facilitando la interacción por
especialistas no expertos en ciencias matemáticas o computacionales. Sin embargo, las
bibliotecas existentes son pocas o están desactualizadas. Además, la incorporación de un
nuevo algoritmo a los paquetes existentes es frecuentemente un reto.
25
Capítulo 2 METODOLOGÍA PARA LA INCORPORACIÓN DE ALGORITMOS A LA PLATAFORMA DE OPTIMIZACIÓN ECJ
2.1 ¿Qué es ECJ y cómo funciona?
ECJ (Evolutionary Computation and Genetic Programming Research System) (Luke) es
una herramienta para el desarrollo de aplicaciones de computación evolutiva y
programación genética implementado en Java por el Laboratorio de Computación
Evolutiva ECLab de la universidad George Mason de Estados Unidos, la cual se ofrece
bajo una licencia especial de código abierto. El sistema fue diseñado para complejas
necesidades experimentales y ofrece herramientas que proporcionan muchos de los
algoritmos populares de la computación evolutiva, pero con un énfasis especial hacia la
programación genética. Esta biblioteca afortunadamente ha mostrado pocos fallos en los
últimos años. Su diseño ha acomodado fácilmente muchas adiciones posteriores,
incluyendo algoritmos de optimización multiobjetivo, modelos de isla, propiedades de
evaluación maestro/esclavo, coevolución, métodos estratégicos evolutivos, steady-state y
varios tipo de representaciones individuales (por ejemplo, rule-sets). Algunas de las
características más significativas de esta herramienta son:
Ciclo central. El estado completo de una «corrida evolutiva» es manejado en una instancia
única de una subclase de EvolutionState. Esto permite a ECJ serializar el estado completo
del sistema a un archivo de control (checkpoint) y restablecerse a partir del mismo. Esta
subclase debe definir el ciclo evolutivo a usar en el sistema, que a su vez puede ser:
o Ciclo simple generacional, con elitismo opcional.
o Ciclo de estado de equilibrio (steady-state)
La Figura 2.1 muestra el bucle de nivel superior de la EvolutionState generacional simple.
El bucle itera entre reproducción y evaluación, con la opción de "cambio" (exchange)
después de cada período. Luego las estadísticas son computadas antes y después de cada
período de reproducción, evaluación e intercambio, así como antes y después de la
Capítulo 2
26
inicialización de la población y "acabado" (finishing), limpiar antes de abandonar el
programa). La reproducción y la evaluación son manejadas por objetos únicos individuales:
Breeder y Evaluator. Asimismo, de la inicialización se encarga un Initializer y de la
terminación un Finisher, objetos únicos respectivamente. Los intercambios después de la
reproducción y previa evaluación están a cargo de un intercambiador. Las versiones
específicas de estos objetos únicos están determinadas por el experimentador, aunque nos
proporcionan versiones que realizan tareas comunes.
Fig.2.1 Ciclo principal de la clase SimpleEvolutionState.
Capítulo 2
27
Construcción parametrizada. La biblioteca ECJ es fuertemente parametrizado,
prácticamente todas las características del sistema se determinan en tiempo de ejecución a
partir de un parámetro determinado. Los parámetros definen la clase de los objetos, los sub-
objetos específicos que poseen, y todos sus valores iniciales de tiempo de ejecución.
Durante el proceso de ejecución ECJ es configurado a través de la clase Evolve esta es la
encargada de crear un objeto de tipo EvolutionState a partir de las configuraciones
especificadas en el archivo de parámetros y de igual manera el proceso continúa hasta que
se configuran todas las clases secundarias que intervienen en el ciclo evolutivo.
Objetos de Estado. Unidos a los objetos que representan “verbos” (Breeder, Evaluator,
Initializer, etc.) ECJ también maneja “sustantivos”, que son los objetos de estado que
representan las cosas que están evolucionando. EvolutionState mantiene exactamente un
objeto Population, que a su vez contiene entre 1 y N (típicamente 1) objetos
Subpopulations. Varias Subpopulations permiten experimentar en coevolución, modelos
de islas internas, etc. Cada Subpopulation mantiene algún número de objetos Individuals y
los objetos Species a los cuales estos individuos pertenecen. Los objetos Species son
objetos estáticos ya que no necesitan ser mantenidos en cada una de sus instancias (Figura
2.3).
Capítulo 2
28
Fig.2.3 Objetos usados en la evolución
Como ECJ solo adquiere las clases específicas de estos objetos a partir del archivo de
parámetros, definido por el usuario en tiempo de ejecución, estos no pueden ser construidos
mediante el operador new de Java. En su lugar, estos objetos serán creados por la
definición de un objeto prototipo (prototype) al comienzo y luego usando este objeto se
imprimirán copias del mismo hasta que sea necesario. Por ejemplo, la clase Species
contiene un prototipo Individual y cuando deben ser creados nuevos objetos de este tipo
para una Subpopulation específica, entonces estos son copiados y luego personalizados.
Esto permite que diferentes objetos de tipo Subpopulation usen diferentes representaciones
de la clase Individual.
Reproducción. Un objeto Species mantiene una tubería de reproducción prototipo que es
clonada por el objeto Breeder y usada por cada hilo para reproducir individuos y formar la
población de la próxima generación. Las tuberías de reproducción son estructuras en forma
Capítulo 2
29
de árbol, donde un nodo de este árbol filtra los individuos entrantes de sus nodos hijos y los
envía a su padre. Los nodos hojas en el árbol son SelectionMethods; estos simplemente
toman individuos de la antigua subpoblación y los pasa para arriba. Existen algunos que
realizan selección por torneo, selección por calidad proporcional, selección por
truncamiento, etc.
Los nodos que no son hojas en el árbol son BreedingPipelines, muchos de los cuales
copian y modifican los individuos que reciben antes de pasarlos a los nodos padres.
Algunos BreedingPipelines son independientes de la representación: por ejemplo,
MultiBreedingPipeline pregunta por individuos de uno de sus hijos de manera aleatoria de
acuerdo con alguna distribución de probabilidad. Aunque la mayoría de los
BreedingPipelines realizan tareas de mutación y cruzamiento dependientes de la forma de
representación. Por ejemplo, GP CrossoverPipeline pregunta por un individuo de cada uno
de sus dos hijos, que deben ser individuos desde el punto de vista de la programación
genética, realiza un cruzamiento de subárboles en estos individuos y luego los pasan a sus
padres.
Una tubería de reproducción basada en una estructura en forma de árbol permite una
amplia variedad de formas de selección y reproducción definidas por el experimentador.
Las tuberías de ECJ son copy-forward: BreedingPipelines debe asegurarse de copiar los
individuos antes de modificarlos o pasarlos adelante, si estos no han sido previamente
copiados. Esto garantiza que los nuevos individuos sean en realidad copias de los más
antiguos de la población y por tanto, permite que múltiples tuberías puedan operar sobre
una misma Subpopulation en diferentes hebras sin la necesidad de bloquear su uso. La
biblioteca ECJ puede usar varios hilos para paralelizar el proceso de reproducción sin el
uso de la sincronización propia de Java.
Evaluación. El objeto Evaluator realiza la evaluación de una población pasando uno o
varios (para evaluación coevolutiva) individuos a una subclase de Problem, la que el
evaluador ha clonado de su prototipo. La evaluación también puede ser realizada en modo
multihilo sin el empleo de bloqueo, usando un Problem por hebra. Los individuos pueden
Capítulo 2
30
también experimentar repetidas evaluaciones en evaluadores coevolutivos de diferentes
tipos. En la mayoría de los proyectos que usan ECJ, la tarea inicial es construir la subclase
apropiada de Problem. La función de Problem es evaluar la calidad del individuo o
individuos y asignar su fitness consecuentemente. Las clases Problem además reportan si el
individuo ideal ha sido encontrado.
2.1.1 Parámetros y Fichero de Parámetros
Números: tanto enteros como valores de punto flotante con precisión doble, por
ejemplo:
generations = 500
tournament.size = 3.25
minimum-fitness = -23.45e15
Cadenas de Caracteres: no deben tener espacios en blanco. Por ejemplo:
crossover-type = two-point
Booleanos: cualquier valor, excepto “false” (sin importar mayúscula o minúscula) es
considerado “verdadero”. Es mejor utilizar “true” y “false” en minúscula:
print-params = false
quit-on-run-complete = True
Nombre de ruta de un archivo: las rutas pueden ser de tres tipos: Rutas absolutas, las
cuales (en Unix) empiezan con “/”, estipulan una localización concreta en el sistema de
archivos. Rutas relativas, que no empiezan con “/”, están definidas en relación al
archivo de parámetro en el cual el parámetro estaba localizado. Finalmente, las rutas
relativas a la ejecución están definidas con respecto al directorio en el cual el proceso
ECJ fue lanzado. Estas rutas son como las rutas relativas, excepto que empiezan con el
carácter especial “$”. Ejemplos de los tres tipos de rutas son:
stat.file = $out.stat
Capítulo 2
31
eval.prob.map-file = ../dungeon.map
temporary-output-file = /tmp/output.txt
Nombre de las clases: los nombres de clase se definen como el nombre de la clase
completo, incluyendo el paquete. Ejemplo:
pop.subpop.0.species = ec.gp.GPSpecies
Arreglos: ECJ no tiene soporte directo para carga de arreglos, pero tiene un
convencionalismo que se debería tener en cuenta. Es común para los arreglos cargar
primero el número de elementos y después cada elemento por turno, empezando por
cero. El parámetro usado para el número de elementos difiere en cada caso. Nótese el
uso de puntos antes de cada número en el siguiente ejemplo:
gp.fs.0.size = 3
gp.fs.0.func.0 = ec.app.ant.func.Left
gp.fs.0.func.1 = ec.app.ant.func.Right
gp.fs.0.func.2 = ec.app.ant.func.Move
El fichero de parámetros es empleado para configurar los distintos aspectos de la
evolución. Este fichero se encarga tanto de las clases que se utilizarán, como de la
estructura de los árboles del lenguaje de los programas y de muchos otros parámetros de
configuración de las clases que intervienen en el proceso de evolución. Este fichero de
parámetros se llamará “params” o terminará con la extensión “.params”.
Dado que numerosos objetos leen los parámetros desde la base de datos, ECJ organiza su
espacio de nombres de parámetros de forma jerárquica usando puntos para separar
elementos en los nombres de los parámetros. Empecemos con la situación más simple,
algunos parámetros de ECJ son simples parámetros globales. Por ejemplo:
evalthreads = 3
Este parámetro indica que se deben generar tres hilos cuando se haga la evaluación de la
población. Otros parámetros son organizados jerárquicamente porque es la manera más
Capítulo 2
32
fácil de hacerlo. Por ejemplo, si evalthreads y breedthreads (número de hilos en el proceso
de reproducción) son ambos 3, entonces hay 3 semillas de generadores de números
aleatorios y deben ser definidos de la siguiente manera:
seed.0 = 2341
seed.1 = 8274654
seed.2 = 523
El punto es usado para otros propósitos jerárquicos. Cuando un objeto contiene otros
objetos como subordinados, estos quedan dentro de su jerarquía. Tales objetos tienen un
parámetro base que usan de prefijo. Por ejemplo, la instancia global Population contiene
un arreglo de instancias Subpopulation y ambas instancias contienen a su vez una gran
variedad de objetos. La instancia Population se define de la siguiente manera: es fijado el
número de subpoblaciones que contiene, las clases de sus diferentes subpoblaciones y el
número de individuos que tiene cada una de ellas. A manera de ejemplo el siguiente
ejemplo define una población conformada por dos subpoblaciones, cada una con 500
individuos:
pop = ec.Population
pop.subpops = 2
pop.subpop.0 = ec.Subpopulation
pop.subpop.0.size = 500
pop.subpop.1 = ec.Subpopulation
pop.subpop.1.size = 500
Si un objeto necesita un parámetro dado y el parámetro no existe en la base proporcionada,
entonces el objeto puede comprobar si existe en una base por defecto. Por ejemplo,
digamos que el pipeline de reproducción número 0 de las especies para la subpoblación
número 1 de la población es una MutationPipeline (mutación de punto en la programación
genética) y está usando la selección por torneo como su fuente número cero para la
selección de individuos. Esto se puede declarar de esta manera:
Capítulo 2
33
pop.subpop.1.species.pipe.0 = ec.gp.koza.MutationPipeline
pop.subpop.1.species.pipe.0.source.0=ec.select.TournamentSele
ction
En este caso el parámetro base jerárquica es pop.subpop.1.species.pipe.0.source.0 y la base
por defecto para la selección por torneo es select.tournament. Si el objeto busca en los dos
lugares y si no encuentra un parámetro definido (o no está correctamente definido),
entonces generará un error. Algunos objetos globales no tienen bases de parámetros por
defecto, pero la mayoría de los objetos que pueden ser repetidamente declarados en
diferentes sitios dispondrán de esta característica.
ECJ utiliza una estructura jerárquica de ficheros de configuración, de tal forma que si
queremos utilizar, por ejemplo, la biblioteca Koza para la programación genética,
simplemente tendremos que heredar del fichero de configuración de Koza y definir ciertas
propiedades específicas de nuestro problema. Esto lo podemos realizar mediante la
siguiente línea:
parent.0 = ./../gp/koza/koza.params
Esta línea nos especifica que ../../gp/koza/koza.params será el primer padre del fichero de
parámetros. Esto indica que, si el parámetro no está especificado en el fichero de
parámetros, entonces ECJ seguirá buscando en la ruta ../../gp/koza/koza.params para
encontrarlo. Esta herramienta cuenta con una jerarquía de parámetros, cuando un parámetro
es solicitado se busca en el siguiente orden:
1. Busca si se creó dinámicamente por el sistema en algún punto llamando al método set
en ec.util.ParameterDatabase.
2. Busca si el usuario especificó el parámetro en la línea de comandos.
3. Busca en la raíz del fichero de parámetros que fue especificada en la línea de
comandos con la opción –file.
4. Busca a través de los ficheros de parámetros padres especificados con la declaración
parent.x, empezando con aquellos declarados en la raíz. La Figura.2.4 muestra un
ejemplo. Se lee de abajo a arriba y de izquierda a derecha. La regla es: un fichero de
Capítulo 2
34
parámetros es comprobado antes que su fichero de parámetros padre parent.x y sus
padres son comprobados antes de parent.x+1 y sus padres. Donde cero es el valor
permitido más pequeño de x.
Figura.2.4 Jerarquía de parámetros en ECJ
La mayoría de paquetes de ECJ disponen de un fichero de parámetros que prepara algunos
parámetros por defecto para ayudarle a empezar, de manera que no tenga que escribirlo
usted mismo. El fichero ./../simple/simple.params, en particular, prepara la configuración
de parámetros comunes.
state = ec.simple.SimpleEvolutionState
init = ec.simple.SimpleInitializer
finish = ec.simple.SimpleFinisher
exch = ec.simple.SimpleExchanger
breed = ec.simple.SimpleBreeder
eval = ec.simple.SimpleEvaluator
stat = ec.simple.SimpleStatistics
Capítulo 2
35
generations = 51
quit-on-run-complete = true
pop = ec.Population
pop.subpops = 1
pop.subpop.0 = ec.Subpopulation
pop.subpop.0.size = 1024
pop.subpop.0.duplicate-retries =0
stat.file = $out.stat
Estos parámetros especifican un procedimiento evolutivo generacional estándar, con un
objeto estadístico muy básico, una única subpoblación de mil veinticuatro individuos,
cincuenta y una generaciones y un objeto de calidad simple, de un solo objetivo. El objeto
encargado de las estadísticas guarda los datos en el archivo out.stat, localizado en el
directorio donde emitimos nuestro comando (para eso utilizamos el símbolo $. Sin él,
estaría situado en el mismo directorio donde encontramos simple.params).
Si cualquiera de los parámetros descritos en simple.params fuera inapropiado para nuestro
algoritmo podríamos anularlos volviendo a declararlos en nuestro fichero de parámetros.
Si, por ejemplo, quisiéramos un número diferente de generaciones de las descritas en
simple.params, sólo tendríamos que volver a declararla en nuestro fichero de parámetros:
generations = 500
simple.params a su vez dispone de un padre: ec.params, localizado en el directorio
ec.ec.params y que especifica la siguiente configuración de parámetros por defecto:
evalthreads = 1
breedthreads = 1
seed.0 = time
checkpoint = false
checkpoint-modulo = 1
prefix = ec
También es posible utilizar la declaración de los parámetros ofrecida por ECJ mediante
parents.x. Por tanto, si se utilizan estos parámetros se debe especificar la parte de los
Capítulo 2
36
parámetros que se anulará, la representación de la población, el dominio del problema y la
BreedingPipelines (mecanismo de reproducción ofrecido por ECJ).
2.1.2 Proceso Evolutivo
El propósito de la clase ec.Evolve es simplemente establecer un ec.EvolutionState,
configurarla y ponerla en marcha El sistema evolutivo completo está contenido en el objeto
EvolutionState o en algún subobjeto suyo. Un proceso en ECJ tiene solamente una
instancia ec.EvolutionState, prácticamente todo en ECJ, excepto ec.Evolve, está enfocado
hacia algún ec.EvolutionState, varias subclases de ec.EvolutionState definen procesos de
optimización estocástico. Una gran cantidad de métodos están contenidos en una instancia
ec.EvolutionState y por lo tanto tienen acceso global al sistema.
El objeto EvolutionState almacena muchos parámetros globales evolutivos de alto nivel y
varios objetos importantes, lo cual define el mecanismo general de evolución.
Algunos de los objetos de alto nivel dentro de EvolutionState son:
Una subclase de la clase ec.Initializer, responsable de crear la población inicial.
Una ec.Population, creada inicialmente por Initializer. Una población almacena un
arreglo de objetos ec.Subpopulations. Cada subpoblación almacena un arreglo de
objetos ec.Individuals, más un ec.Species, el cual especifica como los individuos deben
ser creados y manejados por el optimizador.
Una subclase de la clase ec.Evaluator, responsable de evaluar individuos.
Una subclase de la clase ec.Exchanger, responsable del intercambio de individuos
entre las subpoblaciones o entre los diferentes procesos.
Una subclase de la clase ec.Finisher, responsable de limpiar cuando el sistema está a
punto de finalizar.
Una subclase de la clase ec.Statistics, responsable de imprimir (mostrar en pantalla) las
estadísticas durante la ejecución.
Capítulo 2
37
Un ec.util.ParameterDatabase. La base de datos de parámetros almacena todos los
parámetros cargados desde nuestro fichero de parámetros “params” y otros ficheros de
parámetros, y es usado para ayudar al sistema a que se auto configure.
Figura.2.5 Funcionamiento general de EvolutionEstate.
2.1.3 Objeto SimpleEvolutionState
El paquete SimpleEvolutionState define muchos aspectos de la evolución básica
generacional, y podemos utilizarlo para la mayoría de nuestros propósitos. Vamos a
empezar usando su subclase EvolutionState, ec.simple.SimpleEvolutionState.
Lo hacemos definiendo un parámetro final que Evolve usa para configurar el material:
state = ec.simple.SimpleEvolutionState
SimpleEvolutionState define un procedimiento evolutivo simple, generacional no
coevolutivo. El procedimiento es el siguiente:
1. Llama al Initializer para crear una población.
2. Llama a Evaluator en la población, reemplazando la población antigua con el resultado.
3. Si Evaluator encuentra un individuo ideal, y hemos configurado para que se finalice
cuando lo encuentre, vamos al paso número 9
4. Si nos hemos quedado sin generaciones, también vamos al paso 9
Initializer
Evaluator. evaluate Population
Finisher
Breeder. breedPopulation
Exchanger
Capítulo 2
38
5. Llama a Exchanger en la población (pidiendo un intercambio post-reproducción),
reemplazando la población antigua por el resultado
6. Llama a Breeder en la población, reemplazando la antigua por el resultado.
7. Llama a Exchanger en la población (pidiendo un intercambio post-reproducción),
reemplazando la antigua por el resultado.
8. Incrementa la cuenta de la generación y vuelve al paso 2.
9. Llama a Finisher de la población y finaliza la ejecución.
SimpleEvolutionState puede funcionar con una gran variedad de Initializers, Evaluators,
Breeders, Exchangers, Finishers y Populations. Pero si queremos hacerlo de una manera
simple, podemos usar los básicos. Algunos parámetros que harán que
SimpleEvolutionState cargue estas clases son los siguientes:
pop = ec.Population
init = ec.simple.SimpleInitializer
finish = ec.simple.SimpleFinisher
breed = ec.simple.SimpleBreeder
eval = ec.simple.SimpleEvaluator
stat = ec.simple.SimpleStatistics
exch = ec.simple.SimpleExchanger
SimpleInitializer crea una población mediante la carga de una instancia (en este caso
ec.Population) y le dice que se pueble aleatoriamente, Populations también puede cargar
su población de archivos. SimpleEvaluator evalúa cada individuo en la población
independientemente, SimpleStatistics reporta información estadística básica en función de
cada generación y tanto SimpleExchanger como SimpleFinisher no hacen nada.
Adicionalmente, hay algunos otros parámetros que SimpleEvolutionState necesita:
Generations es el número de generaciones a ejecutar.
Quit-on-run-complete nos dice si debemos o no finalizar ECJ cuando encuentre al
individuo ideal; si no, ECJ continuará ejecutándose hasta que se quede sin
generaciones.
Checkpoint le dice a ECJ que debe hacer un checkpointing (puntos de control) en cada
generación checkpoint-modulo, usando un archivo checkpoint Gzipped.
Capítulo 2
39
Prefix nos indica el prefijo por el que debe empezar el archivo checkpoint Gzipped.
Checkpoint-modulo nos dice cada cuántas generaciones se haría el checkpoint.
Si se realiza un chekpointing entonces se guarda el estado del proceso evolutivo en un
archivo; se puede por tanto recuperar la ejecución desde ese punto, lanzando ECJ desde ese
archivo. Si se espera que la ejecución sea larga o existe la posibilidad de que el sistema se
apague accidentalmente (fallo de electricidad por ejemplo), es aconsejable utilizar la
funcionalidad checkpoint. De otra manera, no es recomendable por su alto costo
computacional.
2.1.4 Objeto SimpleStatistics
Una gran cantidad de objetos en ECJ tienen bases de parámetros. La base de parámetros es
pasada al objeto cuando es creado y es prefijada a sus nombres de parámetro. De esa
manera, por ejemplo, se podría posiblemente crear dos objetos Statistics diferentes,
pasarles diferentes bases y podrían ser capaces de cargar diferentes parámetros. Algunos
objetos de ECJ también tienen una base por defecto, esta base define un parámetro
secundario de ubicación en la que el objeto debe buscar en caso de que no encuentre un
parámetro que necesite y no esté en su base de parámetros estándar. Esto permite a algunos
objetos usar la misma base de parámetros por defecto.
SimpleStatistics no tiene una base por defecto. Es un objeto de alto nivel por lo tanto no
necesita una. La base para nuestro objeto SimpleStatistics es stat. Usualmente las bases
para objetos corresponden con el nombre del parámetro que especificó que clase se
suponen que son. Para SimpleStatistics, por ejemplo, el parámetro que especifica la clase
es:
stat = ec.simple.SimpleStatistics
Por tanto stat es la base y como SimpleStatistics necesita un archivo donde escribir, el
nombre del archivo de salida se encuentra en stat.file. Si no hay archivo especificado,
SimpleStatistics mostrará las estadísticas visualmente.
Capítulo 2
40
2.1.5 La Clase Population y algunas de sus subclases
Poblaciones, subpoblaciones e individuos son los sustantivos en los sistemas evolutivos y
la aptitud sus adjetivos. Ellos son el centro de las operaciones de cualquier algoritmo de
búsqueda evolucionario o basado en una muestra estocástica.
En ECJ un individuo es un candidato para ser solución del problema. Algunos individuos
M son agrupados juntos dentro de una muestra de solución conocido como subpoblación.
Algunas subpoblaciones N son agrupadas juntas dentro del sistema, esto se conoce como
Población. Solo existe una sola población por procesos evolutivos. El escenario más común
para ECJ es tener M individuos agrupados dentro de una simple subpoblación la cual
entonces es un único miembro de la población de ECJ. Sin embargo los algoritmos
coevolucionarios (típicamente tienen N>1 subpoblaciones, como hacer un pequeño y
especial uso interno del esquema modelo de nicho).
Usualmente la población de ECJ es una instancia de la clase ec.Population y sus
subpoblaciones son instancias de la clase ec.Subpopulation, además ambas son grupos.
Digamos que tenemos una simple subpoblación la cual debe contener 100 individuos, esto
lo podemos expresar como sigue:
Pop = ec.Population
pop.subpops = 1
pop.subpop.0 = ec.Subpopulation
pop.subpop.0.size =100
Una población está conformada por un arreglo de subpoblaciones y a su vez estos están
formados por arreglos de Individuos. Además para un arreglo de individuos cada
subpoblación contiene especies la cual define a los individuos empleados para completar la
subpoblación así como su aptitud y la forma mediante la cual ellos son modificados. Las
subpoblaciones también contienen algunos parámetros básicos para la creación de
individuos iniciales, aunque el procedimiento es en gran parte manejado por las especies.
Los individuos están relacionados con especies comunes. Ellos usan las especies para
Capítulo 2
41
almacenar una gran cantidad de información común (por ejemplo cómo modificarse ellos
mismo). Ordinariamente se podría pensar que las subpoblaciones podrían ser un buen lugar
de almacenamiento, sin embargo diferentes subpoblaciones pueden compartir las mismas
especies esto permite, por ejemplo, tener una guía de especies en toda la ejecución de la
evolución la cual podría tener 20 subpoblaciones en ella, las especies de las subpoblación
pueden encontrarse así:
Species theSpecies = state.population.subpops[0].species;
Las especies contienen 3 elementos importantes:
Prototipo individuo
Prototipo aptitud
Prototipo BreedingPipeline
2.1.6 Procedimiento de Breeding en ECJ
La biblioteca ECJ posee un mecanismo de reproducción bastante flexible llamado
BreedingPipeline. Realmente no es una tubería propiamente dicha: en realidad es un árbol.
Las hojas del árbol son métodos de selección, responsables de escoger a los individuos de
la población antigua. Los nodos del árbol no pertenecientes a la hoja son los operadores de
reproducción, los cuales cogen los individuos, entregados a ellos por sus nodos hijos, los
reproducen y los envían a sus nodos padre. La raíz del árbol, por tanto, maneja individuos
completamente criados para ser añadidos a la nueva población (ver Figura.2.6).
Capítulo 2
42
Figura.2.6 Estructura de BreedingPipeline
Como operador de mutación es posible usar ec.vector.breed.VectorMutationPipeline. Este
operador solicita individuos de su única fuente de hijos, una vez obtenidos, los muta. La
mutación se realiza con una simple llamada al método de mutación por defecto definido en
los propios individuos. Si quiere utilizar un método de mutación no definido por defecto
(por ejemplo, la mutación por inversión), necesita definir su propia subclase
BreedingPipeline para hacer su método a medida.
De modo similar, es posible usar ec.vector.breed.VectorCrossoverPipeline, como operador
de cruce. Este operador solicita un individuo de cada una de sus dos fuentes de hijos,
entonces los cruza y devuelve ambos al mismo tiempo. Esta pipeline hace el cruce de una
manera muy simple llamando al método de cruce por defecto definido en los propios
individuos. Otra vez, si necesita algún tipo de cruce no definido por defecto, necesitará
definir su propia subclase BreedingPipeline para hacer su cruce especial.
Capítulo 2
43
Hay un número de métodos de selección estándar disponibles en ECJ, todos localizables en
ec.select.package. Algunos de estos son:
Ec.select.FirstSelection: siempre devuelve el primer individuo de la
Ec.select.RandomSelection. Devuelve un individuo seleccionado de forma
uniformemente aleatoria.
Ec.select.BestSelection escoge entre los mejores o peores n individuos de la población,
dependiendo de un parámetro. El procedimiento de selección entre estos n es una
selección proporcional al fitness. Por eso ec.select.BestSelection requiere que todos los
fitness sean números positivos.
Ec.select.GreedyOverselection es una variación que fue común en las primitivas
comunidades de programación genética. Los individuos son clasificados y divididos en
los grupos “filter” y “less fit”. Con una cierta probabilidad los individuos “filter” serán
seleccionados (usando la selección de calidad proporcional), además los individuos
“less fit” serán seleccionados (también usando la selección de calidad proporcional). El
valor de calidad (aptitud) de todo individuo tiene que ser no negativo.
Ec.select.TournamentSelection primero elige N individuos aleatoriamente con
reemplazo (el mismo individuo puede ser escogido más de una vez). Después, de entre
esos N, devuelve el individuo con mayor calidad (o el de menor calidad), rompiendo los
enlaces aleatoriamente. N es a menudo un entero pero, de hecho, no tiene que serlo
obligatoriamente: puede ser cualquier número de valor real mayor que cero. Los
valores de calidad deben ser no negativos. El ajuste más común para N es dos.
2.1.7 Definiendo el Problema
Con este objetivo, es necesario programar el objeto que es responsable de evaluar la
calidad de nuestros individuos. Este objeto es llamado Problem y está especificado como
parámetro en nuestra clase Evaluator. Buscando en la documentación de Problem, se
podrá observar que son definidos algunos métodos valiosos. Primero define un método de
configuración setup, que se puede anular para configurar el problema prototipo desde un
Capítulo 2
44
fichero de parámetros. Nuestro problema será un clon de este problema prototipo. Luego se
define el método clone () que es utilizado para hacer copias (profundas) de Problem.
Contradictoriamente la clase Problem no define ningún método para evaluar individuos.
Sin embargo, existen interfaces especiales que varios evaluadores usan y que deben
implementarse. SimpleEvaluator requiere que su problema implemente la interfaz
ec.simple.SimpleProblemForm. Esta interfaz define dos métodos, evaluate () (requerido) y
describe () (opcional). evaluate () toma un individuo, lo evalúa de alguna manera, mira su
valor de calidad y lo marca como evaluado; describe () toma un individuo e imprime en un
log alguna información de cómo el individuo opera, describe () es llamado cuando la clase
Statistic quiere imprimir información especial acerca del mejor individuo de la generación
o de la ejecución.
2.2 Metodología para incorporar nuevos algoritmos a ECJ
Para incorporar un nuevo algoritmo en ECJ se deben seguir los siguientes pasos:
Paso #1: Crear un nuevo paquete dentro del paquete ec
Paso #2: Crear un archivo nombre.params.
Paso #3: Definir una subclase de BreedingPipeline llamada nombre.java.
Paso #4: Definir una nueva subclase de Problem que implemente la interfaz
SimpleProblemForm con el identificador nombre_problema.java.
A continuación se explicarán cada uno de los pasos anteriormente mencionados:
Paso #1: Crear un nuevo paquete dentro del paquete ec
La primera acción a llevar acabo es crear un paquete con el nombre del algoritmo que se
quiere incluir en la biblioteca y situarlo en el paquete ec, en este nuevo paquete se incluirán
todas las clases necesarias para el funcionamiento del mismo.
Paso #2: Crear un archivo nombre.params.
Capítulo 2
45
En este archivo es donde se definen los parámetros que utilizará el nuevo algoritmo a
incorporar y contendrá además la configuración de los parámetros que se tendrán en cuenta
en la ejecución del framework, tales como:
• Dominio del problema
• Representación de la población
• Número de individuos de la población
• Archivo de codificación del nuevo algoritmo
• Archivo de codificación de la Función Objetivo
Paso #3: Definir una subclase de BreedingPipeline llamada nombre.java.
La clase abstracta BreedingPipeline es el mecanismo de reproducción de ECJ, o sea es el
que proporciona los nuevos individuos que pueden ser utilizados para llenar una nueva
población y por tanto en ella deberá implementarse el nuevo algoritmo, para lo cual es
necesario personalizar los siguientes métodos:
• public void setup (): En este método se configuran los parámetros necesarios
para la nueva clase de tal forma que garantice el funcionamiento del algoritmo
• public void prepareToProduce(params list): Este método es llamado antes de
produce(...) por lo general una vez por generación en él se codifican acciones
previas a la generación de la nueva población.
• public int produce (params list): Es el método más importante porque es donde
se generan los nuevos individuos de la población usando los operadores del
algoritmo.
• public Parameter defaultBase (): Devuelve el archivo de parámetro por defecto
para el nuevo algoritmo, desde el cual el método setup () cargará todas las
configuraciones necesarias.
Además de estos la clase BreedingPipeline cuenta con otros métodos los cuales hacen este
mecanismo bastante flexible y en caso de tener otras necesidades dichos métodos podrán
facilitar las cosas.
Capítulo 2
46
Paso #4: Definir una nueva subclase de Problem que implemente la interfaz
SimpleProblemForm con el identificador nombre_problema.java.
Esta clase no forma parte del algoritmo pero en ella es donde queda reflejado el problema
al que se le quiere aplicar el nuevo algoritmo y no tendría sentido incorporar un nuevo
método sin definir el tipo de problema para el cual sea factible su aplicación.
De igual forma, al ser una subclase de la clase abstracta Problem e implementar
SimpleProblemForm pues también es necesario sobrescribir los siguientes métodos:
• public void setup (): En este método se configuran los parámetros necesarios
para la codificación del problema. Si el problema no requiere parámetros
externos, entonces no se sobrescribe.
• public void evaluate (params list): Este método es el encargado de evaluar el
individuo (no evalúa si ya ha sido evaluado) y establecer su valor de calidad por
tanto debemos de codificar la función objetivo (problema a resolver).
La interfaz SimpleProblemForm también cuenta con otro método describe () encargado de
mostrar datos relevantes de los individuos y registrar los resultados, sin embargo su
implementación es opcional.
2.3 Incorporando la meta-heurística VMO a ECJ
A continuación como parte de la validación, se incluirá la meta-heuristica poblacional
descrita en el epigrafe 1.3.5 (Optimización de Mallas Variables) usando como guía los
pasos descritos en el epígrafe 2.2.
Creación del paquete
Primeramente se crea el paquete con el nombre vmo y se sitúa en el paquete ec. Se añade a
este paquete porque este es al paquete principal de ECJ. El paquete estará conformado por
cinco clases y un archivo de parámetros, seguidamente se realizará una desripción de las
clases que no son abordadas en los pasos posteriores pero que son necesarias para el
funcinamiento del algoritmo:
Capítulo 2
47
Se crearon dos nuevas subclases, heredando respectivamente de SimpleEvolutionState
(CheckEvalEvolutionState) y SimpleEvaluator (CheckEvalEvaluator) las cuales son
imprescidibles ya que estas clases adaptan el funcionamiento del EvolutionState y el
Evaluator para que la condición de parada sea con respecto al número de evaluaciones.
También se creó una clase denominada EmptySorce, que no es más que una subclase de
BreedingSource que no produce individuos, sin embargo es necesaria para que la tubería
funcione y por último está la clase VMOUtils en la que están implementados gran parte de
los métodos utilizados por la clase VMOPipeline.
Creación del archivo de parámetros
Se creará un archivo de parámetros con el nombre vmo.params, no necesariamente debe
llamarse así, pero por cuestiones de organización se quiere que lleve el mismo nombre del
paquete. Como se muestra en el epígrafe 2.1.1 el fichero de parámetros es el encargado de
ajustar los distintos aspectos de la evolución, incluyendo las especificaciones del algoritmo
(VMO). Algunas de las configuraciones de vmo.params son:
GENERAL CONFIGURATIONS
state = ec.vmo.CheckEvalEvolutionState
init = ec.simple.SimpleInitializer
finish = ec.simple.SimpleFinisher
exch = ec.simple.SimpleExchanger
breed = ec.simple.SimpleBreeder
eval = ec.vmo.CheckEvalEvaluator
stat = ec.simple.SimpleStatistics
VMO CONFIGURATIONS
evaluations = 300000
pop.subpop.0.species.pipe = ec.vmo.VMOPipeline
pop.subpop.0.species.pipe.source.0 = ec.vmo.EmptySource
pop.subpop.0.species.pipe.neighborhood-size = 3
pop.subpop.0.species.pipe.expansion-size = 75
pop.subpop.0 = ec.Subpopulation
pop.subpop.0.size = 50
Capítulo 2
48
Definiendo la subclase de BreedingPipeline
Sin dudas este es el paso más importante ya que con la creación de la subclase de
BreedingPipeline que en nuestro caso tendrá el nombre de VMOPipeline, pues ya quedará
implementado el nuevo algoritmo en la biblioteca.
Como se había descrito anteriormente en la subclase se deberán implementar algunos
métodos como setup() donde se cargarán desde la base (archivo de parámetro), parámetros
para la configuración del algoritmo, como "neighborhood-size" (cantidad de vecinos) y
"expansion-size"(tamaño máximo de la malla) y produce(), método en el que se
implementara algoritmo y sus operadores: "Generación de nodos en dirección a los
extremos locales", "Generación de nodos en dirección hacia el extremo global" y
"Generación de nodos a partir de los nodos más externos de la malla".
Definiendo el problema
Antes de implementar la subclase de Problem fue necesario hacer unas modificaciones en
las clases propias de ECJ, Fitness y SimpleFitness, debido a que ECJ tiene un enfoque de
maximización y resulta ventajoso crear un parámetro que nos permita la opción de decidir
si se quiere maximizar o minimizar la función objetivo y de esta forma hacer más flexible
la biblioteca.
Luego para definir el problema será preciso crear una nueva subclase de Problem que
implemente la interfaz SimpleProblemForm con el identificador funciones.java, en
nuestro caso sí será obligatorio implementar el método setup () con el propósito de cargar
desde el archivo de parámetros el tipo de problema (función objetivo) a resolver. También
se debe implementar el método evaluate () el cual, en dependencia del tipo de función que
sea especificada desde el archivo de parámetros, calculará y asignará el valor fitness de
cada individuo y lo marcará como evaluado.
Capítulo 2
49
2.4 Conclusiones parciales
En este capítulo se realizó un estudio del funcionamiento de la plataforma de computación
evolutiva ECJ. Se especificaron las principales características y detalles del de la
herramienta, haciendo énfasis en la configuración de parámetros y la utilización de las
estructuras de clases disponibles. Además, a partir de las características específicas
abordadas, se definió una metodología que facilita la incorporación de nuevos algoritmos a
la biblioteca, resultando útil para la futura extensión de esta herramienta. Finalmente, a
manera de validación, se utilizó la metodología propuesta a través de un caso de estudio,
incorporando a la herramienta ECJ la variante continua del algoritmo VMO.
50
Capítulo 3 VERIFICACIÓN DE LOS RESULTADOS
En este Capítulo se realizará una verificación del método implementado en la plataforma
de optimización ECJ, con el fin de determinar si su comportamiento es similar al VMO
original. Para realizar la comparación de ambos métodos, el trabajo se apoyará en (Puris et
al., 2012), artículo publicado por el autor sobre la meta-heurística original (VMO) y del
que se tomará el experimento a desarrollar.
3.1 Especificaciones del experimento
En el funcionaminto del algoritmo intervienen diversos párametros que guían la ejecución
del método y que pueden tomar diferentes valores. Sin embargo, para la realización del
experimento en este trabajo se adopta las configuraciones de párametros originales
presentados en (Puris et al., 2012). Esta configuracion es:
Dimensión del problema ]
Total de evaluaciones de la función objetivo (condición de parada)
El número de vecinos k utilizado en todos los casos fue k
El valor de la población es y como tamaño de la malla generada T
De igual manera para hacer el experimento, se tomaron veinte funciones multimodales
descritas en (Suganthan et al., 2005). En cada caso se realizaron 25 simulaciones de las
funciones involucradas en la prueba, y se definió el valor del error calculado para cada
solución como ( ( ) ( ( ) ) donde
es el óptimo global de la función.
Cracterísticas generales de las funciones utilizadas:
Ruidosas y rotadas.
Desplazadas y no separables.
Multimodales con muchos óptimos locales.
Existencia de valles entre el óptimo local y el óptimo global.
Continua pero diferenciable sólo en un conjunto de puntos.
Capítulo 3
51
Clasificación de las funciones:
Siete funciones básicas todas multimodales ( )
-Shifted Rosenbrock’s Function
-Shifted Rotated Griewank’s Function without Bounds
-Shifted Rotated Ackley’s Function with Global Optimum on Bounds
-Shifted Rastrigin’s Function
-Shifted Rotated Rastrigin’s Function
-Shifted Rotated Weierstrass Function
-Schwefel’s Problem 2.13
Dos funciones multimodales expandidas
-Expanded Extended Griewank’s plusRosenbrock’s Function
-Shifted Rotated Expanded Scaffer’s
Once funciones híbridas ( )
-Hybrid Composition Function
-Rotated Hybrid Composition Function
-Rotated Hybrid Composition Function with Noise in Fitness
-Rotated Hybrid Composition Function
-Rotated Hybrid Composition Function with a Narrow Basin for the Global
Optimum
-Rotated Hybrid Composition Function with the Global Optimum on the
Bounds
-Rotated Hybrid Composition Function
-Rotated Hybrid Composition Function with High Condition Number Matrix
-Non-Continuous Rotated Hybrid Composition Function
-Rotated Hybrid Composition Function
-Rotated Hybrid Composition Function without Bounds
Capítulo 3
52
Propiedades de las funciones de prueba:
-Shifted Rosenbrock’s Function
( ) ∑ ( (
) ( ) ) (3.1)
Donde , D: Dimensión, : Óptimo
global.
Propiedades:
Multi-modal
Desplazada
No separable
Escalable
El rango de valor de las variables es y el óptimo es
( ) .
-Shifted Rotated Griewank’s Function without Bounds
( ) ∑
∏ o (
√ )
(3.2)
( ) ,
D: dimensiones, , M’: matriz de transformación lineal con número de
condición =3, M = M’ ( 1+0.3|N(0.1)|)
Propiedades:
Multi-modal
Rotada
Desplazada
No separable
Escalable
Ningún límite para variables x
el óptimo es ( ) .
-Shifted Rotated Ackley’s Function with Global Optimum on Bounds
Capítulo 3
53
( ) ( √
∑
) (
∑ ( )
) (3.3)
Donde ( o) , : Dimensión, o: Óptimo global, o
o están aleatoriamente distribuidos en el rango, para j ⌊ ⌋, : Matriz de
transformación lineal.
Propiedades:
Multi-modal
Rotada
Desplazada
No separable
Escalable
Óptima global sobre la cota
El rango de valor de las variables es y el óptimo es
( ) .
-Shifted Rastrigin’s Function
( ) ∑ ( ( ) )
(3.4)
Donde , : Dimensión, o : Óptimo global.
Propiedades:
Multi-modal
Desplazada
Separable
Escalable
Número enorme de óptimo local
El rango de valor de las variables es y el óptimo es ( ) .
-Shifted Rotated Rastrigin’s Function
( ) ∑ ( o ( ) )
(3.5)
Capítulo 3
54
Donde ( o) , : Dimensión, o: Óptimo global, : Matriz de
transformación lineal.
Propiedades:
Multi-modal
Desplazada
Rotada
No separable
Escalable
Número enorme de óptimo local
El rango de valor de las variables es y el óptimo es ( ) .
-Shifted Rotated Weierstrass Function
( ) ∑ (∑ * ( ( ))+ ) ∑ ( )
(3.6)
Donde , , km , ( o) , : Dimensión, o:
Óptimo global, : Matriz de transformación lineal.
El rango de valor de las variables es y el óptimo es ( ) .
Propiedades:
Multi-modal
Desplazada
Rotada
No separable
Escalable
Continua pero diferenciable solo en un punto
-Schwefel’s Problem 2.13
( ) ∑ ( ( ))
, (3.7)
Capítulo 3
55
Donde ∑ ( ) , ( ) ∑ ( )
, para
i , : Dimensión, : son dos matriz , , son números enteros
aleatorios en el rango , son números enteros aleatorios
en el rango .
Propiedades:
Multi-modal
Desplazada
Rotada
No separable
Escalable
Continua pero diferenciable solo en un punto
El rango de valor de las variables es y el óptimo es ( )
-Expanded Extended Griewank’s plusRosenbrock’s Function( )
( ) ∑
∏ o (
√ )
(3.2)
( ) ∑ ( ( )
( ) ) (3.8)
( ) ( ( )) ( ( )) ( ( )) ( ( )) (3.9)
o : Óptimo global D: dimensión
Propiedades:
Multi-modal
Desplazada
No separable
Escalable
El rango de valor de las variables es y el óptimo es ( )
Capítulo 3
56
-Shifted Rotated Expanded Scaffer’s
( ) ( (√ ) )
( ( )) (3.10)
( ) ( ) ( ) ( ) ( ) (3.11)
( ) o : Óptimo global
Propiedades:
Multi-modal
Desplazada
No separable
Escalable
El rango de valor de las variables es y el óptimo es ( )
-Hybrid Composition Function
( )
( ) ∑ ( o ( ) )
(3.5)
( )
( ) ∑ (∑ * o ( ( ))+ ) ∑ o ( )
(3.6)
( )
( ) ∑
∏ o (
√ )
(3.2)
( )
( ) p ( √
∑
) p (
∑ o ( )
) (3.3)
( )
( ) ∑
(3.12)
todas las matrices idénticas
Capítulo 3
57
Propiedades:
Multi-modal
Separable cerca del óptimo global (Rastrigin)
Escalable
Un número grande de óptimo local
Las propiedades de las funciones están mixtas
El rango de valor de las variables es y el óptimo es ( )
-Rotated Hybrid Composition Function
Excepto que son de transformación lineal con número de condición 2, todo las demás
configuraciones son iguales a
Propiedades:
Multi-modal
Rotada
No separable
Escalable
Un número grande de óptimo local
Las propiedades de las funciones están mixtas
Con ruido Gaussiano en su fitness
El rango de valor de las variables es y el óptimo es ( )
-Rotated Hybrid Composition Function with Noise in Fitness
: con ruido
donde G(x) es ( - 120)
( ) ( ) ( | ( )|) (3.13)
Propiedades:
Multi-modal
Rotada
No separable
Capítulo 3
58
Escalable
Un número grande de óptimo local
Las propiedades de las funciones están mixtas
El rango de valor de las variables es y el óptimo es ( )
-Rotated Hybrid Composition Function
( )
( ) p ( √
∑
) p (
∑ o ( )
) (3.3)
( )
( ) ∑ ( o ( ) )
(3.5)
( )
( ) ∑
(3.12)
( )
( ) ∑ (∑ * o ( ( ))+ ) ∑ o ( )
(3.6)
( )
( ) ∑
∏ o (
√ )
(3.2)
;
todas las matrices de rotación
Propiedades:
Multi-modal
Rotada
No separable
Escalable
Capítulo 3
59
Un número grande de óptimo local
Las propiedades de las funciones están mixtas
El óptimo local esta fijo en el origen
El rango de valor de las variables es y el óptimo es ( )
-Rotated Hybrid Composition Function with a Narrow Basin for the Global
Optimum
Es similar a excepto:
;
Propiedades:
Multi-modal
No separable
Escalable
Un número grande de óptimo local
Las propiedades de las funciones están mixtas
El óptimo local esta fijo en el origen
El rango de valor de las variables es y el óptimo es ( )
-Rotated Hybrid Composition Function with the Global Optimum on the Bounds
Es similar a excepto que después de cargar el fichero de datos ,
( ) ⌊
⌋
Propiedades:
Multi-modal
No separable
Escalable
Un número grande de óptimo local
Las propiedades de las funciones están mixtas
Capítulo 3
60
El óptimo global está en la frontera
El rango de valor de las variables es y el óptimo es ( )
-Rotated Hybrid Composition Function
( )
( ) ( (√ ) )
( ( )) (3.10)
( ) ( ) ( ) ( ) ( ) (3.11)
( )
( ) ∑ ( o ( ) )
(3.5)
( )
( ) ∑
∏ o (
√ )
(3.2)
( ) ∑ ( ( )
( ) ) (3.8)
( ) ( ( )) ( ( )) ( ( )) ( ( )) (3.9)
( )
( ) ∑ (∑ * o ( ( ))+ ) ∑ o ( )
(3.6)
( )
( ) ∑
∏ o (
√ )
(3.2)
,
todas las matrices ortogonales
Propiedades:
Multi-modal
Rotada
No separable
Escalable
Capítulo 3
61
Un número grande de óptimo local
Las propiedades de las funciones están mixtas
El rango de valor de las variables es y el óptimo es ( )
-Rotated Hybrid Composition Function with High Condition Number Matrix
Similar a F21 excepto las ’s cuyos números de condiciones son [10 20 50 100 200 1000
2000 3000 4000 5000]
Propiedades:
Multi-modal
No separable
Escalable
Un número grande de óptimo local
Las propiedades de las funciones están mixtas
El óptimo global está en la frontera
El rango de valor de las variables es y el óptimo es ( )
-Non-Continuous Rotated Hybrid Composition Function
Similar a F21 excepto:
{ | |
( ) ⁄ | | para (3.14)
( ) {
(3.15)
Donde es la parte integra de y es la decimal de
Propiedades:
Multi-modal
No separable
Escalable
Capítulo 3
62
Un número grande de óptimo local
Las propiedades de las funciones están mixtas
No es continua
El óptimo global está en la frontera
El rango de valor de las variables es y el óptimo es ( )
-Rotated Hybrid Composition Function
( )
( ) ∑ (∑ * o ( ( ))+ ) ∑ o ( )
(3.6)
( )
( ) ( (√ ) )
( ( )) (3.10)
( ) ( ) ( ) ( ) ( ) (3.11)
( )
( ) ∑
∏ o (
√ )
(3.2)
( ) ∑ ( ( )
( ) ) (3.8)
( ) ( ( )) ( ( )) ( ( )) ( ( )) (3.9)
( )
( ) p ( √
∑
) p (
∑ o ( )
) (3.3)
( )
( ) ∑ ( o ( ) )
(3.5)
( )
( ) ∑
∏ o (
√ )
(3.2)
( )
( ) ( (√ ) )
( ( )) (3.10)
( ) ( ) ( ) ( ) ( ) (3.11)
Capítulo 3
63
{ | |
( ) ⁄ | | para (3.14)
( )
( ) ∑ ( o ( ) )
(3.5)
{ | |
( ) ⁄ | | para (3.14)
( )
( ) ∑ ( )
(3.15)
( ) with Noise Fitness
( ) (∑
)( | ( )|) (3.16)
las ’s son matrices de rotadas cuyos numeros de condiciones son [100 50 30 10 5 5 4 3
2 2]
Propiedades:
Multi-modal
Rotada
No separable
Escalable
Un número grande de óptimo local
Las propiedades de las funciones están mixtas
Las funciones Unimodales dan las áreas llanas
El rango de valor de las variables es y el óptimo es ( )
-Rotated Hybrid Composition Function without Bounds
Esta función es igual que F24 excepto el rango de búsqueda.
Propiedades:
Multi-modal
Capítulo 3
64
No separable
Escalable
Un número grande de óptimo local
Las propiedades de las funciones están mixtas
Las funciones Unimodales dan las áreas llanas
El óptimo global se encuentra en la frontera
No tiene fronteras
El rango de valor de las variables es y el óptimo es ( )
3.2 Análisis de los resultados
Para analizar estadísticamente los resultados de las simulaciones se utilizan varios test con
el objetivo de demostrar que no existen diferencias significativas entre el VMO original y
la implementación discutida en el capítulo 2. Sin embargo, no existe un único
procedimiento a seguir para comparar algoritmos sobre múltiples conjuntos de datos, por lo
que son utilizadas diversas técnicas estadísticas para determinar la existencia o no de
diferencias significativas entre dos algoritmos.
Como no se tiene conocimiento sobre la distribución de los datos y los resultados obtenidos
por métodos estocásticos raramente cumplen con las normas para realizar pruebas
paramétricas se hará uso de pruebas no paramétricas (S.Siegel, 1956). En la clasificación
de pruebas no paramétricas existen varios test estadísticos, sin embargo, puesto que en este
trabajo se desea establecer una comparación ente dos muestras relacionadas se utilizará el
test de Wilcoxon (Wilcoxon, 1945). Los valores obtenidos por las simulaciones de los
algoritmos se muestran en la Tabla (3.1)
65
Tabla 3.1 Resultados obtenidos
para dimensión 10
Función VMO_ECJ VMO
F6 2.78E+01 6.02E+01
F7 1.27E+03 6.39E+02
F8 2.03E+01 2.03E+01
F9 1.01E+01 3.10E+00
F10 1.61E+01 4.79E+00
F11 6.14E+00 5.12E+00
F12 7.16E+01 7.55E+01
F13 1.06E+00 7.48E-01
F14 2.25E+00 2.74E+00
F15 2.93E+02 2.14E+02
F16 1.19E+02 1.03E+02
F17 1.17E+02 1.20E+02
F18 5.74E+02 7.46E+02
F19 4.50E+02 6.98E+02
F20 7.21E+02 7.87E+02
F21 5.65E+02 5.53E+02
F22 7.56E+02 7.51E+02
F23 7.55E+02 6.45E+02
F24 2.60E+02 4.06E+02
F25 1.74E+03 3.88E+02
Tabla 3.2 Resultados obtenidos
para dimensión 30
Función VMO_ECJ VMO
F6 6.33E+02 1.75E+03
F7 4.86E+03 2.79E+04
F8 2.09E+01 2.10E+01
F9 8.30E+01 1.32E+02
F10 7.99E+01 6.15E+01
F11 1.67E+01 1.60E+01
F12 8.93E+03 1.37E+04
F13 5.43E+00 5.06E+00
F14 1.20E+01 1.24E+01
F15 3.40E+02 3.78E+02
F16 3.52E+02 2.40E+02
F17 2.72E+02 3.21E+02
F18 8.97E+02 9.31E+02
F19 9.07E+02 8.32E+02
F20 9.08E+02 8.31E+02
F21 5.00E+02 7.77E+02
F22 8.87E+02 5.55E+02
F23 5.34E+02 8.87E+02
F24 2.00E+02 2.13E+02
F25 1.61E+03 2.06E+02
Tabla 3.1 Resultados obtenidos
para dimensión 50
Función VMO_ECJ VMO
F6 3.12E+03 2.59E+03
F7 6.42E+03 4.26E+03
F8 2.12E+01 2.11E+01
F9 3.01E+02 3.17E+02
F10 3.24E+02 1.28E+02
F11 5.31E+01 8.63E+01
F12 2.94E+05 1.42E+05
F13 2.73E+01 8.16E+00
F14 2.28E+01 2.11E+01
F15 4.92E+02 5.90E+02
F16 2.68E+02 3.56E+02
F17 2.99E+02 5.25E+02
F18 9.92E+02 1.14E+03
F19 1.00E+03 1.07E+03
F20 9.91E+02 1.03E+03
F21 7.11E+02 9.96E+02
F22 1.07E+03 9.98E+02
F23 7.87E+02 1.57E+03
F24 9.72E+02 1.10E+03
F25 1.71E+03 1.71E+03
Con el objetivo de determinar la posible existencia de diferencias significativas entre el
VMO implementado en el framework ECJ con respecto al algoritmo original, a través del
test de Wilcoxon para muestras pareadas se realizó un análisis del comportamiento de los
dos algoritmos. Como se muestra en la Tabla 3.4 los valores de significación son mayores a
0.05 y por tanto la hipótesis de igualdad es aceptada, por lo que se garantiza que no existen
diferencias significativas en el comportamiento entre los dos algoritmos.
Tabla 3.4 Resultados de Test de Wilcoxon
Algoritmo R
+ R
- Valor p Hipótesis
dimensión d = 10 VMO_ECJ vs VMO 120 90 0,575 A
Capítulo 3
66
dimensión d = 30 VMO_ECJ vs VMO 81 129 0,370 A
dimensión d = 50 VMO_ECJ vs VMO 87 123 0,502 A
3.3 Conclusiones parciales
En el desarrollo de este Capítulo se presentó una verificación experimental con el objetivo
de comparar el desempeño del algoritmo VMO implementado en ECJ, respecto al VMO
original. En este caso se utilizaron pruebas no-paramétricas por el carácter estocástico de
las simulaciones. Ambas implementaciones fueron probadas con una amplia gama de
funciones que presentan características: multimodalidad, no separables, ruido, óptimos en
las fronteras. A los resultados obtenidos por ambos métodos (error respecto al óptimo
conocido) se les aplicó el test de Wilcoxon con el fin de verificar que no existiesen
diferencias significativas Esta hipótesis fue confirmada tal y como sugiere la Tabla 3.4, por
lo que es posible concluir que la implementación de VMO adicionada a ECJ, utilizando la
metodología descrita, no se diferencia de la variante original.
Conclusiones
67
CONCLUSIONES
Con la realización de este trabajo se incorporan nuevas funcionalidades a la biblioteca ECJ,
proporcionando a los investigadores y desarrolladores en el campo de la optimización un
marco de trabajo más extensible. Los resultados obtenidos muestran como, a través de la
metodología propuesta, es posible añadir nuevos algoritmos a la plataforma cumpliéndose
de esta forma los objetivos planteados a partir de que:
A través de cuatro pasos se formalizó una metodología que permite añadir nuevos
algoritmos poblacionales y de Inteligencia Colectiva a la biblioteca, mostrando las
facilidades de extender esta herramienta. En este sentido la nueva metodología aumenta la
usabilidad de la herramienta por otros expertos.
Por otra parte, siguiendo los pasos propuestos se incorporó a la biblioteca ECJ, la variante
continua de la meta-heurística Optimización de Mallas Variables (VMO), validando de esta
forma la factibilidad de la metodología.
Mediante un caso experimental propuesto y el uso de herramientas estadísticas fueron
verificados los resultados obtenidos por el algoritmo incorporado a ECJ, respecto a los
resultados obtenidos con el VMO original. En este estudio se demostró estadísticamente
que ambas implementaciones no se diferencian de forma significativa (salvo por el carácter
no determinista de las meta-heurísticas). Este resultado confirma la utilidad de la
metodología presentada en este trabajo para incorporar nuevos algoritmos poblacionales y
de inteligencia colectiva a la biblioteca ECJ.
68
RECOMENDACIONES
Para trabajos futuros se recomienda extender la validación y verificación de la metodología
propuesta para otros algoritmos, especialmente aquellos reportados como parte de la
producción científica de profesores e investigadores del Centro de Estudios de Informática,
Universidad Central “Marta Abreu” de Las Villas.
Referencias Bibliográficas
69
REFERENCIAS BIBLIOGRÁFICAS
BÄCK, T. 1996. Evolutionary Algorithms in Theory and Practice: Evolution Strategies
Evolutionary Programming Genetic Algorithms, New York, Oxford University
Press.
BÄCK, T., HAMMEL, U. & SCHWEFEL, H. 1997. Evolutionary Computation:
Comments on the History and Current State. IEEE Transactions on Evolutionary
Computation Estados Unidos, 1, 3-17.
BÄCK, T. & SCHWEFEL, H. Evolutionary Computation: An Overview. 166-179.
BEYER, H.-G. (ed.) 2001. The Theory of Evolution Strategies, Springer.
BONABEAU, E. 1999. Swarm Intelligence: From natural to artificial systems, Oxford
University Press.
DORIGO, M. 1999. Ant algorithms for Discrete optimization. 137-172.
DORIGO, M. & STUTZLE, T. 2004. Ant Colony Optimization, Cambridge, MA, MIT
Press.
GLOVER, F. & KOCHENBERGER, G. (eds.) 2003. Handbook of Metaheuristics.: Kluwer
Academic Publishers.
GLOVER, F. & LAGUNA, M. 1997. Tabu Search, MA, Kluwer Academic Publishers.
GOLDBERG, D. E. 1989. Genetic Algorithms in Search. Optimization and Machine
Learning. MA: Addison-Wesley.
GOLDBERG, D. E. (ed.) 1998. Genetic Algorithms in Search, University of Alabama:
Addison-Wesley Publishing Company.
HOOKER, J. H. 1995. Testing Heuristics: We Heve it All Wrong. Journal of Heuristics, 1,
33-42.
KENNEDY, J. & EBERHART, R. C. Year. Particle swarm optimization. In: IEEE
International Conference on Neural Networks, 1995 Piscataway, New York, USA. ,
1942-1948.
KIRKPATRICK, S., GELLAT, C. & VECCHI, M. 1983. Optimization by simulated
annealing. Science, 220, 671–680.
KOZA, J. 1992. Genetic programming: On the programming of computers by means of
natural selection, Cambridge, MA: MIT Press.
LANGDON, W. B. & POLI, R. 2002. Foundations of Genetic Programming, New York,
Springer-Verlag
LUENBERGER, D. G. & YE, Y. 2008. Linear and Nonlinear Programming, New York,
USA, Springer Science +Business Media, LLC.
LUKE, S. "ECJ, A Java-based Evolutionary Computation and Genetic Programming
Research System". [Online]. Available: http://cs.gmu.edu/~eclab/projects/ecj/
[Accessed].
MÜLLER-MERBACH, H. 1981. Heuristics and their design: a survey. European Journal
of Operational Research, 1–23.
NÁPOLES, G., GRAU, I. & BELLO, R. 2012. Constricted Particle Swarm Optimization
based
algorithm for global optimization
Referencias Bibliográficas
70
NAVARRO, R., PURIS, A., BELLO, R. & FRANCISCOHERRERA 2009. Estudio del
desempeño de la optimización basada en mallas variables en problemas con
óptimas en las fronteras del espacio de búsqueda. 3, 57-64.
PRICE, K. V., RAINER, R. M. & LAMPINEN, J. A. 2005. Differential Evolution: A
Practical Approach to Global Optimization. . London: Springer-Verlag.
PUNCH, B. & ZONGKER, D. 1998. lil-gp 1.1. A genetic programming system. [Online].
Available: http://garage.cse.msu.edu/software/lil-gp/, [Accessed].
PURIS, A. 2009. Desarrollo de meta-heurísticas poblacionales para la solución de
problemas complejos. Universidad Central “Marta Abreu” de Las Villas.
PURIS, A., BELLO, R., MOLINA, D. & HERRERA, F. 2012. Variable mesh optimization
for continuous optimization problems. Soft Comput, 511–525.
S.SIEGEL 1956. Nonparametric statistics for the behavioral sciences, New York,
McGrawHill.
SHI, Y. & EBERHART, R. C. 1998. Parameter selection in particle swarm optimization.
Evolutionary Programming VII, 591–600.
STORN, R. & PRICE, K. V. 1997. Differential evolution-A simple and efficient heuristic
for global optimization over continuous Spaces. Journal of Global Optimization,
vol.11, 341-359.
SUGANTHAN, P. N., HANSEN, N., LIANG, J. J., DEB, K., CHEN, Y.-P., AUGER, A. &
TIWARI, S. 2005. Problem Definitions and Evaluation Criteria for the CEC 2005
Special Session on Real-Parameter Optimization.
VANDERBEI, R. J. 2001. Linear Programming: Foundations and Extensions.
WILCOXON, F. 1945. Ajusted p-values for simultaneous inference. Biometrics, 48, 1005-
1013.
YAO, X. 1999. Evolutionary computation, theory and applications. World Scientific.
Anexos
71
ANEXOS
Anexo 1: Gráficas de las Funciones experimentales
-Shif Ro n o k’ un ion -Shif Ro G i w nk’ un ion without Bounds
-Shif Ro kl ’ un ion with Global Optimum on Bounds
-Shif R igin’ un ion
Anexos
72
-Shif Ro E p n S ff ’ -Hybrid Composition Function
-Schwefel’s Problem
2.13
-E p n E n G i w nk’ plu Ro n o k’ un ion
-Shifted Rotated Weierstrass
Function
-Shif Ro R igin’ Function
Anexos
73
-Rotated Hybrid Composition Function with Noise in Fitness
-Rotated Hybrid Composition Function
-Rotated Hybrid Composition Function -Rotated Hybrid Composition Function with a Narrow Basin for the Global Optimum
-Rotated Hybrid Composition Function with the Global Optimum on the Bounds
-Rotated Hybrid Composition Function
Anexos
74
-Rotated Hybrid Composition Function with High Condition Number Matrix
-Non-Continuous Rotated Hybrid Composition Function
-Rotated Hybrid Composition Function
Anexos
75
Anexo 2: Resultados del test de Wilcoxon
Tabla para
Rangos
N Rango
promedio
Suma de
rangos
VMO - VMO_ECJ
Rangos negativos 12a 10.00 120.00
Rangos positivos 8b 11.25 90.00
Empates 0c
Total 20
a. VMO < VMO_ECJ
b. VMO > VMO_ECJ
c. VMO = VMO_ECJ
Estadísticos de contrastea
VMO -
VMO_ECJ
Z -.560b
Sig. asintót. (bilateral) .575
a. Prueba de los rangos con signo de
Wilcoxon
b. Basado en los rangos positivos.
Tabla para
Rangos
N Rango
promedio
Suma de
rangos
VMO - VMO_ECJ
Rangos negativos 8a 10.13 81.00
Rangos positivos 12b 10.75 129.00
Empates 0c
Total 20
a. VMO < VMO_ECJ
b. VMO > VMO_ECJ
c. VMO = VMO_ECJ
Anexos
76
Estadísticos de contrastea
VMO -
VMO_ECJ
Z -.896b
Sig. asintót. (bilateral) .370
a. Prueba de los rangos con signo de
Wilcoxon
b. Basado en los rangos negativos.
Tabla para
Rangos
N Rango
promedio
Suma de
rangos
VMO - VMO_ECJ
Rangos negativos 8a 10.88 87.00
Rangos positivos 12b 10.25 123.00
Empates 0c
Total 20
a. VMO < VMO_ECJ
b. VMO > VMO_ECJ
c. VMO = VMO_ECJ
Estadísticos de contrastea
VMO -
VMO_ECJ
Z -.672b
Sig. asintót. (bilateral) .502
a. Prueba de los rangos con signo de
Wilcoxon
b. Basado en los rangos negativos.
