Está en la página 1de 23

TEMA: ALGORITMOS GENTICOS JGPA

MODULO IX B AUTOR:

Germn David Salas Paucar

LOJA ECUADOR

ndice
Introduccin ............................................................................................................................... 3 Instalacin y configuracin del entorno ..................................................................................... 4

Descarga e instalacin de la maquina virtual de java ........................................................ 4 Descarga e instalacin de Netbeans desarrollo en java .................................................... 4 Descarga e instalacin de JGAP ....................................................................................... 5 Agregar las libreras a una aplicacin ...............................................................................5-6

Introduccin a los algoritmos genticos7


Mtodos de Seleccin ...............................................................................................................7

Rueda de ruleta ..................................................................................................................7 Seleccin por torneo .......................................................................................................... 7 Basado en el rango ............................................................................................................8 Mtodo Estocstico ............................................................................................................8
Mtodos de Reproduccin .........................................................................................................8

Cruza Simple .......................................................................................................................8 Cruza de dos puntos ...........................................................................................................8 Cruza Multipunto .................................................................................................................8 Cruza binomial ....................................................................................................................9 Mutacin .............................................................................................................................9
Ejemplo de aplicacin: ............................................................................................................. 10 Implementacin de ejemplo ..................................................................................................... 11

Funcin Aptitud ................................................................................................................. 13


ANEXO I: Cdigo fuente Cambio Mnimo ................................................................................ 14 ANEXO II: Ejemplo de Ejecuciones y Resultados ................................................................... 21

Para 300 centavos ........................................................................................................... 21 Para 471 Centavos ........................................................................................................... 21 Para 275 Centavos ........................................................................................................21-22
ANEXO III: Licencia ................................................................................................................. 23 Bibliografa.23

INTRODUCCIN JGAP es un framework libre (ver anexo licencia para mas informacin) basado en la tecnologa JAVA. El mismo provee mecanismos para aplicar principios evolutivos en la resolucin de problemas. Al momento de escribir este documento la ltima versin estable de este framework es la 3.4.3 Nuestro trabajo se focaliza en probar este framework y realizar un manual detallado con ejemplos didcticos que permitan aprender a utilizarlo haciendo mas leve su curva de aprendizaje. Incluiremos srceen shots para hacer esta tarea mas simple.

INSTALACIN Y CONFIGURACIN DEL ENTORNO 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 descargar el NetBeans es necesario disponer de la mquina virtual de java para poder compilar las aplicaciones. Esto lo hace automticamente el eclipse pero debe tenerse instalada previamente. Se puede obtener en este sitio o en el cd. http://java.sun.com/javase/downloads/index.jsp

Descarga e instalacin de NetBeans para desarrollo en java Se puede descargar la ltima versin de NetBeans de Internet del sitio: http://www.oracle.com/technetwork/java/javase/downloads/jdk-netbeans-jsp-142931.html Como se muestra en la siguiente imagen.

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

Agregar las libreras a una aplicacin Una vez instalado NetBeans y descomprimido el framework en c:\jgap\jgapfull procedemos a crear un proyecto en el netbeans. Abrimos NetBeans y creamos un nuevo proyecto java: Para esto hacemos click en file new Project y se nos muestra la siguiente ventana.

Damos click en next y nos aparece la siguiente ventana

Ahor a

debemos configurar el Build Path para incluir las libreras de jgap. Hacemos clic derecho en el proyecto Seleccionando Set Configuratin -> Customize

Seleccionamos libraries y damos click en Add JAR/Folder

Se muestra la siguiente ventana y en esta buscamos en c:\jgap\jgap_full la librera jgap.jar y le damos click a abrir

