You are on page 1of 19

Prctica de Algoritmos Genticos

ndice de contenido
Informacin previa:...................................................................................................................................1 Problema volumen.....................................................................................................................................2 Problema Sphere........................................................................................................................................3 Problema: Funcion (X > 0) OR (X == -8) OR (X == - 5)......................................................................15 Problema: aprender Hello word...........................................................................................................18

Informacin previa:
LOS ALGORITMOS GENETICOS. Los algoritmos genticos se basan en la teora de la evolucin de Charles Darwin. Se tiene una poblacin, donde cada individuo posee diferentes caractersticas. Esas caractersticas se muestran favorables o no frente a un mtodo de seleccin al que se enfrentan todos los individuos. As se van identificando los que poseen las mejores caractersticas. Las caractersticas de los individuos estn dadas por sus cromosomas. Un cromosoma es un conjunto de genes. Cada gen es responsable de indicar el tipo de una sola caracterstica del individuo. El valor que toma el gen se llama alelo.

En la biologa, los individuos mejor adaptados al medio donde se encuentran son los que sobreviven. De esa forma se reproducen, dando lugar a una descendencia que hereda sus caractersticas ventajosas. Tambin se dan variaciones en los genes por medio de la combinacin (reproduccin sexual) o por cambios aleatorios(mutaciones). As surgen de forma natural ms caractersticas que a su vez son puestas a prueba y permiten a sus portadores sobrevivir y reproducirse si son las ms adecuadas para el ambiente que les rodea. Los algoritmos genticos son una analoga de lo que ocurre biolgicamente, pero aplicada a encontrar la mejor solucin a un problema. Cada solucin es un individuo. El mtodo de seleccin se llama funcin de ajuste, e indica la aptitud de cada individuo para resolver el problema. Tambin existen cromosomas con genes y sus respectivos alelos. A los cromosomas se les aplican operadores genticos, equivalentes a la mutacin y la reproduccin sexual,de forma que se generan y ponen a prueba nuevas soluciones. De ese modo, los algoritmos genticos son un mtodo para probar mltiples soluciones autogeneradas a un problema. JGAP- Framework para algoritmos genticos. JGAP son las siglas de Java Genetic Algorithms Package (paquete de algoritmos genticos para Java). Es un componente de programacin de algoritmos genticos que se utiliza como un framework. JGAP es software libre y se puede distribuir bajo la GNU Lesser Public License 2.1 o posterior. Las aplicaciones comerciales que no publiquen su cdigo fuente deben distribuirse bajo la Mozilla Public License. En ese caso deben donarse 50 Euros al proyecto. JGAP tiene clases e interfaces para representar: Genes (Gene), cromosomas (Chromosome), individuos(IChromosome), la poblacin (Genotype), la funcin de ajuste (FitnessFunction) y operadores genticos. Se trata de una solucin genrica, sin relacin alguna con un problema particula.. Por esa razn se deben crear nuevas

clases que heredan o implementan las clases e interfaces mencionadas. As se adapta JGAP al problema especfico que se quiere solucionar. JGAP tambin se encarga de la simulacin de un ambiente para que se desarrolle y sobreviva la mejor solucin. El motor gentico crea varias soluciones (individuos) aleatoriamente con el mtodo randomInitialGenotype(). Aplica operadores genticos (mutacin y combinacin) para que surjan nuevas soluciones con el mtodo evolve(). Pone a prueba cada solucin con la funcin de ajuste evaluate(). Y por ltimo retorna el cromosoma del individuo mejor adaptado con getFittestChromosome(). Para instalar JGAPE, el primer paso es descargar la ltima versin. Se puede encontrar en la siguiente direccin: http://sourceforge.net/projects/jgap/files/.El archivo se llama jgap_x.x.x_full.zip (x.x.x corresponde al nmero de versin). Se recomienda descargar el de instalacin completa si no se desea compilar el cdigo. Luego de descargar el archivo se extrae su contenido. Esto puede hacerse en cualquier directorio. Por ltimo slo es necesario incluir el archivo jgap.jar como una biblioteca para poder usar las clases de JGAP.

