UNIVERSIDAD NACIONAL DE LOJA

REA DE LA ENERGIA LAS INDUSTRIAS Y LOS RECURSOS NATURALES NO RENOVABLES

Carrera Ingeniera En Sistemas

MODULO X A

Algoritmos Genticos JGAP

Alumno: Jorge Tene

Docente:
Ing. Luis Chamba

LOJA ECUADOR
2011

CONTENIDOS 1. Introduccin 2. Instalacin y configuracin del entorno 2.1 Generalidades 2.2 Descarga e instalacin de JGAP 2.3 Agregar las libreras a la aplicacin Netbeans 3. Algoritmos Genticos 4. Ejemplo de aplicacin 5. Implementacin de ejemplo Funcin Aptitud 6. ANEXO II: Licencia

Introduccin
JGAP son las siglas de Java Genetic Algorithms Package (paquete de algoritmos genticos para Java). Es un componente de programacin de algoritmos genticos que se utiliza como un framework. Los algoritmos genticos se basan en la teora de la evolucin de Charles Darwin. Se tiene una poblacin, donde cada individuo posee diferentes caractersticas. Esas caractersticas se muestran favorables o no frente a un mtodo de seleccin al que se enfrentan todos los individuos. As se van identificando los que poseen las mejores caractersticas. Las caractersticas de los individuos estn dadas por sus cromosomas. Un cromosoma es un conjunto de genes. Cada gen es responsable de indicar el tipo de una sola caracterstica del individuo. El valor que toma el gen se llama alelo. QU OFRECE JGAP? JGAP tiene clases e interfaces para representar: Genes (Gene), cromosomas (Chromosome), individuos (IChromosome), la poblacin (Genotype), la funcin de ajuste (FitnessFunction) y operadores genticos. Se trata de una solucin genrica, sin relacin alguna con un problema particular. Por esa razn se deben crear nuevas clases que heredan o implementan las clases e interfaces mencionadas. As se adapta JGAP al problema especfico que se quiere solucionar. MOTOR GENTICO JGAP tambin se encarga de la simulacin de un ambiente para que se desarrolle y sobreviva la mejor solucin. El motor gentico crea varias soluciones (individuos) aleatoriamente con el mtodo randomInitialGenotype(). Aplica operadores genticos (mutacin y combinacin) para que surjan nuevas soluciones con el mtodo evolve(). Pone a prueba cada solucin con la funcin 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 cdigo fuente deben distribuirse bajo la Mozilla Public License. En ese caso deben donarse 50 Euros al proyecto.Laboratorio de AG con JGAPAlgoritmos-geneticos.

2. Instalacin y configuracin del entorno. 2.1 Generalidades. En primer lugar debe disponerse de una herramienta de desarrollo de aplicaciones java. Luego es necesario descargar las libreras JGAP y agregarlas a una aplicacin. - Descarga e instalacin de la mquina virtual de java. Antes de empezar a programar en un IDE de programacin como Eclipse o Netbeans es necesario disponer de la mquina virtual de java para poder compilar las aplicaciones.

Se puede obtener en este sitio o en el http://java.sun.com/javase/downloads/index.jsp

2.2 Descarga e instalacin de JGAP Se deben descargar las libreras de JGAP desde el sitio oficial hay un link a la ltima versin. Hasta el da de hoy es 3.5. Las libreras las pueden descargar de la siguiente direccin: http://sourceforge.net/projects/jgap/files/

El archivo se llama jgap_3.5_full.zip. Para que no existan errores de instalacin se recomienda descargar el instalador completo para que no estn en la necesidad de compilar el cdigo. Procedemos a descomprimir el archivo mencionado anteriormente en un cualquier directorio que a usted le parezca ms conveniente. Lo que haremos a continuacin es incluir el archivo jgap.jar como una biblioteca para hacer uso de todas las clases del JGAP. 2.3 Agregar las libreras a la aplicacin Netbeans Una vez tengamos nuestro proyecto abierto con Netbeans lo que hacemos es hacer clic derecho en el proyecto y nos dirigimos en propiedades y en la opcin Libaries agregamos la libreria jgap.jar haciendo clic en Add Jar/folder.

