PRÁCTICA 1 – ALGORITMOS GENÉTICOS

Universidad de San Carlos de Guatemala

Jorge Raúl Lu Hernández
Carné: 200512045

12-8-2010
CONTENIDO

Características y funcionalidades de JGAP ............................................................................................................... 1

Algoritmos genéticos .......................................................................................................................................... 1

¿Qué ofrece JGAP? ............................................................................................................................................. 1

Clases e interfaces .......................................................................................................................................... 1

Motor genético............................................................................................................................................... 2

Licencia .............................................................................................................................................................. 2

Instalación de JGAP ................................................................................................................................................ 2

Implementación de un algoritmo genético con JGAP............................................................................................... 2

Problema a resolver............................................................................................................................................ 2

Establecer la función de ajuste............................................................................................................................ 2

Implementación en JGAP .................................................................................................................................... 3

Incluir JGAP en el proyecto.............................................................................................................................. 3

Función de ajuste............................................................................................................................................ 4

Configuración ................................................................................................................................................. 5

Bibliografía ............................................................................................................................................................. 6
PRÁCTICA 1 – ALGORITMOS GENÉTICOS

CARACTERÍSTICAS Y FUNCIONALIDADES DE JGAP

JGAP son las siglas de Java Genetic Algorithms Package (paquete de algoritmos genéticos para Java). Es un
componente de programación de algoritmos genéticos que se utiliza como un framework.

ALGORITMOS GENÉTICOS

Los algoritmos genéticos se basan en la teoría de la evolución de Charles Darwin. Se tiene una población, donde
cada individuo posee diferentes características. Esas características se muestran favorables o no frente a un
método de selección al que se enfrentan todos los individuos. Así se van identificando los que poseen las mejores
características.

Las características de los individuos están dadas por sus cromosomas. Un cromosoma es un conjunto de genes.
Cada gen es responsable de indicar el tipo de una sola característica del individuo. El valor que toma el gen se
llama alelo.

En la biología, los individuos mejor adaptados al medio donde se encuentran son los que sobreviven. De esa forma
se reproducen, dando lugar a una descendencia que hereda sus características ventajosas. También se dan
variaciones en los genes por medio de la combinación (reproducción sexual) o por cambios aleatorios
(mutaciones). Así surgen de forma natural más características que a su vez son puestas a prueba y permiten a sus
portadores sobrevivir y reproducirse si son las más adecuadas para el ambiente que les rodea.

Los algoritmos genéticos son una analogía de lo que ocurre biológicamente, pero aplicada a encontrar la mejor
solución a un problema. Cada solución es un individuo. El método de selección se llama función de ajsute, e indica
la aptitud de cada individuo para resolver el problema. También existen cromosomas con genes y sus respectivos
alelos. A los cromosomas se les aplican operadores genéticos, equivalentes a la mutación y la reproducción sexual,
de forma que se generan y ponen a prueba nuevas soluciones. De ese modo, los algoritmos genéticos son un
método para probar múltiples soluciones “autogeneradas” a un problema.

¿QUÉ OFRECE JGAP?

CLASES E INTERFACES

JGAP tiene clases e interfaces para representar: Genes (Gene), cromosomas (Chromosome), individuos
(IChromosome), la población (Genotype), la función de ajuste (FitnessFunction) y operadores genéticos.

1
Se trata de una solución genérica, sin relación alguna con un problema particular. Por esa razón se deben crear
nuevas clases que heredan o implementan las clases e interfaces mencionadas. Así se adapta JGAP al problema
específico que se quiere solucionar.

MOTOR GENÉTICO

JGAP también se encarga de la simulación de un ambiente para que se desarrolle y sobreviva la mejor solución. El
“motor genético” crea varias soluciones (individuos) aleatoriamente con el método randomInitialGenotype().
Aplica operadores genéticos (mutación y combinación) para que surjan nuevas soluciones con el método
evolve(). Pone a prueba cada solución con la función de ajuste evaluate(). Y por último retorna el cromosoma
del individuo mejor adaptado con getFittestChromosome().

LICENCIA

JGAP es software libre y se puede distribuir bajo la GNU Lesser Public License 2.1 o posterior. Las aplicaciones
comerciales que no publiquen su código fuente deben distribuirse bajo la Mozilla Public License. En ese caso deben
donarse 50 Euros al proyecto.

INSTALACIÓN DE JGAP

El primer paso es descargar la última versión de JGAP. Al momento de escribir este documento es la 3.4.4. Se
puede encontrar en la siguiente dirección:

http://sourceforge.net/projects/jgap/files/

El archivo se llama jgap_3.4.4_full.zip. Se recomienda descargar el de instalación completa si no se desea compilar

el código.

Luego de descargar el archivo se extrae su contenido. Esto puede hacerse en cualquier directorio. Por último sólo
es necesario incluir el archivo jgap.jar como una biblioteca para poder usar las clases de JGAP.

IMPLEMENTACIÓN DE UN ALGORITMO GENÉTICO CON JGAP

PROBLEMA A RESOLVER