Problema volumen.
Enunciado: Escribir un programa para maximizar el volumen de un cilindro en el que la suma de su radio (r) y su altura (h) debe ser de 30cm. El volumen de un cilindro se expresa con la funcin: V(r, h) = 2 r2 h La restriccin del problema es: r + h = 30 Expresando h en funcin de r h(r) = 30 r Reemplazando en la funcin del volumen en contramos la funcin de ajuste: V(r, h) = 2 r2 (30 - r) Planteando la solucin: La funcin de ajuste de JGAP se implementa sobrecargando el mtodo evaluate() en una subclase de FitnessFunction (se debe extender). Esta funcin se debe especificar de modo que un resultado mayor indique que el individuo evaluado es ms apto. Como el mejor resultado lo dar el mayor volumen. public double evaluate(IChromosome sujeto) { double radio = (Double)sujeto.getGene(0).getAllele(); return 2 * Math.PI * Math.pow(radio, 2) * (30 radio); } Se debe configurar el entorno que el motor gentico de JGAP va a simular. Para ello se usa una instancia de la claseConfiguration. Configuration configuracion = new DefaultConfiguration(); Luego se indica la funcin de ajuste que se va a usar con una instancia de la subclase de FitnessFunction

FitnessFunction maximizarV olumen = new FuncionAjusteMaximizarV olumen(); configuracion.setFitnessFunction(maximizarV olumen); Despus se debe crear un cromosoma de muestra. Se usa para indicar la cantidad de genes que lo componen, as como su tipo de dato y de preferencia un rango de valores para los alelos. Especificar un rango es importante porque reduce la cantidad de posibilidades que se pueden generar, mejorando el tiempo de ejecucin. Gene[] genes = { new DoubleGene(configuracion, 0. 0, 30. 0) }; Chromosome cromosoma = new Chromosome(configuracion, genes); configuracion.setSampleChromosome(cromosoma); El siguiente paso es definir el tamao de la poblacin. Una vez hecho, se pueden crear los individuos de la primera generacin de forma automtica y aleatoria. configuracion.setPopulationSize(TAMANIO_POBLACION); Genotype poblacion = Genotype.randomInitialGenotype(configuracion); Se contina con la evolucin de las diferentes generaciones. Puede ir dentro de un ciclo para hacerlo varias veces. En cada generacin se seleccionan los mejores individuos por medio de la funcin de ajuste. A partir de ellos se crea la siguiente generacin, mejor adaptada para resolver el problema. for (int i = 0; i < CANTIDAD_GENERACIONES; i++) { poblacion.evolve(); } Para terminar se obtiene el cromosoma del individuo mejor adaptado de la ltima generacin. IChromosome mejorSolucion = poblacion.getFittestChromosome(); A partir de ese cromosoma se puede obtener su valor con el mtodo getAllele() y su resultado en la funcin deajuste con getFitnessValue() (que en este ejemplo es el volumen). Una salida obtenida fue la siguiente: El mayor volumen es para un radio de 19.98009774232426 cm y una altura de 10.019902257675739 cm. El volumen resultante es de 25132.666615185735 cm cbicos. Algo interesante de los algoritmos genticos es que no son determinsticos. Los resultados de distintas ejecuciones tendrn pequeas diferencias. Eso se debe a la generacin aleatoria de los alelos para los genes. Es poco probable que en ejecuciones distintas se den de forma exacta los mismos valores hasta el ltimo decimal.

Problema Sphere.
Enunciado: Escribe un programa en C para minimizar la funcin Sphere, definida como: N

f X= xi2
i=0 donde X={x1, x2, ...xN} y x toma valores en el intervalo [-5.12, 5.12]. El valor de N ser 2, es decir, la funcin ser bidimensional. Para codificar cada variable xi usaremos 10 bits, por lo que solo podremos representar 1024 puntos. La siguiente tabla describe los posibles individuos o soluciones al problema:

genotipo 0000000000 0000000000 .................. 1111111111 1111111111

fenotipo punto (-5.12,-5.12) .................. punto (5.12,5.12)

Valor de f(x) o aptitud f(-5.12,-5.12)=52.4288 .................. f(5.12,5.12)=52.4288