3. Algoritmos Genticos Los Algoritmos Gticos (AGs) son mtodos adaptativos que pueden usarse para resolver problemas de bsqueda y optimizacin. Estn basados en el proceso gentico de los organismos vivos. A lo largo de las generaciones, las poblaciones evolucionan en la naturaleza de acorde con los principios de la seleccin natural y la supervivencia de los mas fuertes, postulados por Darwin (1859). Por imitacin de este proceso, los Algoritmos Genticos son capaces de ir creando soluciones para problemas del mundo real. La evolucin de dichas soluciones hacia valores ptimos del problema depende en buena medida de una adecuada coeducacin de las mismas. Los Algoritmos Genticos usan una analoga directa con el comportamiento natural. Trabajan con una poblacin de individuos, cada uno de los cuales representa una solucin factible a un problema dado. A cada individuo se le asigna un valor o puntuacin, relacionado con la bondad de dicha solucin. En la naturaleza esto equivaldra al grado de efectividad de un organismo para competir por unos determinados recursos. Cuanto mayor sea la adaptacin de un individuo al problema, mayor sera la probabilidad de que el mismo sea seleccionado para reproducirse, cruzando su material gentico con otro individuo seleccionado de igual forma. Este cruce producira nuevos individuos descendientes de los anteriores los cuales comparten algunas de las caractersticas de sus padres. Cuanto menor sea la adaptacin de un individuo, menor sera la probabilidad de que dicho individuo sea seleccionado para la reproduccin, y por tanto de que su material gentico se propague en sucesivas generaciones. De esta manera se produce una nueva poblacin de posibles soluciones, la cual reemplaza a la anterior y verifica la interesante propiedad de que contiene una mayor proporcin de buenas caractersticas en comparacin con la poblacin anterior. As a lo largo de las generaciones las buenas caractersticas se propagan a travs de la poblacin. Favoreciendo el cruce de los individuos mejor adaptados, van siendo exploradas las reas ms prometedoras del espacio de bsqueda. Si el Algoritmo Gentico ha sido bien diseado, la poblacin convergera hacia una solucin ptima del problema. El poder de los Algoritmos Genticos proviene del hecho de que se trata de una tcnica robusta, y pueden tratar con xito una gran variedad de problemas provenientes de diferentes reas, incluyendo aquellos en los que otros mtodos encuentran dificultades. Si bien no se garantiza que el Algoritmo Gentico encuentre la solucin ptima del problema, existe evidencia emprica de que se encuentran soluciones de un nivel aceptable, en un tiempo competitivo con el resto de

algoritmos de optimizacin combinatoria. En el caso de que existan tcnicas especializadas para resolver un determinado problema, lo ms probable es que superen al Algoritmo Gentico, tanto en rapidez como en eficacia. El gran campo de aplicacin de los Algoritmos Genticos se relaciona con aquellos problemas para los cuales no existen tcnicas especializadas. Incluso en el caso en que dichas tcnicas existan, y funcionen bien, pueden efectuarse mejoras de las mismas hibridndolas con los Algoritmos Genticos.

4. Ejemplo de aplicacin Una vez ya instalado las libreras en nuestro proyecto ejecutamos la aplicacin y nos debe de dar los siguientes resultados. Cuando insertamos un total de 800 centavos el programa nos arroja como resultado lo siguiente:

Donde notamos que la suma de todas las 12 monedas en centavos nos da como resultado 800 centavos en total.

5. Codigo Fuente Esta cdigo es de la clase CambioMInimo.java package practica1; import import import import import import import import java.io.File; org.jgap.Chromosome; org.jgap.Configuration; org.jgap.FitnessFunction; org.jgap.Gene; org.jgap.Genotype; org.jgap.IChromosome; org.jgap.data.DataTreeBuilder;

import import import import import import

org.jgap.data.IDataCreators; org.jgap.impl.DefaultConfiguration; org.jgap.impl.IntegerGene; org.jgap.xml.XMLDocumentBuilder; org.jgap.xml.XMLManager; org.w3c.dom.Document;

