Algoritmos GenticosTrabajo FinalMariana Gonzlez Mariana 08/07/2011

ndice Introduccin.....................................................................................................................2 Instalacin y configuracin del entorno...........................................................................3 Agregar las libreras a una aplicacin.............................................................................5 Mtodos de Seleccin.....................................................................................................6 Rueda de ruleta...............................................................................................................6 Seleccin por torneo.......................................................................................................6 Basado en el rango.........................................................................................................6 Mtodo Estocstico.........................................................................................................7 Mtodos de Reproduccin........................................................................................... .7 Cruza Simple................................................................................................................ 7 Cruza de dos puntos.................................................................................................... 7 Cruza Multipunto.......................................................................................................... 7 Cruza binomial............................................................................................................. 7 Mutacin..................................................................................................................... .7 ANEXO I: Cdigo fuente Cambio Mnimo......................................................................8 ANEXO II: Ejemplo de Ejecuciones y Resultados........................................................21

1

INTRODUCCIN

JGAP es un FRAME escrito en Java el mismo provee mecanismos para aplicar principios evolutivos en la resolucin de problemas.

El presente trabajo est realizado en la versin 3.5 adaptado al IDE Netbeans 6.9.1 al final se anexa un ejemplo con una versin del cdigo proporcionado, para que se adapte al sistema monetario de ecuador ya que la versin original est en pesos y la variacin que se proporcion esta en euros a continuacin se detallan los instaladores. jgap_3.5_full.zip Netbeans 6.9.1

2

INSTALACIN Y CONFIGURACIN DEL ENTORNO

Descarga e instalacin de JGAPSe deben descargar las libreras de JGAP desde el sitio oficial hay un link a la ltima versin. Hasta el da de hoy es la 3.5 http://sourceforge.net/projects/jgap/files/ Se debe tener previamente instalado el IDE Netbeans 6.9.1

Agregar las libreras a una aplicacin Se descomprime el archivo .zip del jgap en un directorio y se procede a realizar lo siguiente: Se crea un nuevo proyecto

3

Se realiza click derecho en libraries, se elige la opcin Add JAR/Folder y se eligen las libreras .jar de la ruta en la que se descomprimi el jgap

Se realiza el mismo procedimiento para aadir el resto de libreras ubicada el lib del jgap

4

5

INTRODUCCIN A LOS ALGORITMOS GENTICOS

Para los algoritmos genticos los individuos se denominan cromosomas. Cada cromosoma es una solucin a un problema especfico. Las caractersticas de un cromosoma se denominan genes. Tambin existe una funcin de aptitud, la cual aplicada a cada cromosoma devuelve un valor que indica cuan apto es y permite compararlos entre ellos. Antes de comenzar, es necesario tener una poblacin inicial. Lo que suele hacerse es crear una poblacin de cromosomas al azar. Una vez que se tiene una poblacin se reproducen los individuos para obtener mayor variedad, tal como en la naturaleza. Luego, es necesario seleccionar los mejores, para ir evolucionando. Hay varios mtodos de seleccin pero en general lo que se busca es que los mejores pasen a la prxima generacin y algunos no tan aptos tambin, ya que la variedad ayuda a que en la reproduccin se generen cromosomas ms aptos aun que sus padres. Puede que de la cruza de un cromosoma muy apto y otro no tanto resulte uno mucho mejor a sus padres. Para llegar a buenos resultados es necesario recorrer varias generaciones. Es decir, reproducir varias veces los individuos y hacer varias selecciones y algunas pocas mutaciones. Tambin es necesario determinar cuando una solucin es suficientemente apta como para aceptarla. Para esto puede medirse cuanto aumenta la aptitud del mejor cromosoma y si despus de varias generaciones no mejora aun introduciendo mutaciones o aumentando el nmero de cromosomas podemos decidir dejar de evolucionar y utilizar esa solucin. Otra tcnica consiste establecer de ante mano cuantas generaciones se van a considerar.

MTODOS DE SELECCIN A continuacin se muestran algunas de las tcnicas de seleccin mas conocidas Rueda de ruleta Este mtodo consiste en construir una ruleta particionada en ranuras de igual tamao, las cuales se numeran. A cada individuo de la poblacin se le asigna una cantidad de ranuras proporcional a su aptitud. El proceso se repite hasta completar la cantidad de individuos deseados. Este mtodo de seleccin otorga mayor probabilidad de contribuir a la siguiente generacin a los individuos con mayor aptitud. Seleccin por torneo En este caso dos individuos son elegidos al azar de la poblacin actual y el mejor o ms apto de los dos se coloca en la generacin siguiente. Esto contina hasta que se complete la nueva poblacin. Basado en el rango En este esquema se mantiene un porcentaje de la poblacin, generalmente la mayora, para la siguiente generacin. Se coloca toda la poblacin por orden de

6

aptitud, y los M menos dignos son eliminados y sustituidos por la descendencia de alguno de los M mejores con algn otro individuo de la poblacin. Mtodo Estocstico Por cada individuo se calcula la aptitud relativa al promedio de aptitudes de la poblacin, y en funcin de esto se asignan las copias. Por ejemplo, si la aptitud promedio de la poblacin es 15 y la aptitud del individuo es 10; entonces su aptitud relativa es 1.5. Esto significa que se colocar una copia en la prxima generacin y que se tiene el 0.5 (50 %) de chance de colocar una segunda copia. MTODOS DE REPRODUCCIN A continuacin se muestran algunas tcnicas para reproducir individuos (o cromosomas). Cruza Simple Los dos cromosomas padres se cortan por un punto, y el material gentico situado entre ellos se intercambia. Dada las siguientes estructuras de longitud 1 = 8, y eligiendo 3 como el punto de cruza se intercambian los segmentos de cromosoma separados por este punto. Cruza de dos puntos En este mtodo de cruza de dos puntos, se seleccionan dos puntos aleatoriamente a lo largo de la longitud de los cromosomas y los dos padres intercambian los segmentos entre estos puntos. Cruza Multipunto El cromosoma es considerado un anillo, y se eligen n puntos de cruza en forma aleatoria. Si la cantidad de puntos de cruza es par, se intercambian las porciones de cromosomas definidas entre cada par de puntos consecutivos, si es impar se asume un punto de cruza adicional en la posicin cero y se procede de igual modo. Cruza binomial Para generar un cromosoma hijo por cruza binomial, se define la probabilidad P0 como la probabilidad de que el Alelo de cualquier posicin del descendiente se herede del padre, y 1 P0 como la probabilidad de que lo herede de la madre. Mutacin En la Evolucin, una mutacin es un suceso bastante poco comn (sucede aproximadamente una de cada mil replicaciones), en la mayora de los casos las mutaciones son letales, pero en promedio, contribuyen a la diversidad gentica de la especie. En un algoritmo gentico tendrn el mismo papel, y la misma frecuencia (es decir, muy baja).

7

ANEXO I: CDIGO FUENTE CAMBIO MNIMO

Este ejemplo fue modificado para dlares:

/* * To change this template, choose Tools | Templates * and open the template in the editor. */

package practica1;

/** * * @compilado luis */

import org.jgap.*;

/** * Funcion de Aptitud para Cambio Minimo * * @author Garbiel Veloso * @author Ruben Arce * @since 1.0 */

public class CambioMinimoFuncionAptitud extends FitnessFunction{ private final int montoObjetivo; // Maximo monto posible 1000 Centimos = 10 Euros

8

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 } montoObjetivo = monto; } + " centimos");

/** * 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

9

// 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);

10

} }

/** * 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 Moneda5dolares = getNumeroDeComendasDeGen(cromosoma, 0); int Moneda1dolar = getNumeroDeComendasDeGen(cromosoma, 1); int Moneda50Centavos = getNumeroDeComendasDeGen(cromosoma, 2); int Moneda25Centavos = getNumeroDeComendasDeGen(cromosoma, 3); int Moneda10Centavos = getNumeroDeComendasDeGen(cromosoma, 4); int Moneda5Centavos = getNumeroDeComendasDeGen(cromosoma, 5); int Moneda1centavo = getNumeroDeComendasDeGen(cromosoma, 6); // int Moneda1Centimo = getNumeroDeComendasDeGen(cromosoma, 7);

return (Moneda5dolares * 500) + (Moneda1dolar * 100) + (Moneda50Centavos * 50) + (Moneda25Centavos * 25) + (Moneda10Centavos * 10)+ (Moneda5Centavos * 5) + (Moneda1centavo * 2) ; }

11

/** * 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 * * * @author Gabriel Veloso, Ruben Arce */

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

12

* El cromosoma a evaluar * @return El total de monedas que tiene esa solucion * * @author Gabriel Veloso, Ruben Arce */

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; } }

13

/* * To change this template, choose Tools | Templates * and open the template in the editor. */

package practica1;

/** * * @compilado luis */

import java.io.File; import org.jgap.Chromosome; import org.jgap.Configuration; import org.jgap.FitnessFunction; import org.jgap.Gene; import org.jgap.Genotype; import org.jgap.IChromosome; import org.jgap.data.DataTreeBuilder; import org.jgap.data.IDataCreators; import org.jgap.impl.DefaultConfiguration; import org.jgap.impl.IntegerGene; import org.jgap.xml.XMLDocumentBuilder; import org.jgap.xml.XMLManager; import org.w3c.dom.Document;

/** * En este ejemplo se muestra como resolver un problema clasico de algoritmos * genticos utilizando el framework JGAP. El problema consiste en lograr juntar

14

* el monto de dinero ingresado a la aplicacion por parametro con la menor * cantidad de monedas posibles. Para resolver el problema nos basamos en la * moneda de la Republica Argentina(Se adapto para trabajarlo en Euros aumentando) * la moneda de 2 euros, cambiando la de 25 por 20 y agregando la de 2 centimos * Moneda de 1 euro ( equivale a 100 centimos) Moneda de 50 Centimos Moneda de 20 Centimos * Moneda de 10 Centimos Moneda de 5 Centimos Moneda de 2 Centimos Moneda de 1 Centimo * * @author Gabriel Veloso * @author Ruben Arce * @since 1.0 */

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 * * @author Gabriel Veloso * @author Ruben Arce

15

* @since 1.0 */ 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 7 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[7]; sampleGenes[0] = new IntegerGene(conf, 0, Math.round(CambioMinimoFuncionAptitud.MAX_MONTO/500)); // Moneda 5 dolares sampleGenes[1] = new IntegerGene(conf, 0, Math.round(CambioMinimoFuncionAptitud.MAX_MONTO/100)); // Moneda 1 dolares sampleGenes[2] = new IntegerGene(conf, 0, 10); // Moneda 50 centavos sampleGenes[3] = new IntegerGene(conf, 0, 10); // Moneda 25 centavos sampleGenes[4] = new IntegerGene(conf, 0, 10); // Moneda 10 centavos sampleGenes[5] = new IntegerGene(conf, 0, 10); // Moneda 5 centavos

16

sampleGenes[6] = new IntegerGene(conf, 0, 10); // Moneda 1 centavos // sampleGenes[7] = new IntegerGene(conf, 0, 10); // Moneda 1 centimo 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: ");

17

System.out.println("\t" + CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasApto, Moneda 5 dolares"); System.out.println("\t" + CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasApto, Moneda 1 dolar"); System.out.println("\t" + CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasApto, Moneda 50 centavos"); System.out.println("\t" + CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasApto, Moneda 25 centavos"); System.out.println("\t" + CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasApto, Moneda 10 centavos"); System.out.println("\t" CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasApto, Moneda 5 centavos"); System.out.println("\t" CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasApto, Moneda 1 centavos"); // System.out.println("\t" + CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasApto, Moneda 1 centimo");

0)

+

"

1)

+

"

2)

+

"

3)

+

"

4)

+

"

5)

+

+ "

6)

+

+ "

7)

+

"

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 * * @author Gabriel Veloso

18

* @author Ruben Arce * @since 1.0 */

public static void main(String[] args) throws Exception { int amount = 423; 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); }

}

19

// --------------------------------------------------------------------// 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")); } }

20

ANEXO II: EJEMPLO DE EJECUCIONES Y RESULTADOS

21

22