En la grfica podemos ver la representacin invertida de la funcin Sphere

Para implementar el AG binario utilizar una seleccin por torneos de 2, cruce en un punto, mutacin en un punto. Parar el AG cuando f(x)<1*10-2 . Utilizar elitismo de un individuo. Para facilitar la operatoria utilizar un nmero impar de individuos, p.e. 11, de los cuales seleccionaremos 10 para cruzar que generaran 10 hijos, que a su vez sern mutados generando una poblacin de 10 individuos, a la que se incorporar el mejor individuo de la poblacin anterior. El resto de parmetros como nmero de individuos, probabilidad de cruce y mutacin, etc, deben definirse como constantes. Material a entregar. Cdigo del programa. Cual sera la precisin mxima que podemos alcanzar utilizando 10 bits?. Y con 20 bits?. Realiza una grfica como la de la figura en la que se muestre nmero de generacin frente a aptitud.

Realiza una grfica en la que se vea como influye el tamao de la poblacin en la resolucin del problema. Realiza una grfica en la que se vea como influye la probabilidad de mutacin. Realiza una grfica en la que se vea como influye la probabilidad de cruce. Solucin: (Eliminar los nmeros de lneas) 001 002 003 004 005 006 007 008 009 010 011 012 013 #define #define #define #define #define #define POBLACION 11 LONG_COD 20 LIMITE -5.12 PROB_CRUCE 0.3 PROB_MUTACION 0.001 INTERVALO 10.24/pow(2,LONG_COD/2)

#include <stdio.h> #include <stdlib.h> #include <math.h> typedef struct { int genotipo[LONG_COD];

014 015 016 017 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043

double aptitud; } Individuo; void decoder (double *, double *, int *); double fitness (double, double); int generarBinario (void); Individuo generarIndividuo (void); Individuo * generarPoblacion (void); Individuo * seleccionTorneos(Individuo * pob); void mutacionHijos (Individuo *); void cruzarSeleccion (Individuo *); Individuo elite(Individuo *); void AG(); void imprimePoblacion (Individuo *); void imprimeGenotipo(Individuo); void generarGraficoGeneracional(void); int main() { srand(time(NULL)); AG(); return 0; } /* PROC decoder (double *x, double *y, int *genotipo) DEV (double) * MODIFICA (double *x double *y) * EFECTO recibe un vector de enteros compuesto de 0 y 1 que representa dos numeros * codificados en binario. se encarga de convertir estos dos numeros binarios a su * equivalente en decimal con ayuda de la macro PRECISION (incremento del valor entre * cada binario) y la macro LIMITE que es el valor del limite inferior de la repre* sentacion que en el problema es -5.12 */

044 045 046 void decoder (double * x, double * y, int * genotipo) 047 { 048 int i; 049 *x = *y = 0.0; 050 051 // calculo del primer decimal 052 for(i=0; i<LONG_COD/2; i++)

053 *x += genotipo[i] * pow(2, (LONG_COD/2)-(i+1)); 054 *x = (*x) * INTERVALO + LIMITE; 055 056 //calculo del segundo decimal 057 for(;i<LONG_COD;i++) 058 *y += genotipo[i] * pow(2, LONG_COD-(i+1)); 059 *y = (*y) * INTERVALO + LIMITE; 060 } 061 /* PROC fitness (double p1, double p2) DEV 062 (double) 063 * MODIFICA nada * EFECTO recibe dos valores que representan los puntos que 064 caracterizan a un individuo * la funcion sirve para calcular la aptitud o fitness de 065 cierto individuo segun sus * puntos. este valor de aptitud es el que devuelve la 066 funcion. */ 067 068 double fitness (double p1, double p2) 069 { 070 return pow(p1,2) + pow(p2,2); 071 } 072 /* PROC generarBinario (void) DEV 073 (void) 074 * MODIFICA nada * EFECTO se encarga de devolver un valor entero que siempre 075 sera cero o uno. lo vamos a * utilizar para generar los individuos al principio dado que 076 su genoma es una cadena 077 * binaria que se genera aleatoriamente */ 078 079 int generarBinario (void) { 080 if (1 + (int) (10.0*rand()/(RAND_MAX+1.0)) > 5) 081 return 1; 082 else 083 return 0; 084 } 085 /* PROC generarIndividuo (void) DEV 086 (Individuo) 087 * MODIFICA nada 088 * EFECTO se encarga de generar un individuo utilizando valores

aleatorios. primero crea * la cadena de bits del genotipo utilizando la funcion 089 generaBinario y luego evalua * la aptitud del individuo utilizando la funcion decoder para 090 decodificar el genotipo 091 * y la funcion fitness para obtener la aptitud. */ 092 093 Individuo generarIndividuo (void){ 094 Individuo ind; 095 int i; 096 double x, y; 097 098 for (i=0; i<LONG_COD; i++) 099 ind.genotipo[i]=generarBinario(); 100 101 decoder(&x, &y, ind.genotipo); 102 ind.aptitud = fitness(x,y); 103 104 return ind; 105 } 106 /* PROC generarPoblacion (void) DEV 107 (Individuo *) 108 * MODIFICA nada * EFECTO esta funcion genera una poblacion con la cantidad de 109 individuos dada por la * macro POBLACION. para generar cada individuo utiliza la 110 funcion generarIndividuo() * y una vez ha terminado el bucle, devuelve el puntero al 111 primer individuo */ 112 113 Individuo * generarPoblacion(void) 114 { 115 Individuo * poblacion; 116 int i; 117 poblacion = (Individuo *) 118 malloc(sizeof(Individuo)*POBLACION); 119 for(i=0;i<POBLACION;i++) 120 poblacion[i] = generarIndividuo(); 121 122 return poblacion; 123 } 124

125 126 127 128 129 130 131 132

133 134 135 Individuo * seleccionTorneos (Individuo * poblacion) 136 { 137 Individuo candidato_a, candidato_b; 138 int i; 139 Individuo * seleccion = (Individuo *) malloc 140 (sizeof(Individuo)*POBLACION); 141 142 for (i=0; i<POBLACION-1; i++) 143 { candidato_a = poblacion[(int) (((double) 144 POBLACION)*rand()/(RAND_MAX+1.0))]; candidato_b = poblacion[(int) (((double) 145 POBLACION)*rand()/(RAND_MAX+1.0))]; 146 147 if (candidato_a.aptitud < candidato_b.aptitud) 148 seleccion[i] = candidato_a; 149 else 150 seleccion[i] = candidato_b; 151 } 152 153 return seleccion; 154 } 155 /* PROC mutacionHijos (Individuo *) DEV 156 (void) 157 * MODIFICA (Individuo *) 158 * EFECTO esta funcion aplica la mutacion segun la probabilidad

/* PROC seleccionTorneos (Individuo *) DEV (Individuo *) * MODIFICA nada * EFECTO se crea un nuevo vector de individuos que contendra a los individuos seleccionados * para el cruce. la seleccion se hace por torneos por tanto cada individuo seleccionado * sera el que tenga mejor aptitud de dos candidatos. el proceso se repite en POBLACION-1 * iteraciones, que es la cantidad de individuos que se deben seleccionar. la reserva de * memoria se hace sobre POBLACION individuos dado que, como luego vamos a seleccionar el * mejor de la poblacion anterior por elitismo, debemos dejar una plaza de la siguiente * generacion libre. la seleccion es con repeticion */

159 160 161

162 163 164 void mutacionHijos (Individuo * hijos) 165 { 166 int i, j; 167 168 for(i=0; i<2; i++) 169 for(j=0; j<LONG_COD; j++) 170 if ((double) rand()/(RAND_MAX+1.0) < PROB_MUTACION) 171 { 172 if(hijos[i].genotipo[j]) 173 hijos[i].genotipo[j] = 0; 174 else hijos[i].genotipo[j] = 1; 175 } 176 } 177 /* PROC cruzarSeleccion (Individuo *) DEV 178 (void) 179 * MODIFICA (Individuo *) * EFECTO esta funcion se encarga de cruzar los individuos 180 seleccionados. la seleccion * esta ordenada luego cruzamos los individuos seguidos de dos 181 en dos. para cada una * de las iteraciones se aplica la probabilidad de cruce. en 182 caso de que se crucen * los individuos se genera un punto de cruce y se 183 intercambian las porciones del * vector. luego se llama a la funcion de mutacion. en caso de 184 que no haya cruce, los 185 * padres pasan directamente a la siguiente generacion */ 186 187 void cruzarSeleccion (Individuo * seleccion) 188 { 189 int i, j, punto, aux; 190 double x, y; 191 192 for(i=0; i<POBLACION-1; i+=2)

dada por PROB_MUTACION. * recibe un vector de individuos en el que debe ocurrir que los dos primeros sean * los hijos correspondientes a un cruce. el genotipo de cada uno de los individuos * se recorre por completo calculando la probabilidad de que el bit mute y cambiando * si se diera el caso positivo */

193 194 195

if((double) rand()/(RAND_MAX+1.0) < PROB_CRUCE) { punto = (int) (((double) LONG_COD)*rand()/ 196 (RAND_MAX+1.0)); 197 198 for(j=punto; j<LONG_COD; j++) 199 { 200 aux=seleccion[i].genotipo[j]; seleccion[i].genotipo[j]=seleccion[i+1].genotip 201 o[j]; 202 seleccion[i+1].genotipo[j]=aux; 203 } 204 205 mutacionHijos(&seleccion[i]); 206 207 decoder(&x, &y, seleccion[i].genotipo); 208 seleccion[i].aptitud = fitness(x,y); 209 210 decoder(&x, &y, seleccion[i+1].genotipo); 211 seleccion[i+1].aptitud = fitness(x,y); 212 } 213 } 214 } 215 /* PROC elite (Individuo * poblacion) DEV 216 (Individuo) 217 * MODIFICA nada * EFECTO se trata de una funcion que devuelve el mejor 218 individuo de una poblacion * que se pasa como argumento. utiliza un individuo como 219 comparador y devuelve * el que para nuestro caso tiene el mejor fitness, es decir, 220 aptitud mas baja */ 221 222 Individuo elite (Individuo * poblacion) 223 { 224 int i; 225 Individuo best = poblacion[0]; 226 227 for(i=0; i<POBLACION; i++) 228 if(best.aptitud > poblacion[i].aptitud) 229 best = poblacion[i]; 230

231 return best; 232 } 233 /* PROC AG(void) 234 DEV (void) 235 * MODIFICA nada * EFECTO se trata de la funcion que ejecuta el algoritmo. el 236 proceso es el siguiente 237 * 1 - Generar la poblacion 238 * 2 - Seleccion de candidatos al cruce 239 * 3 - Cruce de los candidatos (incluye mutacion) 240 * 4 - Incluir al mejor de la generacion anterior en la nueva 241 * 5 - Repetir el proceso */ 242 243 void AG (void) 244 { 245 Individuo * seleccion, * poblacion = generarPoblacion(); 246 Individuo best; 247 int generacion = 0; 248 double x, y; 249 250 do 251 { 252 seleccion = seleccionTorneos(poblacion); 253 cruzarSeleccion(seleccion); 254 seleccion[POBLACION-1] = elite(poblacion); 255 free(poblacion); 256 poblacion = seleccion; 257 generacion++; 258 } while (elite(poblacion).aptitud > pow(10,-2)); 259 260 best = elite(poblacion); 261 free(poblacion); 262 decoder(&x, &y, best.genotipo); 263 264 printf ("*************************************\n"); 265 printf ("* FIN DEL ALGORITMO *\n"); 266 printf ("*************************************\n"); 267 printf (" - En el punto (%.5f, %.5f)\n", x, y); 268 printf (" - Su fenotipo es %.5f\n", best.aptitud); 269 printf (" - Es la generacion numero %i\n", generacion); 270 printf ("*************************************\n"); 271 }

272 273 274 275 276 277 /* PROC imprimePoblacion (Individuo * pob) DEV (void) * MODIFICA nada * EFECTO es una funcion auxiliar que imprime por pantalla toda la informacion * relativa a una poblacion que se debe pasar como argumento. recorre con un * bucle for todos los individuos para imprimirlos uno a uno y se ayuda de la * funcion decoder para sacar la aptitud */

278 279 280 void imprimePoblacion (Individuo * pob) 281 { 282 int i; 283 double x, y; 284 285 for(i=0;i<POBLACION;i++) 286 { 287 decoder(&x, &y, pob[i].genotipo); 288 printf ("INDIVIDUO NUMERO %i \t", i+1); 289 printf ("(%f,", x); 290 printf (" %f)", y); 291 printf ("\tAptitud = %.20f\n", pob[i].aptitud); 292 } 293 } 294 /* PROC imprimeGenotipo (Individuo x) 295 DEV (void) 296 * MODIFICA nada * EFECTO esta funcion se encarga de imprimir por pantalla el 297 genotipo asociado a * un individuo que se pasa como argumento. recorre el 298 genotipo por medio de 299 * un bucle for y no necesita funciones auxiliares */ 300 301 void imprimeGenotipo (Individuo x) 302 { 303 int i; 304 305 for(i=0; i<LONG_COD; i++) 306 printf ("%i ", x.genotipo[i]); 307 printf ("\n"); 308 }