INTRODUCCIN A LOS ALGORITMOS GENTICOS Los algoritmos genticos buscan imitar los procesos evolutivos de la naturaleza para resolver problemas. En la naturaleza los individuos de una poblacin se reproducen entre si y de esta forma nacen nuevos individuos. Todos se someten a una seleccin natural durante sus vidas en la que los ms aptos tienen ms probabilidades de sobrevivir, de esta forma las poblaciones evolucionan, mejoran constantemente y se adaptan a los nuevos medios. 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. En la naturaleza algunas veces sucede un fenmeno llamado mutacin. Este es un pequeo cambio en la informacin gentica producido espordicamente, que provoca un cambio en un individuo. Este cambio asegura ms variedad y provoca cambios positivos o negativos. Los cambios negativos deberan quedar en el olvido gracias a la seleccin natural y los positivos perdurar haciendo evolucionar a la poblacin. Para los algoritmos tambin se puede utilizar mutacin para agregar variedad y obtener mejores soluciones. 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 cundo 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 ms 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. Hay algunas otras variantes como por ejemplo, incluir en la nueva generacin el mejor representante de la generacin actual. En este caso se denomina mtodo elitista.

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 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. YYX|YYXXY YYX | XYYYX XYX | XYYYX XYX | YYXXY 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 X | YXX | Y | YY | X X | YXY | Y | XX | X
Y | YXY | Y | XX | Y Y | YXX | Y | YY | Y

Cruza binomial 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. Dadas dos estructuras de longitud 1 = 8, con n = 4 puntos de cruza. Intercambiando los segmentos de la posicin 2 a 4 y 6 a 7, se tiene: 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. En este caso se puede construir un nico hijo por cada aplicacin del operador, o bien generar un segundo hijo como complemento del primero. Cuando existe igual probabilidad de heredar del padre como de la madre, P0 = 0,5 la cruza se denomina uniforme. Para estructuras de longitud l la cruza uniforme implica un promedio de l/2 puntos de cruza. 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). Una vez establecida la frecuencia de mutacin, por ejemplo, uno por mil, se examina cada bit de cada cadena. Si un nmero generado aleatoriamente est por debajo de esa probabilidad, se cambiar el bit (es decir, de 0 a 1 o de 1 a 0). Si no, se dejar como est. Dependiendo del nmero de individuos que haya y del nmero de bits por individuo, puede resultar que las mutaciones sean extremadamente raras en una sola generacin. No hace falta decir que no conviene abusar de la mutacin. Es cierto que es un mecanismo generador de diversidad, y, por tanto, la solucin cuando un algoritmo gentico est estancado, pero tambin es cierto que reduce el algoritmo gentico a una bsqueda aleatoria. Siempre es ms conveniente usar otros mecanismos de generacin de diversidad, como aumentar el tamao de la poblacin, o garantizar la aleatoriedad de la poblacin inicial.

EJEMPLO DE APLICACIN: Para poder entender cmo funciona el framework y poder manejarlo, un ejemplo de aplicacin simple es lo indicado. Supongamos que es necesario descomponer un cierto monto de dinero en la menor cantidad posible de monedas. Por ejemplo si se tienen 1.45dlares (145 centavos) puede descomponerse de la siguiente forma: 1 Moneda de un dlar 1 Moneda de 25 centavos 2 Moneda de 10 centavos 4 monedas en total Pero tambin puede descomponerse de la siguiente forma: 29 Monedas de 5 centavos. 29 monedas en total. Hay muchas formas de descomponer este monto en monedas cada una de ellas es una solucin posible al problema (cromosoma) y tiene un valor de aptitud asociado, que deber depender de la cantidad de monedas totales de ese cromosoma. Cuantas menos monedas se necesiten ms apta ser la solucin ya que lo que se busca es lograr la menor cantidad de monedas posibles. Cada cromosoma tendr 6 genes. Los genes en este problema son nmeros enteros que representan la cantidad de monedas de cada tipo Moneda de un dlar (100 centavos) Moneda de 50 centavos Moneda de 25 centavos Moneda de 10 centavos Moneda de 5 centavos Moneda de 1 centavo

