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
8/6/2019 Algorirtmos Geneticos
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.jsp8/6/2019 Algorirtmos Geneticos
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.html8/6/2019 Algorirtmos Geneticos
4/29
8/6/2019 Algorirtmos Geneticos
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
8/6/2019 Algorirtmos Geneticos
6/29
Luego se debe seleccionar el tem Libraries y hacer clicen Add JAR
8/6/2019 Algorirtmos Geneticos
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_full8/6/2019 Algorirtmos Geneticos
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
8/6/2019 Algorirtmos Geneticos
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
8/6/2019 Algorirtmos Geneticos
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
8/6/2019 Algorirtmos Geneticos
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.
8/6/2019 Algorirtmos Geneticos
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.
8/6/2019 Algorirtmos Geneticos
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
8/6/2019 Algorirtmos Geneticos
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
8/6/2019 Algorirtmos Geneticos
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
8/6/2019 Algorirtmos Geneticos
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;
8/6/2019 Algorirtmos Geneticos
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;
/**
8/6/2019 Algorirtmos Geneticos
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
* @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).
8/6/2019 Algorirtmos Geneticos
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[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[6] = new IntegerGene(conf, 0, 10); // Moneda 2 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
// ---------------------------------------------------------------
8/6/2019 Algorirtmos Geneticos
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");
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");
8/6/2019 Algorirtmos Geneticos
21/29
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
*/
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) + ".");
8/6/2019 Algorirtmos Geneticos
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.*;
8/6/2019 Algorirtmos Geneticos
23/29
/**
* 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 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;
}
8/6/2019 Algorirtmos Geneticos
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
8/6/2019 Algorirtmos Geneticos
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);
}
}
8/6/2019 Algorirtmos Geneticos
26/29
/**
* 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 Moneda1Centavos =
getNumeroDeComendasDeGen(cromosoma, 5);
8/6/2019 Algorirtmos Geneticos
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
* 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();
}
8/6/2019 Algorirtmos Geneticos
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
*
* @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;
}
}
8/6/2019 Algorirtmos Geneticos
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