Programación Genética (PG)

1. Programación Genética(PG) Mario Hernández

2. ¿PG? • La PG suministra una metodología para crear automáticamente programas a partir de una definición de los mismos a alto nivel. • PG consigue el objetivo de Programación Automática (también denominada Síntesis de Programas o Inducción de Programas) reproduciendo genéticamente una población de programas utilizando los principios darwinianos de la selección natural y de las operaciones inspiradas biológicamente.

3. PG • Rama de la Computación Evolutiva (CE) • Diferencia PG - AG: ¿qué solución se busca? O, de otra manera: cuál es la representación que se utiliza para la solución

4. Los AG crean cadenas de cromosomas que codifican (representan) la solución buscada • La PG crea Programas (código)  • Es decir: en PG se transforman Programas que buscan la Solución, en vez de la Representación de la solución

5. Algunos Campos de Aplicación • Síntesis automática de circuitos eléctricos analógicos • Síntesis automática de controladores • Problemas en biología molecular computacional, incluyendo rutas metabólicas y redes genéticas. • Autómatas Celulares • Sistemas Multiagente • Investigación Operativa • Areas de Diseño • Uso de PG como una “Máquina Automática de Invenciones” para crear nuevas invenciones útiles patentables

6. Algoritmo Evolutivo General • Crear aleatoriamente una población de soluciones • Hacer iterativamente, hasta alcanzar una solución suficientemente buena: • Evaluar cada solución, dándole una puntuación • Escoger las mejores y reproducirlas; mutarlas o cruzarlas, con otras nuevas soluciones para la próxima generación

7. Algoritmo General de PG • Generarar una población inicial de programas • Ejecutar cada programa de la población y asignarle un valor de aptitud (fitness) de acuerdo a lo bien que resuelve el problema. • Crear una nueva población de programas aplicando las siguientes operaciones: i) Copiar los mejores programas existentes ii) Crear nuevos programas por mutación iii) Crear nuevos programas por cruce (crossover) El mejor programa aparecido en cualquier generación, es decir el que genera la mejor de las soluciones con las restricciones que le son impuestas (pe complejidad, etc…), resulta designado como el resultado del procedimiento de Selección Genética por PG.

8. La Idea ¿Lunática? de Evolucionar Programas • Ejemplo del primer paso: Programa generado aleatoriamente:

9. Argumentos contra la evolución de programas • Los programas creados aleatoriamente tienen una posibilidad infinitesimal de compilar, y menos que hagan lo que se pretende • La ejecución de un programa creado aleatoriamente darán lugar, si compila, y muy probablemente a errores de salida de espacios reservados para matrices, data-casting, core-dumps, divisiones por cero, etc... lo que conllevará a suspensión de ejecución • Mutar y mezclar segmentos de programas creados aleatoriamente resulta en un sinsentido equivalente a crearlos aleatoriamente ¿Cómo se resuelve esto en la PG?

10. La Representación en PG El truco consiste en escoger una representación subyacente para los programas tal que resulte factible la creación aleatoria, la mutación y el cruce de programas

11. La Representación en PG + * 4 5 -2 • Representación basada en árboles (+ (* 5 –2) 4) La representación empleada en PG se basa en árboles, que presentan una correspondencia directa con la notación prefija o polaca

12. La Representación en PG (II) • Una familia de lenguajes de programación que se adapta a esta representación son la familia Lisp (Lisp-like), como p.e. Lisp o Scheme

13. La Representación en PG (III) Notación Sufija Notación Prefija f(x,y) (f x y) 3*4 (* 3 4) Los programas complejos se expresan utilizando funciones compuestas, pe: (+ 2 (IF (> X 3) 4 7))

14. (+ 2 (IF (> X 3) 4 7)) La estructura consta de funciones y terminales + 2 IF > 4 7 X 3

15. Utilidad de la representación en árbol • La estructura en árbol resulta útil para definir los efectos de los operadores sobre los programas • Los operadores presentan una estructura muy “elegante” en este formato • También resulta útil a efectos prácticos en dominios de aplicación como: • Determinar las capas (layouts) en un circuito integrado analógico • Crear redes neuronales • Paralelizar programas • Y muchos otros ...

16. Ventajas de las estructuras “Lispy” • Cada programa es una lista uniforme • Las listas representan, sin distinción alguna, datos y código. Ello permite que se puedan definir las operaciones genéticas de forma sencilla • El formato de las instrucciones es el de una función aplicada a argumentos. Ello representa la información de control en una sintaxis común, que resulta (otra vez) cómoda para su modificación genética • La estructura de longitud variable de las lista supera la limitación de longitud fija de las cadenas (strings) en los AG

17. Operadores Genéticos para Programas • Creación: generación aleatoria de árboles utilizando funciones y terminales • Cruce: fijar puntos de cruce en ambos padres y solapar ambos subárboles • Mutación: fijar un punto de mutación en un padre y reemplazar subárbol con un árbol generado aleatoriamente

18. Para aplicar operadores genéticos El Primer Paso: Identificación de los “Puntos de Fractura” : análogos a los “puntos de cruce en las representaciones genéticas en cadenas utilizadas por los AG. Pueden ser: • El Inicio de una sublista • Un Terminal