public class CambioMinimo { /** * The total number of times we'll let the population evolve. */ private static final int MAX_EVOLUCIONES_PERMITIDAS = 2200; /** * Calcula utilizando algoritmos geneticos la solucin al problema y la * imprime por pantalla * * @param Monto * Monto que se desea descomponer en la menor cantidad de monedas * posibles * @throws Exception * */ public static void calcularCambioMinimo(int Monto)throws Exception { // Se crea una configuracion con valores predeterminados. // -----------------------------------------------------------Configuration conf = new DefaultConfiguration(); // Se indica en la configuracion que el elemento mas apto siempre pase a // la proxima generacion // -----------------------------------------------------------conf.setPreservFittestIndividual(true); // Se Crea la funcion de aptitud y se setea en la configuracion // -------------------------------------------------------FitnessFunction myFunc = new CambioMinimoFuncionAptitud(Monto); conf.setFitnessFunction(myFunc); // Ahora se debe indicar a la configuracion como seran los cromosomas: en // este caso tendran 8 genes (uno para cada tipo de moneda) con un valor // entero (cantidad de monedas de ese tipo).

// Se debe crear un cromosoma de ejemplo y cargarlo en la configuracion // Cada gen tendra un valor maximo y minimo que debe setearse. // ------------------------------------------------------------Gene[] sampleGenes = new Gene[6]; sampleGenes[0] = new IntegerGene(conf, 0, Math.round(CambioMinimoFuncionAptitud.MAX_MONTO/100)); // Moneda 1 dolar sampleGenes[1] = new IntegerGene(conf, 0, 10); // Moneda 50 centimos sampleGenes[2] = new IntegerGene(conf, 0, 10); // Moneda 25 centavos sampleGenes[3] = new IntegerGene(conf, 0, 10); // Moneda 10 centavos sampleGenes[4] = new IntegerGene(conf, 0, 10); // Moneda 5 centavos sampleGenes[5] = new IntegerGene(conf, 0, 10); // Moneda 1 centavos IChromosome sampleChromosome = new Chromosome(conf, sampleGenes); conf.setSampleChromosome(sampleChromosome); // Por ultimo se debe indicar el tamao de la poblacion en la // configuracion // ----------------------------------------------------------conf.setPopulationSize(200); Genotype Poblacion; // El framework permite obtener la poblacion inicial de archivos xml // pero para este caso particular resulta mejor crear una poblacion // aleatoria, para ello se utiliza el metodo randomInitialGenotype que // devuelve la poblacion random creada Poblacion = Genotype.randomInitialGenotype(conf); // La Poblacion debe evolucionar para obtener resultados mas aptos // -------------------------------------------------------------long TiempoComienzo = System.currentTimeMillis(); for (int i = 0; i < MAX_EVOLUCIONES_PERMITIDAS; i++) { Poblacion.evolve(); } long TiempoFin = System.currentTimeMillis(); System.out.println("Tiempo total de evolucion: " + (TiempoFin - TiempoComienzo) + " ms"); guardarPoblacion(Poblacion); // Una vez que la poblacion evoluciono es necesario obtener el cromosoma

// mas apto para mostrarlo como solucion al problema planteado para ello // se utiliza el metodo getFittestChromosome IChromosome cromosomaMasApto = Poblacion.getFittestChromosome(); System.out.println("El cromosoma mas apto encontrado tiene un valor de aptitud de: " + cromosomaMasApto.getFitnessValue()); System.out.println("Y esta formado por la siguiente distribucion de monedas: "); System.out.println("\t" + CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasAp to, 0) + " Moneda 1 dolar"); System.out.println("\t" + CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasAp to, 1) + " Moneda 50 centavos"); System.out.println("\t" + CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasAp to, 2) + " Moneda 25 centavos"); System.out.println("\t" + CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasAp to, 3) + " Moneda 10 centavos"); System.out.println("\t" + CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasAp to, 4) + " Moneda 5 centavos"); System.out.println("\t" + CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasAp to, 5) + " Moneda 1 centavo"); System.out.println("Para un total de "+ CambioMinimoFuncionAptitud.montoCambioMoneda(cromosomaMasApto) + " centavos en " + CambioMinimoFuncionAptitud.getNumeroTotalMonedas(cromosomaMasApto) + " monedas."); } /** * Metodo principal: Recibe el monto en dinero por parametro para determinar * la cantidad minima de monedas necesarias para formarlo * * @param args * Monto de dinero * @throws Exception * */ public static void main(String[] args) throws Exception { int amount = 800; try { //amount = Integer.parseInt(args[0]); } catch (NumberFormatException e) {

System.out.println("El (Monto de dinero) debe ser un numero entero valido"); System.exit(1); } if (amount < 1 || amount >= CambioMinimoFuncionAptitud.MAX_MONTO) { System.out.println("El monto de dinero debe estar entre 1 y "+ (CambioMinimoFuncionAptitud.MAX_MONTO - 1)+ "."); } else { calcularCambioMinimo(amount); } }

