Jgap

rea de Energa, Industrias y Recursos Naturales No
Renovables
INGENIERA EN SISTEMAS
Algoritmos Genticos
JGAP
POR:
Angel Alberto Valdez Masache
DOCENTE:
Luis Antonio Chamba Eras
LOJA -
2012
ECUADOR
ndice
Introduccin
Instalacin y configuracin del entorno 4
Descarga e instalacin de la maquina virtual de java 4
Descarga e instalacin de Netbeans desarrollo en java
Descarga e instalacin de JGAP
Agregar las libreras a una aplicacin 5
Mtodos de Seleccin 10
Rueda de ruleta
10
Seleccin por torneo
11
Basado en el rango
11
Mtodo Estocstico
11
Mtodos de Reproduccin
Cruza Simple 12
Cruza de dos puntos
12
Cruza Multipunto
12
Cruza binomial 12
Mutacin
13
Ejemplo de aplicacin: 15
12
Implementacin de ejemplo
Funcin Aptitud
16
19
ANEXO I: Cdigo fuente Cambio Mnimo
ANEXO II: Ejemplo de Ejecuciones y Resultados
Para 90 centavos
29
Para 125 Centavos
29
Para 87 Centavos
29
ANEXO III: Licencia
30
20
29
Bibliografa31
INTRODUCCIN
JGAP es un framework libre 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.5
Nuestro 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.
Descarga e instalacin de la mquina virtual de java
Antes de descargar el Eclipse 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 bajar 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.
Una vez descargado el instalador, se ejecuta e instala con normalidad.
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 la 3.5.
http://sourceforge.net/projects/jgap/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 debemos

crear 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.
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 Configuratin ->
Customize
Luego se debe seleccionar el item Libraries y hacer clic en Add JAR/Folder
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.
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.
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 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,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.
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 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

2
Cantidad de Monedas de 50 centavos

1

0

0
Cantidad 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 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.
// 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.setPreservFittestIndividual(true);
Se crea la funcin de aptitud que ms adelante se explicar y se setea en la

configuracin
// 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[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 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;
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 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, 0,

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

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

