algorirtmos geneticos

8/6/2019 Algorirtmos Geneticos

1/29

UNIVERSIDAD NACIONAL DE LOJArea de la Energa, las Industrias y los Recursos Naturales no Renovables

Ingeniera en Sistemas

Tema:

ALGORITMOS GENETICOS

Alumno:

Lenin Gordillo

Docente: Ing. Luis Chamba

Fecha:08 de julio de 2011

LOJA - ECUADOR2011


2/29

INTRODUCCIN

JGAP es un framework libre basado en la tecnologa JAVA. El mismo proveemecanismos 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.5

Este trabajo se focaliza en probar este framework y realizar un manual detallado con

ejemplos didcticos que permitan aprender a utilizarlo haciendo ms 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 para sucorrecto funcionamiento.

Descarga e instalacin de la mquina virtual de java

Para poder descargar y utilizar esta herramienta ingresamos al siguiente sitio web dondeencontramos lamas reciente versin del mismo.

http://java.sun.com/javase/downloads/index.jsp

Descarga e instalacin de Netbeans para desarrollo en java
http://java.sun.com/javase/downloads/index.jsphttp://java.sun.com/javase/downloads/index.jsp


3/29

Se puede bajar la ltima versin de Netbeans de Internet del sitio:http://www.oracle.com/technetwork/iava/javase/downloads/jdk-netbeans-isp-142931.html

Descarga e instalacin de JGAP

Se deben descargar las libreras de JGAP desde el sitio oficial hay un link a la ltimaversin. Hasta el da de hoy es la 3.5.

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

En este archivo se encuentran las libreras y algunos ejemplos de aplicacin compilados,el archivo jgap_3.5_full.zip contiene todos los cdigos fuentes. Descomprimir el archivo

jgap_3.5_full.zip en c:\jgap\jgapfull

Agregar las libreras a una aplicacin

Una vez instalado netbeans y descomprimido el framework en c:\jgap\jgapfull debemoscrear un proyecto en el netbeans.

Entramos al netbeans y creamos un nuevo proyecto java:Para esto hacemos click derecho como se muestra en la imagen.
http://www.oracle.com/technetwork/java/javase/downloads/jdk-netbeans-jsp-142931.htmlhttp://www.oracle.com/technetwork/java/javase/downloads/jdk-netbeans-jsp-142931.htmlhttp://sourceforge.net/projects/jgap/files/jgap/http://c/jgap/jgapfullhttp://c/jgap/jgapfullhttp://c/jgap/jgapfullhttp://c/jgap/jgapfullhttp://sourceforge.net/projects/jgap/files/jgap/http://www.oracle.com/technetwork/java/javase/downloads/jdk-netbeans-jsp-142931.htmlhttp://www.oracle.com/technetwork/java/javase/downloads/jdk-netbeans-jsp-142931.html


4/29


5/29

Escribimos el nombre del proyecto y hacemos clic en Finish y crea automticamente un

proyecto nuevo.

Una vez creado el proyecto se debe configurar el Build Path para incluir las libreras de jgap. Haciendo clic derecho en el proyecto y seleccionando Set Configuration ->

Customize


6/29

Luego se debe seleccionar el tem Libraries y hacer clicen Add JAR


7/29

Buscar en c:\jgap\jgap_3.5_full el jgap.jar y hacer click en Abrir

Una vez realizado esto ya se puede utilizar las libreras desde una clase java de ese

proyecto.

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.
http://c/jgap/jgap_3.5_fullhttp://c/jgap/jgap_3.5_full


8/29

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


9/29

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 msapto 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 Mmenos 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 lapoblacin es 15 y la aptitud del individuo es 10; entonces su aptitud relativa es 1.5. Esto


10/29

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.

XYX | XYYYX YYX|YYXXY

XYX | YYXXY YYX | XYYYX

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 Y | YXY | Y | XX | Y

X | YXY | Y | XX | X Y | YXX | Y | YY | Y

Cruza binomial


11/29

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.


12/29

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,35 dlares (135 centavos) puede

descomponerse de la siguiente forma:

1 Moneda de un dlar

1 Moneda de 25 centavos

1 Moneda de 10 centavos

3 monedas en total

Pero tambin puede descomponerse de la siguiente forma: 27

Monedas de 5 centavos. 27 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.