19. Implementación de Operadores • Cruce • Inversión • Mutación

20. I. Operador de Cruce (crossover) Pasos: • Escoger dos programas criadores individuales • Seleccionar dos sublistas, una por criador • Intercambiar las sublistas en la descendencia

21. Paso 1 (* x (+ x y )) (+ (* z y) (/ y x )) * + * / x + x y z y y x

22. Paso 2 * + * / x + x y z y y x

23. Paso 2 * + * / x + x y z y y x

24. Paso 2 * + * x + x z y

25. Paso 3 * + * x + y / x z y y x

26. II. Operador de Inversión Pasos: • Escoger un individuo de la población • Seleccionar dos puntos de fractura en el individuo • Generar un nuevo individuo conmutando los símbolos delimitados y solapando las sublistas con la lista principal

27. Paso 1 + * / z y y x

28. Paso 2 + * / z y y x

29. Paso 2 + * / z y y x

30. Paso 2 + * / z y y x

31. Paso 3 + * / z y y x

32. Paso 3 + * z / y y x

33. Paso 3 + * z / y y x

34. III. Operador de Mutación Pasos: • Seleccionar un programa padre • Reemplazar aleatoriamente cualquier símbolo de función por cualquier otro o cualquier símbolo terminal por cualquier otro

35. Paso 1 + * / z y y x

36. Paso 2 + * / z y y x

37. Paso 2 + + / z y y x

38. Paso 2 + + / z y y x

39. Problema • Todos los ejemplos anteriores son aritméticos • En casos más generales puede darse SOLAPAMIENTO DE ARGUMENTOS Pe: si una función devuelve una lista y se intercambia con otra que devuelve un entero, la estructura resultará sintacticamente inválida

40. Soluciones • Todas las funciones deben devolver el mismo tipo de argumentos (pe entero) • Usar programación genética fuertemente tipada para asegurar que todas las expresiones son type-safe • Implementar algún tipo de chequeo

41. Algoritmo de PG • La principal diferencia del algoritmo básico de PG con el AG básico surge de la sustitución de las cadenas por programas • Esta diferencia se muestra en la evaluación de la aptitud, por lo que el programa se prueba con un conjunto de entradas para evaluarlo.

42. Algoritmo de PG • Escoger una población de tamaño NP • Escoger el número de generaciones NG • Inicializar la población • Repetir durante NG generaciones • Seleccionar probabilísticamente un cierto número de pares de individuos de la población después de asignar a cada estructura una probabilidad proporcional a su aptitud (fitness) o desempeño (performance) • Copiar las estructuras seleccionadas y aplicarle los operadores para producir nuevas estructuras • Seleccionar aleatoriamente otros elementos y reemplazarlos con las nuevas estructuras • Observar y registrar la aptitud de las nuevas estructuras • Suministrar como salida a los individuos más adecuados

43. Creación de la Población Inicial • Cuando se crea una población, resulta interesante empezar con muchos árboles de diferentes tamaños/formas • Se generan árboles utilizando los siguientes métodos: • Full: cada ruta en el árbol es de la longitud máxima • Grow: las longitudes de rutas varían hasta la longitud máximaRamp half-and-half: (típico) se crean árboles de profundidades variadas desde un mínimo hasta un máximo, y para cada profundidad, la mitad se crean usando el método full y la otra mitad usando el método grow

44. Pasos preparatorios para PG Una vez decidido que quieres resolver un problema usando GP, para efectuar la ejecución se necesita: • Determinar el conjunto de terminales: variables, valores de entrada o comandos de acción • Determinar el conjunto de funciones (no terminales) • Determinar la medida de aptitud (fitness) • Los parámetros para controlar la ejecución: • Tamaño de población • Número máximo de generaciones • Tasas de Mutación, cruce y reproducción (típicos 1, 90 y 9%) • El método de terminación de una ejecución y de designación de un resultado

45. Suficiencia y Cierre El conjunto de funciones y el de terminales deben satisfacer los principios: • Cierre: cada función f debe ser capaz de aceptar los valores de todos los terminales t del conjunto de terminales y cada función f del conjunto de funciones • Suficiencia: en el Espacio de Programas creado a partir de los conjuntos de funciones y terminales • debe existir una solución al problema que se plantea

46. Algunos Ejemplos

47. Ejemplo: Paridad Objetivo: obtener la función paridad n-par, pe n=3

48. Elementos del Problema • Conjunto de Terminales: los tres símbolos que representan las tres posibles entradas a ser comprobadas para paridad: T = {D0, D1, D2} • Conjunto de Funciones: primitivas booleanas de dos argumentos F = [AND, OR, NAND, NOR}

49. Solución • Utilizando una población inicial de 4000 programas, se descubrió una solución en la generación 5 • La solución contiene 45 elementos (terminales + no terminales)

50. Solución (II) (AND (OR (OR D0 (NOR D1 D2)) D2) (AND (NAND (NOR (NOR (NOR D0 D2) (AND (AND D1 D1) D1)) (NAND (OR (AND D0 D1) D2) D0)) (OR (NAND (AND (D0 D2) (OR (NOR D0 (OR D2 D0) D1)) (NAND (NAND D1 (NAND (D0 D1)) D2)))