Los algoritmos genéticos son particularmente útiles para resolver problemas de optimización. Como ejemplo se va
a maximizar el volumen de un cilindro, pero la suma de su radio (r) y su altura (h) debe ser de 30cm.

ESTABLECER LA FUNCIÓN DE AJUSTE

Si r y h se expresan en cm, se obtiene la relación de la Ecuación 1.

Ecuación 1. Relación entre las variables r y h

Para lograr que se respete la restricción, la Ecuación 1 se puede transformar para expresar la altura en función del
radio. La transformación se muestra en la Ecuación 2.

2
 Ecuación 2. Altura h en función del radio r

La Ecuación 3 muestra el volumen de un cilindro como una función de su radio y su altura.

Ecuación 3. Fórmula del volumen de un cilindro

Sustituyendo h en la Ecuación 3 por la Ecuación 2, la función de ajuste se puede expresar como el volumen del
cilindro en función del radio solamente. El resultado se aprecia en la Ecuación 4, para valores de r mayores a 0 y
menores a 30.

Ecuación 4. Función de ajuste

IMPLEMENTACIÓN EN JGAP

INCLUIR JGAP EN EL PROYECTO

Para poder usar las clases de JGAP, se debe incluir en el proyecto. En este caso se utiliza NetBeans, por lo que se
agrega el archivo jgap.jar como biblioteca. Esto puede hacerse desde las propiedades del proyecto, en el nodo
“Libraries”. La Ilustración 1 muestra la ventana de propiedades del proyecto.

Ilustración 1. Ventana de propiedades del proyecto

3
La Ilustración 2 muestra la biblioteca de JGAP ya incluida como parte del proyecto.

Ilustración 2. JGAP como biblioteca del proyecto

De ese modo sólo es necesario importar los paquetes de JGAP necesarios para poder usar sus clases, como se
aprecia en la Ilustración 3.

Ilustración 3. Uso de las clases de JGAP en NetBeans

FUNCIÓN DE AJUSTE

La función de ajuste de JGAP se implementa sobrecargando el método evaluate() en una subclase de

FitnessFunction (se debe extender). Esta función se debe especificar de modo que un resultado mayor indique
que el individuo evaluado es más apto. Como el mejor resultado lo dará el mayor volumen, no es necesario
modificar la Ecuación 4.

public double evaluate(IChromosome sujeto) {

double radio = (Double)sujeto.getGene(0).getAllele();
return 2 * Math.PI * Math.pow(radio, 2) * (30 - radio);
}

4
CONFIGURACIÓN

Se debe configurar el entorno que el motor genético de JGAP va a simular. Para ello se usa una instancia de la clase
Configuration.

Configuration configuracion = new DefaultConfiguration();

Luego se indica la función de ajuste que se va a usar con una instancia de la subclase de FitnessFunction.

FitnessFunction maximizarVolumen = new FuncionAjusteMaximizarVolumen();

configuracion.setFitnessFunction(maximizarVolumen);

Después se debe crear un cromosoma de “muestra”. Se usa para indicar la cantidad de genes que lo componen, así
como su tipo de dato y de preferencia un rango de valores para los alelos. Especificar un rango es importante
porque reduce la cantidad de posibilidades que se pueden generar, mejorando el tiempo de ejecución.

Gene[] genes = { new DoubleGene(configuracion, 0.0, 30.0) };

Chromosome cromosoma = new Chromosome(configuracion, genes);
configuracion.setSampleChromosome(cromosoma);

El siguiente paso es definir el tamaño de la población. Una vez hecho, se pueden crear los individuos de la primera
generación de forma automática y aleatoria.

configuracion.setPopulationSize(TAMANIO_POBLACION);
Genotype poblacion = Genotype.randomInitialGenotype(configuracion);

Se continúa con la evolución de las diferentes generaciones. Puede ir dentro de un ciclo para hacerlo varias veces.
En cada generación se seleccionan los mejores individuos por medio de la función de ajuste. A partir de ellos se
crea la siguiente generación, mejor adaptada para resolver el problema.

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

poblacion.evolve();
}

Para terminar se obtiene el cromosoma del individuo mejor adaptado de la última generación.

IChromosome mejorSolucion = poblacion.getFittestChromosome();

A partir de ese cromosoma se puede obtener su valor con el método getAllele() y su resultado en la función de
ajuste con getFitnessValue() (que en este ejemplo es el volumen). Una salida obtenida fue la siguiente:

El mayor volumen es para un radio de 19.98009774232426cm y una altura de

10.019902257675739cm.
El volumen resultante es de 25132.666615185735cm cúbicos.

Algo interesante de los algoritmos genéticos es que no son determinísticos. Los resultados de distintas ejecuciones
tendrán pequeñas diferencias. Eso se debe a la generación aleatoria de los alelos para los genes. Es poco probable
que en ejecuciones distintas se den de forma exacta los mismos valores hasta el último decimal.

5
BIBLIOGRAFÍA

[1] JGAP. (2010) [En línea]. http://jgap.sourceforge.net/doc/tutorial.html

[2] JGAP. (2010) [En línea]. http://jgap.sourceforge.net/#documentation