309 310 311 312 313 314 315 316 317 /* PROC imprimeGenotipo (Individuo x) DEV (void) * MODIFICA nada * EFECTO esta funcion la utilizamos para generar los ficheros de puntos que se * utilizan en GNUPLOT para dibujar las graficas. se trata de una serie de * ejecuciones del algoritmo similar a como se hace en la funcion AG(), solo * que en este caso se imprime en un fichero, anadiendo informacion al final * con un formato especifico de generacion-aptitud, ademas se utiliza una * variable media para calcular la aptitud media de cada 10 generaciones */

318 319 void generarGraficoGeneracional() 320 { 321 FILE *f; 322 int generacion, j; 323 double media; 324 Individuo *seleccion, *poblacion = generarPoblacion(); 325 326 f=fopen("Puntos.dat", "at"); 327 fprintf (f, "\n0 %.40f\n", elite(poblacion).aptitud); 328 for(generacion=1; generacion<2000;) 329 { 330 media = 0; 331 for(j=0; j<10; j++, generacion++) 332 { 333 seleccion = seleccionTorneos(poblacion); 334 cruzarSeleccion(seleccion); 335 seleccion[POBLACION-1] = elite(poblacion); 336 media += elite(poblacion).aptitud; 337 free(poblacion); 338 poblacion = seleccion; 339 } 340 media /= j; 341 fprintf (f, "%i %.40f\n", generacion, media); 342 } 343 344 fprintf (f, "\n\n"); 345 fclose(f);

346 }

Problema: Funcion (X > 0) OR (X == -8) OR (X == - 5)


Leer y comprender el siguiente programa para explicar un algoritmo gentico y estar en condiciones de programar un Algoritmo gentico. Enunciado: Programacin Gentica para descubrir la frmula (X > 0) OR (X == -8) OR (X == - 5) dadas un conjunto de entradas que van desde -10 a 10 y salidas esperadas (verdadero o falso). La funcin de aptitud usada en el ejemplo toma en cuenta la variacin del resultado esperado tanto como la complejidad de la solucin (la solucin ms fcil es la mejor mutatis mutandis). La solucin ha sido presentada por Klaus Meffert y forma parte de JGAP. // Paquetes propios de la librera JGAP package examples.gp; import org.jgap.*; //La librera general import org.jgap.event.*; //Con sus eventos import org.jgap.gp.*; //Especificando las funciones, los mtodos, atributos, valores, etc. de import org.jgap.gp.function.*; //Programacin Gentica import org.jgap.gp.impl.*; import org.jgap.gp.terminal.*; import org.jgap.util.*; //Utilidades del programa //Clase SimpleExample que hereda de GPProblem, es decir, de la clase problema de Programacin Gentica . public class SimpleExample extends GPProblem { protected static Variable vx;//Una variable auxiliar //Funcin que crea el genotipo y cacha el error de configuracin invlida public GPGenotype create() throws InvalidConfigurationException { GPConfiguration conf = getGPConfiguration();//Se toma la configuracin de la clase // El resultado de la Programacin Gentica retorna un booleano. // ------------------------------------------Class[] types = {CommandGene.BooleanClass}; // Arreglo de clases que representa los booleanos Class[][] argTypes = { {} // resultados, y un arreglo de arreglos de clases }; // Los comandos y terminales permiten encontrar una solucin. // -----------------------------------------------------CommandGene[][] nodeSets = { { // Necesitamos una variable para la alimentacin de los datos (ver la funcin fitness (aptitudes)). // ---------------------------------------------------------vx = Variable.create(conf, "X", CommandGene.IntegerClass), // Define las terminales (aqu: numeros) para tratar:

// De la manera ms fcil: Define dos constantes // Ms difcil: Define una terminal que pueda tener valores entre -10 a 10, por ejemplo: // new Constant(conf, CommandGene.IntegerClass, 0), // new Constant(conf, CommandGene.IntegerClass, -8), new Terminal(conf, CommandGene.IntegerClass,-10,10,true), // Operadores booleanos a utilizar. // -----------------------new GreaterThan(conf, CommandGene.IntegerClass), // Mayor que new Or(conf), //Operador OR new Equals(conf, CommandGene.IntegerClass), //Igual a // Define operadores complejos. // -----------------------new If(conf, CommandGene.BooleanClass), //Operador IF // Terminales booleanos a utilizar (estos no aparecen dentro de una solucin opcional // y hacen la labor mas desafiante) --> dejar fuera si es necesario // ------------------------------------------------------------------// new True(conf, CommandGene.BooleanClass), new False(conf, CommandGene.BooleanClass)//Terminal con valor falso } }; // Inicializa el GPGenotype, es decir, el Genotipo de Programacin Gentica. // -------------------------return GPGenotype.randomInitialGenotype(conf, types, argTypes, nodeSets,100, true); //100 genes } //Funcin de inicio que cacha el error de excepcin public void start() throws Exception { GPConfiguration config = new GPConfiguration(); //Se inicializa la configuracin config.setMaxInitDepth(5); //Profundidad de 5 niveles config.setPopulationSize(80); //Tamao de la poblacin de 80 individuos config.setFitnessFunction(new SimpleFitnessFunction()); //Tipo de funcin para obtener aptitud config.setStrictProgramCreation(false);// No se requiere una estricta creacin del programa config.setProgramCreationMaxTries(5);//Intentos maximos de creacin 5 config.setMaxCrossoverDepth(5);//Profundidad mxima de cruza 5 // El valor ms bajo de aptitud es mejor que el valor de aptitud que indica tasa de error. // -------------------------------------------------------------------config.setGPFitnessEvaluator(new DeltaGPFitnessEvaluator()); //Tipo de evaluador de aptitud super.setGPConfiguration(config); //Se coloca la configuracin GPGenotype geno = create(); //Se crea el genotipo // Simple implementacin de dirigir la evolucin en un hilo. A continuacin se agrega un evento. // ------------------------------------------------------//Esta parte tal ves hace referencia a parar el proceso si se estanca durante mucho tiempo config.getEventManager().addEventListener(GeneticEvent. GPGENOTYPE_EVOLVED_EVENT, new GeneticEventListener() { public void geneticEventFired(GeneticEvent a_firedEvent) { GPGenotype genotype = (GPGenotype) a_firedEvent.getSource(); int evno = genotype.getGPConfiguration().getGenerationNr(); double freeMem = SystemKit.getFreeMemoryMB(); if (evno % 100 == 0) { IGPProgram best = genotype.getAllTimeBest();

System.out.println("Evolving generation " + evno); genotype.outputSolution(best); } if (evno > 3000) { System.exit(1); } } }); //Esta parte tal vez hace referencia a regresar el resultado cuando se encuentre el mejor individuo config.getEventManager().addEventListener(GeneticEvent. GPGENOTYPE_NEW_BEST_SOLUTION, new GeneticEventListener() { /** * New best solution found. * * @param a_firedEvent GeneticEvent */ public void geneticEventFired(GeneticEvent a_firedEvent) { GPGenotype genotype = (GPGenotype) a_firedEvent.getSource(); IGPProgram best = genotype.getAllTimeBest(); double bestFitness = genotype.getFittestProgram(). getFitnessValue(); if (bestFitness < 0.1) { // Sale, cuando la solucin se muestra perfecta. // --------------------------------------genotype.outputSolution(best); System.exit(0); } } }); geno.evolve(10000); } //funcin principal y maneja excepciones public static void main(String[] args) throws Exception { SimpleExample example = new SimpleExample(); //Se inicializa el ejemplo simple example.start(); //Inicia el proceso } //Case de funcin de aptitud simple que hereda de funcion de aptitud class SimpleFitnessFunction extends GPFitnessFunction { //funcin de evaluacin de los individuos protected double evaluate(final IGPProgram ind) { int error = 0; //Variable que indica el error Object[] noargs = new Object[0]; //Declaracin de un objeto int maxDepth = ind.getChromosome(0).getDepth(0); //Se obtiene la profundidad mxima if (maxDepth > 2) { //Se controla la profundidad error += maxDepth - 2; } for (int i = -10; i < 10; i++) {//Se inicia con la bsqueda del resultado vx.set(new Integer(i));//Se aplica un nuevo valor a vx

boolean y; //Se manejan los casos respuesta con la variable y if (i > 0) {// si es mayor a cero y = true; } else {if (i != -8 && i != - 5) { y = false; } else {y = true; //o si es -8 o -5 } } try {boolean result = ind.execute_boolean(0, noargs); //Se obtiene la aptitud if (result != y) { error += 10; //Si el resultado del booleano comparado con y es diferente, se incrementa el error } } catch (ArithmeticException ex) { // Alguna operacin ilegal ocurri. System.out.println("x = " + i); //Se muestra el estado en el que se encontraba al ocurrir System.out.println(ind);//y el individuo que lo produjo throw ex; } } return error;//Regresa el error que representa el nivel de aptitud } } }

Problema: aprender Hello word


Escrito en C. Presentacin de la solucin: Hello world 1. Descargar el codigo c++ desde http://www.generation5.org/content/2003/gahelloworld.asp y grabarlo como helloworld.cpp 2. Compilar el programa, creando el ejecutable hola: g++ -o hola helloword.cpp 3. Abrir terminal 4. cd /home/mario/Escritorio/AG/hellowordAG 5. Ejecutar el programa hola: ./hola 6. La siguiente lista muestra para cada iteracin, la selccin y su fitness (funcin de aptitud): 7. Best: :Njhu)rfyGN@ (169) 8. Best: HXpU`4Zmlat. (152) 9. Best: Grhh^4grrvU6 (124) 10. Best: Grdgv%kger_, (94) 11. Best: B\hio6umqqO& (80) 12. Best: B\hio6umqqO& (80) 13. Best: Mk_gp wqth[" (48) 14. Best: Dmdgp wqth[" (44) 15. Best: Dmdgp wqtjn" (43) 16. Best: Djlnp#tuumh# (34) 17. Best: Fegmn!rmqfk (32) 18. Best: Idnfh wknmh# (32)

19. Best: Hegmp wqth[" (25) 20. Best: Kfkmu"wqtme! (20) 21. Best: Kfkmu"wqtme! (20) 22. Best: Gblop wqthe! (17) 23. Best: Fenko"wqtle! (12) 24. Best: Idnkp wrrle! (10) 25. Best: Hdnkp wrrle! (9) 26. Best: Henkp wrrle! (8) 27. Best: Hflmp wqqld! (6) 28. Best: Helmn wnqle! (5) 29. Best: Helmn wnqle! (5) 30. Best: Helkp wrrld! (5) 31. Best: Hflmp wnrld! (4) 32. Best: Helmp wnrle! (4) 33. Best: Helkn wnrld! (3) 34. Best: Helmo wnrld! (2) 35. Best: Helmo wnrld! (2) 36. Best: Hello wnrle! (2) 37. Best: Helmo wnrld! (2) 38. Best: Hellp wnrld! (2) 39. Best: Helmo world! (1) 40. Best: Hello wnrld! (1) 41. Best: Hello wnrld! (1) 42. Best: Hello world! (0)