IMPLEMENTACIN DE EJEMPLO Para poder implementar una solucin a este problema utilizando jgap es necesario indicarle al framework una serie de parmetros y codificar la funcin de aptitud. Para este caso la clase principal se llamar CambioMinimo y la funcin aptitud se codificar en la clase CambioMinimoFuncionAptitud. En primer lugar se debe modelar el problema, es decir definir como se compone cada gen de los cromosomas (soluciones posibles). Para este problema puntual cada gen ser un nmero entero y representar la cantidad de un tipo de moneda de ese cromosoma. Por lo tanto cada cromosoma tendr 6 genes Ejemplo: Cantidad de Monedas de 1 dlar Cantidad de Monedas de 50 centavos Cantidad de Monedas de 25 centavos Cantidad de Monedas de 10 centavos Cantidad de Monedas de 5 centavos Cantidad de Monedas de 1 centavo 3 0 1 2 0 2

Este cromosoma sumara 347 centavos en 8 monedas. Una vez definido el modelo se puede comenzar a codificar la solucin. A continuacin se explica a grandes rasgos como se implement el ejemplo de aplicacin y que clases y funciones principales se utilizaron. Pero para ms detalle se encuentra el anexo con el cdigo fuete explicado instruccin por instruccin.

Primero se debe crear una configuracin con valores predeterminados que luego se irn modificando. Configuration conf = new DefaultConfiguration(); Luego se le indica que el mejor elemento siempre pase a la prxima generacin conf.setPreservFittestIndividual(true); // Se indica en la configuracin que el elemento ms apto siempre pase a la prxima generacin

Se crea la funcin de aptitud que ms adelante se explicar y se setea en la configuracin // Se Crea la funcion de aptitud y se setea en la configuracin // --------------------------------------------------------FitnessFunction myFunc = new CambioMinimoFuncionAptitud(Monto);

conf.setFitnessFunction(myFunc); Tambin se debe crear un cromosoma de ejemplo para que el framework conozca su estructura // 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 dlar sampleGenes[1] = new IntegerGene(conf, 0, 10); // Moneda 50 centavos 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);

Es importante tener en cuenta los valores mximos y mnimos ya que si se cargan mal, podra eliminar muchas soluciones que tal vez sean las mejores o si son muy amplios costara ms tiempo de procesamiento llegar a soluciones ptimas. Se puede configurar el tamao que tendr la poblacin (Cantidad de cromosomas de una generacin) conf.setPopulationSize(200); Para poder evolucionar se necesita una poblacin inicial. El framework permite cargarla de un xml pero lo mejor en este caso es indicarle que genere una poblacin inicial aleatoria. Poblacion = Genotype.randomInitialGenotype(conf); El mtodo envolve evoluciona una generacin. Se lo llama una cierta cantidad de veces con un loop para que realice cierta cantidad de evoluciones. Pobl acion.evolve(); El mtodo guardar poblacin creado para este manual guarda todos los datos de la poblacin en un xml llamado PoblacionCaminoMinimo.xml para demostrar como Trabaja el Framework con las poblaciones y los xml. Para ms detalle ver el cdigo fuente del anexo. guardarPoblacion(Poblacion); De esta forma se obtiene el cromosoma ms apto de la poblacin. IChromosome cromosomaMasApto = Poblacion.getFittestChromosome(); Funcin Aptitud La clase que implementar la funcin aptitud debe heredar de FitnessFunction y redefinir el mtodo public double evaluate(IChromosome cromosoma) Este mtodo le permite al framework determinar que cromosoma es ms apto que otro. El valor devuelto debe ser un double positivo. Por defecto, se entiende que un valor ms alto devuelto corresponde a un cromosoma ms apto pero esto puede no ser as, depende del evaluador que se haya utilizado. En el ejemplo se tiene en cuenta esto antes de devolver el valor de aptitud.

ANEXO I: CDIGO FUENTE CAMBIO MNIMO

package practica1; /** * * @compilado PC */ 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 * 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 * @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 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, Math.round(CambioMinimoFuncionAptitud.MAX_MONTO/100)); // Moneda 1 dolar sampleGenes[1] = new IntegerGene(conf, 0, 10); // Moneda 50 centavos 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

0,

// --------------------------------------------------------------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(cromosomaMasApto, 0) + " Moneda 1 Dolar"); System.out.println("\t" + CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasApto, 1) + " Moneda 50 centavos"); System.out.println("\t" + CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasApto, 2) + " Moneda 25 centavos"); System.out.println("\t" + CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasApto, 3) + " Moneda 10 centavos"); System.out.println("\t" + CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasApto, 4) + " Moneda 5 centavos"); System.out.println("\t" + CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasApto, 5) + " Moneda 1 centavos"); 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 * @author Ruben Arce * @since 1.0 */ public static void main(String[] args) throws Exception { int amount = 347; 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")); } } package practica1; /** * * @compilado PC */ 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 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 Moneda2Euro = getNumeroDeComendasDeGen(cromosoma, 0); 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 Moneda2centavos = getNumeroDeComendasDeGen(cromosoma, 6); int Moneda1centavos = getNumeroDeComendasDeGen(cromosoma, 5); return ((Moneda1Dolar * 100) + (Moneda50centavos * 50) + (Moneda25centavos * 25) +(Moneda10centavos * 10) + (Moneda5centavos * 5) + Moneda1centavos); } /** * 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 * 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; } }

ANEXO II: EJEMPLO DE EJECUCIONES Y RESULTADOS Para 300 centavos Tiempo total de evolucion: 18005 ms El cromosoma mas apto encontrado tiene un valor de aptitud de: 993.0 Y esta formado por la siguiente distribucion de monedas: 2 Moneda 1 Dolar 1 Moneda 50 centavos 1 Moneda 25 centavos 2 Moneda 10 centavos 1 Moneda 5 centavos 0 Moneda 1 centavos Para un total de 300 centavos en 7 monedas. Para 471 centavos Tiempo total de evolucion: 18403 ms El cromosoma mas apto encontrado tiene un valor de aptitud de: 992.0 Y esta formado por la siguiente distribucion de monedas: 4 Moneda 1 Dolar 1 Moneda 50 centavos 0 Moneda 25 centavos 2 Moneda 10 centavos 0 Moneda 5 centavos 1 Moneda 1 centavos Para un total de 471 centavos en 8 monedas. Para 275 centavos Tiempo total de evolucion: 15107 ms El cromosoma mas apto encontrado tiene un valor de aptitud de: 996.0 Y esta formado por la siguiente distribucion de monedas: 2 Moneda 1 Dolar 1 Moneda 50 centavos 1 Moneda 25 centavos

0 Moneda 10 centavos 0 Moneda 5 centavos 0 Moneda 1 centavos Para un total de 275 centavos en 4 monedas.

ANEXO III: LICENCIA Este fragmento esta publicado en la pgina principal de JGAP donde explica que es un software libre. Pero si se quiere utilizar de forma comercial es necesario donar al menos 20 euros a JGAP. JGAP is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. Inste|ad, you could choose to use the Mozilla Public License to use JGAP in commercial applications without the need of publishing your source code or make it reverse engineerable (as is required with the GNU License). For using the MPL you have to donate at least 20 Euros to JGAP. Maybe you would like to browser further information about using JGAP commercially. JGAP is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above mentioned GNU Lesser Public License and the Mozilla Public License for more details. But we offer really a lot of unit tests which help assure a very high probability for a correct piece of software! Bibliografa: VELOSO, Gabriel Alejandro. ARCE, Rubn, Algoritmos Genticos JGAP. http://eqaula.org/eva/mod/resource/view.php?inpopup=true&id=9541 [disponible en lnea]. 2009.

También podría gustarte