// -------------------------------------------------------------------// Este metodo permite guardar en un xml la ultima poblacion calculada // -------------------------------------------------------------------public static void guardarPoblacion(Genotype Poblacion) throws Exception { DataTreeBuilder builder = DataTreeBuilder.getInstance(); IDataCreators doc2 = builder.representGenotypeAsDocument(Poblacion); // create XML document from generated tree XMLDocumentBuilder docbuilder = new XMLDocumentBuilder(); Document xmlDoc = (Document) docbuilder.buildDocument(doc2); XMLManager.writeFile(xmlDoc, new File("PoblacionCambioMinimo.xml")); } } Este es el cdigo de la siguiente clase de nombre CambioMinimoFuncionAptitud.java package practica1; import org.jgap.*; /** * Funcion de Aptitud para Cambio Minimo * */

public class CambioMinimoFuncionAptitud extends FitnessFunction{ private final int montoObjetivo; // Maximo monto posible 1000 Centimos = 10 Euros public static final int MAX_MONTO = 1000; // Maxima cantidad de monedas posibles. Es igual al Monto maximo en // centimos, ya que si se utilizan monedas de un centimo se llegaria al // monton con la mayor cantidad posible de monedas public static final int MAX_CANT_MONEDAS = MAX_MONTO; // El constructor de la funcion de aptitud debe recibir el monto objetivo // del problema y almacenarlo en un atributo. Si el monto es invalido arroja // una excepcion public CambioMinimoFuncionAptitud(int monto) { if (monto < 1 || monto >= MAX_MONTO) { throw new IllegalArgumentException("El monto debe ser un numero entre 1 y " + MAX_MONTO + " centavos"); } montoObjetivo = monto; } /** * El metodo evaluate es el metodo que se debe sobrecargar para que devuelva * el valor de aptitud asociado al cromosoma que se recibe por parametro. * * * @param cromosoma * El cromosoma a evaluar * * @return El valor de aptitud de ese cromosoma * @author Gabriel Veloso, Ruben Arce */ public double evaluate(IChromosome cromosoma) { // Se debe tener en cuenta el evaluador que se esta usando. El evaluador // estandar le asigna un valor mas apto a los valores mas altos de // aptitud. Tambien hay otros evaluadores que asignan mejor aptitud a // los valores mas bajos. // Es por esto que se chequea si 2 es mas apto que 1. Si esto es asi // entonces el valor mas apto sera el mayor y el menos apto el 0 boolean evaluadorEstandard = cromosoma.getConfiguration().getFitnessEvaluator().isFitter(2, 1); int montoCambioMonedas = montoCambioMoneda(cromosoma); int totalMonedas = getNumeroTotalMonedas(cromosoma);

int diferenciaMonto = Math.abs(montoObjetivo montoCambioMonedas); // El primer paso es asignar la menor aptitud a aquellos cromosomas cuyo // monto no sea el monto objetivo. Es decir una descomposicion en // monedas que no sea del monto ingresado if (evaluadorEstandard) { if (diferenciaMonto != 0) return 0.0d; } else { if (diferenciaMonto != 0) return MAX_CANT_MONEDAS; } // luego se debe asignar mas aptitud a aquellos cromosomas que posean // menor cantidad de monedas. if (evaluadorEstandard) { // Se debe asegurar devolver un valor de aptitud positivo siempre. // Si el valor es negativo se devuelve MAX_CANT_MONEDAS ( elemento // menos apto ) return Math.max(0.0d, MAX_CANT_MONEDAS totalMonedas); } else { // Se debe asgurar devolver un valor de aptitud positivo siempre. // Si el valor es negativo se devuelve 0 ( elemento menos apto ) return Math.max(0.0d, totalMonedas); } } /** * Calcula el monto total que suman todas las monedas de un cromosoma * * * @param cromosoma * El cromosoma a evaluar * @return Retorna el monto en centimos compuesto por la suma de las monedas * de ese cromosoma * * @author Gabriel Veloso, Ruben Arce * */ public static int montoCambioMoneda(IChromosome cromosoma) { int Moneda1Dolar = getNumeroDeComendasDeGen(cromosoma, 0);

int Moneda50Centavos = getNumeroDeComendasDeGen(cromosoma, 1); int Moneda25Centavos = getNumeroDeComendasDeGen(cromosoma, 2); int Moneda10Centavos = getNumeroDeComendasDeGen(cromosoma, 3); int Moneda5Centavos = getNumeroDeComendasDeGen(cromosoma, 4); int Moneda1Centavo = getNumeroDeComendasDeGen(cromosoma, 5); return ((Moneda1Dolar * 100) + (Moneda50Centavos * 50) + (Moneda25Centavos * 25) + (Moneda10Centavos * 10) + (Moneda5Centavos * 5) + Moneda1Centavo); } /** * Calcula la cantidad de monedas de determinado tipo (gen) de un cromosoma * Ejemplo. Cantidad de monedas de 20 centimos de es cromosoma * * @param cromosoma * El cromosoma a evaluar * @param numeroGen * El numero gen (tipo de moneda) de que se desea averiguar la * cantidad * @return Devuelve la cantidad de monedas de ese tipo de ese cromosoma * * g */ public static int getNumeroDeComendasDeGen(IChromosome cromosoma,int numeroGen) { Integer numMonedas = (Integer) cromosoma.getGene(numeroGen).getAllele(); return numMonedas.intValue(); } /** * Calcula el total de monedas que tiene esa solucion. Este valor se utiliza * para calcular la aptitud del cromosoma ya que el objetivo es minimizar la * cantidad de monedas de la solucion * * * @param cromosoma * El cromosoma a evaluar * @return El total de monedas que tiene esa solucion

* */ public static int getNumeroTotalMonedas(IChromosome cromosoma) { int totalMonedas = 0; int numberOfGenes = cromosoma.size(); for (int i = 0; i < numberOfGenes; i++) { totalMonedas += getNumeroDeComendasDeGen(cromosoma, i); } return totalMonedas; } }

6. Implementacin de ejemplo Funcion Aptitud La clase que implementar la funcin aptitud debe heredar de Fitness Function y redefinir el mtodo: Public doubl evaluate(IChromosomecromosoma) Este mtodo le permite al framework determinar que cromosoma es ms apto que otro. El valor devuelto debe ser un doubl positivo. Por defecto, se entiende que un valor ms alto devuelto corresponde a un crosoma ms apto pero este no puede ser as, depende del evaluador que se haya utilizado.

7. ANEXO II: Licencia JGAP es software libre, puede redistribuirlo y / o modificarlo bajo los trminos de la GNU Public License publicada por la Free Software Foundation, ya sea la versin 2.1 de la Licencia, o (a su eleccin) cualquier versin posterior. En su lugar, podra optar por utilizar la Licencia Pblica de Mozilla para el uso en aplicaciones comerciales JGAP sin la necesidad de publicar el cdigo fuente o que sea contrario ingeniosa (como es necesaria con la licencia GNU). Para el uso de la MPL tiene que donar al menos 20 De euros para JGAP. Tal vez le gustara a la informacin sobre el uso el navegador ms JGAP comercialmente.