13/29

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

IMPLEMENTACION 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 2Cantidad de Monedas de 50 centavos 1Cantidad de Monedas de 25 centavos 1Cantidad de Monedas de 10 centavos 0Cantidad de Monedas de 5 centavos 0Cantidad de Monedas de 1 centavo 0

Este cromosoma sumara 275 centavos en 4 monedas.

Una vez definido el modelo se puede comenzar a codificar la solucin.

A continuacin se explica a grandes rasgos como se implemento 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


14/29

irn modificando.

// Se crea una configuracin con valores predeterminados.

//Configuration conf = new DefaultConfiguration();

Luego se le indica que el mejor elemento siempre pase a la prxima generacin

// Se indica en la configuracin que el elemento ms apto siempre pase // a

// la prxima generacin //

conf.setPreservFittestlndividual(true);

Se crea la funcin de aptitud que ms adelante se explicar y se setea en laconfiguracin:

// Se Crea la funcin 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 cromosoma: // en

// este caso tendran 6 genes (uno para cada tipo de moneda) con un // valor

// entero (candiad 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_M0WT0/100));// Moneda 1 dolar

sampleGenes[1] = new IntegerGene(conf, 0, 10);//Moneda 50 centavos

sampleGenes[2] = new IntegerGene(conf, 0, 10);//Moneda 25centavos

sampleGenes[3] = new IntegerGene(conf, 0, 10);//Moneda 10 centavos


15/29

sampleGenes[4] = new IntegerGene(conf, 0, 10);//Moneda 5centavos

sampleGenes[5] = new IntegerGene(conf, 0, 10);//Moneda 1 centavo

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 unageneracin)

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.randomlnitialGenotype(conf);

El mtodo envolve evoluciona una generacin. Se lo llama una cierta cantidad de vecescon 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


16/29

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 MINIMO

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;


17/29

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 el sistema

* monetario de Ecuador

* La moneda de 1 dolar ( equivale a 100 centavos) Moneda de 50 Centavos, Moneda de

25 Centavos,

* Moneda de 10 Centavos, Moneda de 5 Centavos, Moneda de 1 Centavo.

*

* @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;

/**


18/29

* 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


* @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).


19/29

// 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/200)); // Moneda 2 euro

sampleGenes[0] = new IntegerGene(conf, 0,

Math.round(CambioMinimoFuncionAptitud.MAX_MONTO / 100)); // Moneda 1 dolar

sampleGenes[1] = new IntegerGene(conf, 0, 10); // Moneda 50 centavos




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

// ---------------------------------------------------------------


20/29

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



+ " Moneda 50 centavos");








21/29







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

*/

public static void main(String[] args) throws Exception {

int amount = 323;

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) + ".");


22/29

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

}

}

ANEXO II: EJEMPLO DE EJECUCIONES Y RESULTADOS

package practica1;

/**

*

* @compilado luis

*/

import org.jgap.*;


23/29

/**

* Funcion de Aptitud para Cambio Minimo

*

* @author Garbiel Veloso


* @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 monedaspublic 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;

}


24/29

/**

* 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


25/29

// 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 positivosiempre.

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

}

}


26/29

/**

* Calcula el monto total que suman todas las monedas de un

cromosoma

*

*

* @param cromosoma


* @return Retorna el monto en centimos compuesto por la suma de las

monedas* de ese cromosoma

*


*

*/

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








27/29

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


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

*

*


*/

public static int getNumeroDeComendasDeGen(IChromosome

cromosoma, int numeroGen) {

Integer numMonedas = (Integer)

cromosoma.getGene(numeroGen).getAllele();

return numMonedas.intValue();

}


28/29

/**

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

}

}


29/29

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 helpassure a very high probability for a correct piece of software!

Bibliografa:

VELOSO, Gabriel Alejandro. ARCE, Rubn, Algoritmos Genticos JGAP. 2009.

http://eqaula.org/eva/mod/resource/view.php?inpopup=true&id=9541 [disponible en

lnea].
http://jgap.sourceforge.net/commercialUsage.htmlhttp://eqaula.org/eva/mod/resource/view.php?inpopup=true&id=9541http://eqaula.org/eva/mod/resource/view.php?inpopup=true&id=9541http://jgap.sourceforge.net/commercialUsage.html

algorirtmos geneticos

Documents