= new IntegerGene(conf, 0, 10); // Moneda 1 centavo 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(cromosomaMasApto, 0) + "
Moneda 1 dolar");
Moneda 50 centavos");
Moneda 1 centavo");
System.out.println("Para un total de "+

CambioMinimoFuncionAptitud.montoCambioMoneda(cromosomaMasApto) + " centimos
en " + CambioMinimoFuncionAptitud.getNumeroTotalMonedas(cromosomaMasApto) + "
monedas.");
/**
Mtodo principal: Recibe el monto en dinero por parmetro para determinar
la cantidad minima de monedas necesarias para formarlo
@param args
Monto de dinero
@throws Exception
@author Ruben Arce
@since 1.0
*/
public static void main(String[] args) throws Exception { int amount = 353;
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;
import org.jgap.*;
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
+ " centimos");
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
@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 Moneda50Centimos = getNumeroDeComendasDeGen(cromosoma, 1);

int Moneda5Centimos = getNumeroDeComendasDeGen(cromosoma, 4); int

Moneda1Centimo = getNumeroDeComendasDeGen(cromosoma, 5);
return (Moneda1Dolar * 100) + (Moneda50Centimos * 50) + (Moneda25Centimos * 25) +

(Moneda10Centimos * 10) + (Moneda5Centimos * 5) + Moneda1Centimo;
/**
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();
/**
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
@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;
ANEXO II: EJEMPLO DE EJECUCIONES Y RESULTADOS
Para 353 centavos
Tiempo total de evolucin: 12265 ms
El cromosoma ms apto encontrado tiene un valor de aptitud

de: 993.0 Y est formado por la siguiente distribucin de
monedas:
3 Moneda 1 dlar
1 Moneda 50 centavos
0 Moneda 5 centavos
3 Moneda 1 centavo
Para un total de 353 centavos en 7 monedas.
Para 155 Centavos

monedas:
1 Moneda 1 dlar
1 Moneda 5 centavos
0 Moneda 1 centavo
Para 263 Centavos

monedas:
2 Moneda 1 dlar
1 Moneda 5 centavos
3 Moneda 1 centavo
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. 2009.

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

Jgap

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Jgap

Загружено:

Авторское право:

Доступные форматы

rea de Energa, Industrias y Recursos Naturales No

Angel Alberto Valdez Masache

Luis Antonio Chamba Eras

Instalacin y configuracin del entorno 4

Descarga e instalacin de la maquina virtual de java 4

Descarga e instalacin de Netbeans desarrollo en java

Descarga e instalacin de JGAP

Agregar las libreras a una aplicacin 5

Seleccin por torneo

Cruza de dos puntos

ANEXO I: Cdigo fuente Cambio Mnimo

ANEXO II: Ejemplo de Ejecuciones y Resultados

Para 125 Centavos

ANEXO III: Licencia

JGAP es un framework libre basado en la tecnologa JAVA. El mismo provee

Nuestro trabajo se focaliza en probar este framework y realizar un manual

INSTALACIN Y CONFIGURACIN DEL ENTORNO

En primer lugar debe disponerse de una herramienta de desarrollo de aplicaciones java.

Descarga e instalacin de la mquina virtual de java

Antes de descargar el Eclipse es necesario disponer de la mquina virtual de java para

Descarga e instalacin de Netbeans para desarrollo en java

Se puede bajar la ltima versin de Netbeans de Internet del sitio:

Como se muestra en la siguiente imagen.

Una vez descargado el instalador, se ejecuta e instala con normalidad.

Descarga e instalacin de JGAP

En este archivo se encuentran las libreras y algunos ejemplos de aplicacin compilados,

Agregar las libreras a una aplicacin

Una vez instalado netbeans y descomprimido el framework en c:\jgap\jgapfull debemos

Entramos al netbeans y creamos un nuevo proyecto java:

Para esto hacemos click derecho como se muestra en la imagen.

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

Luego se debe seleccionar el item Libraries y hacer clic en Add JAR/Folder

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

INTRODUCCIN A LOS ALGORITMOS GENTICOS

Los algoritmos genticos buscan imitar los procesos evolutivos de la

Para los algoritmos genticos los individuos se denominan cromosomas.

Antes de comenzar, es necesario tener una poblacin inicial. Lo que suele

En la naturaleza algunas veces sucede un fenmeno llamado mutacin.

poblacin. Para los algoritmos tambin se puede utilizar mutacin para

Para llegar a buenos resultados es necesario recorrer varias generaciones.

A continuacin se muestran algunas de las tcnicas de seleccin ms

Este mtodo consiste en construir una ruleta particionada en ranuras de

El proceso se repite hasta completar la cantidad de individuos deseados.

Hay algunas otras variantes como por ejemplo, incluir en la nueva

Seleccin por torneo

En este caso dos individuos son elegidos al azar de la poblacin actual y el

En este esquema se mantiene un porcentaje de la poblacin,

Por cada individuo se calcula la aptitud relativa al promedio de aptitudes

A continuacin se muestran algunas tcnicas para reproducir individuos (o

Los dos cromosomas padres se cortan por un punto, y el material gentico

Dada las siguientes estructuras de longitud 1 = 8, y eligiendo 3 como el

Cruza de dos puntos

En este mtodo de cruza de dos puntos, se seleccionan dos puntos

El cromosoma es considerado un anillo, y se eligen n puntos de cruza en

cromosomas definidas entre cada par de puntos consecutivos, si es impar

Para generar un cromosoma hijo por cruza binomial, se define la

Cuando existe igual probabilidad de heredar del padre como de la madre,

En la Evolucin, una mutacin es un suceso bastante poco comn (sucede

No hace falta decir que no conviene abusar de la mutacin. Es cierto que

gentico est estancado, pero tambin es cierto que reduce el algoritmo

Para poder entender cmo funciona el framework y poder manejarlo, un

Supongamos que es necesario descomponer un cierto monto de dinero en

Pero tambin puede descomponerse de la siguiente forma: