Galindo Cárdenas Enrique

IA 1958
Comentarios a un programa de Programación
Genética.
martes 30/noviembre/2010
1 de 5

A continuación presento un ejemplo de código utilizado para implementar programación

genética por medio de la libreria JGAP echa en JAVA descargable en http://jgap.sourceforge.net, en sí
sólo es el comienzo para entender la librería y cómo funciona, trataré de comentar lo mejor posible su
función y traduciré sus comentarios:

/*
* Este archivo es parte de JGAP.
*
* JGAP oferta un modelo de doble licencia tanto licencia LGPL como la licencia MPL.
*
* Para información referente a la licencia favor de ver el archivo license.txt incluido con JGAP
* o echar un vistazo a la parte superior de la clase org.jgap.Chromosome que representativamente
* incluye la politica de licencia de JGAP aplicable para cualquier archivo desarrollado con JGAP.
*/

//A continuación se muestran los paquetes propios de la librería JGAP

package examples.gp;

import org.jgap.*; //La librería general

import org.jgap.event.*; //Con sus eventos
import org.jgap.gp.*; //Especificando las funciones, los métodos, atributos, valores, etc. de
import org.jgap.gp.function.*; //Programación Genética
import org.jgap.gp.impl.*;
import org.jgap.gp.terminal.*;
import org.jgap.util.*; //Utilidades del programa

/**
* Ejemplo simple de Programación Genética para descubrir la fórmula
* (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 función de aptitud usada en el ejemplo toma en cuenta la variacón del resultado esperado
* tanto como la complejidad de la solución (la solución más fácil es la mejor
* mutatis mutandis).
*
* @author Klaus Meffert
* @since 3.5
*/
 Galindo Cárdenas Enrique
IA 1958
Comentarios a un programa de Programación
Genética.
miercoles 27/octubre/2010
2 de 5

//Clase SimpleExample que hereda de GPProblem, es decir, de la clase problema de Programación

//Genética
public class SimpleExample
extends GPProblem {

protected static Variable vx; //Una variable auxiliar

//Función que crea el genotipo y cacha el error de configuración inválida

public GPGenotype create()
throws InvalidConfigurationException {
GPConfiguration conf = getGPConfiguration(); //Se toma la configuración de la clase
// El resultado de la Programación Genética 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 solución.
// ------------------------------------------------------
CommandGene[][] nodeSets = { {
// Necesitamos una variable para la alimentación de los datos (ver la función fitness (aptitudes)).
// ----------------------------------------------------------
vx = Variable.create(conf, "X", CommandGene.IntegerClass),
// Define las terminales (aquí: numeros) para tratar:
// De la manera más fácil: Define dos constantes
// Más difícil: 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 solución 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
}
};
 Galindo Cárdenas Enrique
IA 1958
Comentarios a un programa de Programación
Genética.
miercoles 27/octubre/2010
3 de 5

// Inicializa el GPGenotype, es decir, el Genotipo de Programación Genética.

// --------------------------
return GPGenotype.randomInitialGenotype(conf, types, argTypes, nodeSets,
100, true); //100 genes
}

//Función de inicio que cacha el error de excepción

public void start()
throws Exception {
GPConfiguration config = new GPConfiguration(); //Se inicializa la configuración
config.setMaxInitDepth(5); //Profundidad de 5 niveles
config.setPopulationSize(80); //Tamaño de la población de 80 individuos
config.setFitnessFunction(new SimpleFitnessFunction()); //Tipo de función para obtener aptitud
config.setStrictProgramCreation(false);// No se requiere una estricta creación del programa
config.setProgramCreationMaxTries(5);//Intentos maximos de creación 5
config.setMaxCrossoverDepth(5);//Profundidad máxima de cruza 5
// El valor más 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 configuración
GPGenotype geno = create(); //Se crea el genotipo
// Simple implementación de dirigir la evolución en un hilo. A continuación 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);
}
}
});
 Galindo Cárdenas Enrique
IA 1958
Comentarios a un programa de Programación
Genética.
miercoles 27/octubre/2010
4 de 5

//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 solución se muestra perfecta.
// ---------------------------------------
genotype.outputSolution(best);
System.exit(0);
}
}
});
geno.evolve(10000);
}

//función 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
}
 Galindo Cárdenas Enrique
IA 1958
Comentarios a un programa de Programación
Genética.
miercoles 27/octubre/2010
5 de 5

//Case de función de aptitud simple que hereda de funcion de aptitud

class SimpleFitnessFunction
extends GPFitnessFunction {
//función de evaluación de los individuos
protected double evaluate(final IGPProgram ind) {
int error = 0; //Variable que indica el error
Object[] noargs = new Object[0]; //Declaración de un objeto
int maxDepth = ind.getChromosome(0).getDepth(0); //Se obtiene la profundidad máxima
if (maxDepth > 2) { //Se controla la profundidad
error += maxDepth - 2;
}
for (int i = -10; i < 10; i++) {//Se inicia con la búsqueda 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 operación 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
}
}
}