CBI - 148.206.53.84148.206.53.84/tesiuami/UAMI12078.pdflenguajes y expresiones regulares.....9 1.1 símbolos ... manual de usuario

-

División:

CBI

Grado:

Licenciatura en Computación

Título del Trabajo:

APRENDIENDO AUTOMATAS ACICLICOS CON ALGORITMOS GENETICOS

Lugar de realización:

Laboratorio de Acústica y Fonética UAM-I

Nombre de los participantes:

Torres Hernández Yazmín Yahaira

Hernández García Humberto

Nombre y firma del asesor:

Dr. Jhon Charles Goddard Close

-

INDICE.

INTRODUCCIÓN ..........................................................................6

CAPITULO 1 ...............................................................................9

LENGUAJES Y EXPRESIONES REGULARES ..........................................................................9 1.1 Símbolos..................................................................................................................................9 1.2 Alfabeto .................................................................................................................................9 1.3 Cadena................................................................................................................................... 10 1.4 Longitud de cadena ............................................................................................................ 10 1.5 Cadena vacía .........................................................................................................................11 1.6 Universo del discurso .........................................................................................................11 1.7 Lenguaje ............................................................................................................................... 12 1.8 Lenguaje vació..................................................................................................................... 13

CAPÍTULO 2 ............................................................................. 15

AUTÓMATAS................................................................................................................................ 15 2.1 Introducción........................................................................................................................ 15 2.2 Definición Autómata finito deterministico ................................................................ 16 2.3 Representación de autómatas......................................................................................... 17

2.3.1 Tabla de transiciones ................................................................................................ 17 2.3.2 Diagramas de transiciones....................................................................................... 17

2.4 Autómata Finito No Deterministico .............................................................................. 19

CAPITULO 3 ............................................................................. 21

ALGORITMOS GENÉTICOS...................................................................................................... 21 3.1 Introducción........................................................................................................................ 21 3.2 Algoritmos Genéticos ....................................................................................................... 21

3.2.1 Orígenes ....................................................................................................................... 21 3.2.2 Descripción................................................................................................................. 22

3.3 Funcionamiento.................................................................................................................. 22 3.3.1 Bases biológicas ......................................................................................................... 22

3.4 Algoritmo Genético .......................................................................................................... 24 3.5 Descripción algorítmica................................................................................................... 25 3.6 ¿Cómo saber si es posible usar el Algoritmo Genético? .......................................... 27 3.7 Selección ............................................................................................................................ 28

3.7 .1 Selección por la Regla de la Ruleta ...................................................................... 28 3.7.2 Selección por Ranking .............................................................................................. 29 3.7.3 Selección de Estado Fijo......................................................................................... 30

3.8 Elitismo ............................................................................................................................... 30 3.9 Operadores de un AG ....................................................................................................... 31

3.9.1 Operador de cruce..................................................................................................... 31

-

3.9.2 Cruce en un punto ...................................................................................................... 31 3.9.3 Cruce en dos puntos .................................................................................................. 31 3.9.4 Cruce uniforme.......................................................................................................... 32 3.9.5 Cruce aritmético ....................................................................................................... 32

3.10 Operador de mutación ................................................................................................... 32 3.10.1 Inversión de genes .................................................................................................. 32 3.10.2 Cambio de orden...................................................................................................... 33 3.10.3 Modificación de genes ........................................................................................... 33

3.11 Parámetros de los AGs................................................................................................... 33 3.11.1 Porcentaje de Cruce (Pc) ........................................................................................ 33 3.11.2 Porcentaje de Mutación (Pm) ................................................................................ 34 3.11.3 Tamaño de la Población (tam-pob) ....................................................................... 34 3.11.4 Número de Generaciones (nro-gen)..................................................................... 34 3.11.5 Tamaño del Individuo (tam-ind) ........................................................................... 34

3.12 Representación del genotipo ........................................................................................ 34 3.12.1 Representación Binaria........................................................................................... 35 3.12.2 Representación Directa......................................................................................... 35

3.13 Ejemplo de un Algoritmo Genético.............................................................................. 35 3.14.1 El problema ............................................................................................................... 39 3.14.2 Implementación ....................................................................................................... 39 3.14.3 Funciones que se utilizaron................................................................................... 40 3.14.3.7 report();................................................................................................................. 41 3.14.3.8 evaluate();............................................................................................................... 41 3.14.3.9 elitist():................................................................................................................... 41 3.14.3.10 Resultados ............................................................................................................ 41

CAPITULO 4 ............................................................................. 44

APLICACIÓN DE ALGORITMOS GENÉTICOS PARA EL APRENDIZAJE DE AUTÓMATAS FINITOS. .......................................................................................................... 44

4.1 Introducción....................................................................................................................... 44 4.2 Estructura de la población.............................................................................................. 46 4.3 Inicialización...................................................................................................................... 50 4.4 Selección y reemplazo ..................................................................................................... 50 4.5 Función de evaluación (fitness) ..................................................................................... 50

4.5.1 Consistencia (C1):........................................................................................................ 51 4.5.2 Tamaño (C2): .............................................................................................................. 52 4.5.3 Generalización (C3): ................................................................................................. 52

4.6 Operador de Cruzamiento. ............................................................................................. 53 4.7 Operador de Mutación. ................................................................................................... 56 4.8 Otros Operadores ............................................................................................................ 57

4.8.1 Validación .................................................................................................................... 57 4.8.2 Operador State Merge ........................................................................................... 58 4.8.3 Operador State Split .............................................................................................. 58

CAPITULO 5 ............................................................................. 61

-

CODIFICACIÓN PARA EL APRENDIZAJE DE AUTÓMATAS FINITOS QUE RECONOZCAN CADENAS.......................................................................................................... 61

5.1 Descripción y estructuras de datos del programa ..................................................... 61 5.2 Procedimiento Principal del programa.......................................................................... 62 5.3 Descripción de cada función .......................................................................................... 62

5.3.1 Genera_pob_inicial: .................................................................................................. 62 5.3.2 Validar_población: .................................................................................................... 62 5.3.3 Evalúa_población:...................................................................................................... 63 5.3.4 Carga_archivo:........................................................................................................... 65 5.3.5 Algoritmo_genético:................................................................................................. 65 5.3.6 Encuentra_mejor: ..................................................................................................... 66 5.3.7 Visualiza_población: ................................................................................................. 66 5.3.8 Genera_archivo: ........................................................................................................ 66 5.3.9 Cruzamiento: .............................................................................................................. 66 5.3.10 Mutación: .................................................................................................................. 68 5.3.11 State_Merge:........................................................................................................... 68 5.3.12 State_Split: ............................................................................................................. 69

CAPITULO 6 ............................................................................. 72

PRUEBAS Y RESULTADOS ....................................................................................................... 72 6.1 Descripción de la prueba 1 .............................................................................................. 72

6.1.1. Primer prueba utilizando el lenguaje 1 ................................................................ 73 6.1.2 Segunda prueba utilizando el lenguaje 1 .............................................................. 77 6.1.3 Tercer prueba utilizando el lenguaje 1 ................................................................. 78

6.2. Descripción de la prueba utilizando otro lenguaje................................................... 79 6.2.1. Primer prueba utilizando el lenguaje 2................................................................ 80 6.2.2 Segunda prueba utilizando el lenguaje 2 ............................................................. 83 6.2.2 Tercer prueba utilizando el lenguaje 2................................................................ 83

6.3 Prueba con los datos utilizados por Anja Belz........................................................... 84

CONCLUSION ........................................................................... 88

BIBLIOGRAFIA.......................................................................... 89

ANEXO ................................................................................... 90

A) MANUAL DE USUARIO........................................................................................................ 90 B) FORMATO DE ARCHIVOS........................................................................................................... 92

a) Formato archivo cadenas .................................................................................................. 92 b) Formato archivo result.txt............................................................................................... 92 c) Formato archivo generado.txt ......................................................................................... 93

C) CÓDIGO FUENTE........................................................................................................................ 93 D) PRUEBA DE DIGITOS..........................................................................................................128

-

-

INTRODUCCION

INTRODUCCIÓN

Durante las dos últimas décadas el campo de la computación ha tenido diversas aplicaciones en todas las áreas de conocimiento. Una aplicación es la computación evolutiva que se basa en la naturaleza, todo se lleva a cabo a base de interacciones locales entre individuos, y entre estos y lo que les rodea, haciendo pequeños modelos de la naturaleza, que tuvieran alguna de sus características, y ver cómo funcionaban, para luego extrapolar sus conclusiones a la totalidad.

La Computación evolutiva ha sido recientemente reconocida como campo de investigación. Su campo de aplicación se extiende desde los problemas de optimización hasta e l aprendizaje de m quinas. Bajo esta denominación se engloban distintos enfoques de simulación de la evolución: l os algoritmos genéticos, las estrategias evolutivas y la programación evolutiva. Todos ellos tienen en comparación la reproducción las modificaciones aleatorias, la competencia y la selección de individuos en una población. El Profesor Michalewicz ofrece, en su libro, una introducción al tema abarcando cada uno de los enfoques evolutivos aunque con preferencia hacia los algoritmos genéticos y sus extensiones: los programas evolutivos.

La comunidad científica internacional ha mostrado un creciente interés en una nueva técnica de búsqueda basada en la teoría de la evolución y que se conoce como el algoritmo genético. Esta técnica se basa en los mecanismos de selección que utiliza la naturaleza, de acuerdo a los cuales los individuos más aptos de una población son los que sobreviven, al adaptarse más fácilmente a los cambios que se producen en su entorno.

Ahora bien, a pesar de que el algoritmo es un proceso lógico e innato del hombre no es tan común meditar los pasos que se deben seguir para resolver un problema. Esto se debe en gran medida a que en la escuela sólo nos transmiten conocimientos sin enseñarnos a pensar, no nos enseñan a analizar los problemas.

Un Algoritmo Genético es un procedimiento de resolución de problemas que se

basa en los métodos de Evolución Genética de los seres vivos para solucionar problemas de búsqueda y optimización, debido a que el problema a resolver se trata de una búsqueda se utilizó un algoritmo genético para darle solución.

El reporte esta organizado por definiciones de componentes de un autómata

deterministico finito, y la partes que forma un algoritmo genético como algunos de sus operadores que existen, seguimos por entender un algoritmo genético con el ejemplo que fue tomado del libro de Michalewicz minimiza la función que es x2-x*y+z donde se

-

observa el funcionamiento y comportamiento de funciones como selección, cruzamiento, mutación, la función de evaluación en este caso fue codificada para números reales. Se continúo con hacer modificaciones al programa que fueron cambiar la función fitness, lo cual consistió en codificar las entradas de números reales en números binarios para trabajar con los binarios en las funciones de cruzamiento y mutación, y observar el comportamiento el cual se comprueba que converge más rápido a la solución.

La parte final de este trabajo es una aplicación importante hacia el aprendizaje de un autómata finito para un conjunto de cadenas, esta aplicación esta basada en el diseño de Anja Belz (Computational Learning of Finite-State Models for Natural Language Processing), se toman las constantes que el articulo propone. Al final se obtiene una tabla de transición del mejor autómata encontrado.

-

-

CAPITULO 1

LENGUAJES Y EXPRESIONES REGULARES

En este capitulo se describen y definen los diferentes componentes que forman un lenguaje.

1.1 Símbolos Es una entidad abstracta, que no se va a definir, pues se dejará como axioma. Al

igual que no se define punto en Geometría. Normalmente los símbolos son letras (a, b, c, . . . ,z), dígitos (O, 1,. . ., 9) y otros caracteres (+, -, *, /, ?, ...). Los símbolos también pueden estar formados por varias letras o caracteres, así por ejemplo las palabras reservadas de un lenguaje de programación son símbolos de dicho lenguaje.

Ejemplo 1. Un conjunto de símbolos.

a , b , c , # , O , 1 , + , * ,then, begin, end, else 1.2 Alfabeto

Es un conjunto finito de símbolos, no vació. Para definir que un símbolo a pertenece a un alfabeto V. Los alfabetos se definen por enumeración de los símbolos que contienen, así por ejemplo se presentan a continuación varios alfabetos.

Ejemplo 2. Se muestran algunos tipos de alfabetos.

V1 = {A, B, C, D, E, F, G, H ,..., X, Y, Z} V2 = {a, b, c, d, 0, J , 2 , 3, 4, *, #, +} V3 = { 0, 1 } V4 = {if, then, begin, end, else, a, b, .. , =, >, ; }

También se puede definir las tablas ASCII y EBCDIC como los alfabetos de distintos ordenadores.

CAPITULO 1


-

1.3 Cadena

Una cadena es una secuencia finita de símbolos de un determinado alfabeto. Ejemplo 3. Para estas cadenas hacemos referencia a los alfabetos definidos en

ejemplo 2. ABCD es una cadena del alfabeto V1

a+2*b es una cadena del alfabeto V2

000111 es una cadena del alfabeto V3

if a>b then b=a; es una cadena del alfabeto V4

1.4 Longitud de cadena La longitud de una cadena es el número de símbolos que contiene. La notación

empleada es la que se indica en los siguientes ejemplos. Una cadena o palabra de longitud k de un alfabeto V, es una secuencia de K

símbolos. Y se denota de la siguiente manera. Tenemos la cadena V1V2V3V4… Vk la longitud para esta cadeana es K.

Se representa |V1V2V3V4… Vk | = K

Ejemplo 4. Longitud de cadenas, se utilizan las cadenas del ejemplo 3.

| abcb | =4 |a +2*b | =5 I 000 111 | =6 | if a > b then a = b ; | =9

CAPITULO 1


-

Ejemplo 5. En este ejemplo a partir del alfabeto se muestran algunas cadenas que se pueden formar con diferente longitud. Alfabetos Cadenas

{a} a, aa, aaa, aaaa {a,b} a,b,aabab, donde ab≠ba {a,b,c} abcabc,acb {0,1} 100011,11110

Ejemplo 6.Longitud de cadenas. Encontrar todas las cadenas con longitud 1, 2, 3 en los alfabetos.

Alfabeto Cadenas longitud 1 longitud 2 longitud 3 {a} a aa aaa {0,1} 0,1 01,10,00,11 000,001,010,100 011,101,110,111

1.5 Cadena vacía

Introducimos la cadena única que no contiene símbolos llamada cadena vacía, por :

ε y su longitud es |ε|=0 1.6 Universo del discurso Cerradura de Kleene o Universo de discurso Usamos el símbolo V* para denotar el conjunto de todas las cadenas de V incluyendo a ε. El operador * se llama la “cerradura de Kleene”.

CAPITULO 1


-

Ejemplo 7.

Sea un alfabeto con una sola letra V = { a }, entonces el universo del discurso es :

V* = { ε , a, aa, aaa, aaaa, . . . }

que contiene infinitas cadenas. 1.7 Lenguaje

Se denomina lenguaje sobre un alfabeto V a un subconjunto del universo del discurso. También se puede definir como un conjunto de palabras de un determinado alfabeto.

Alguien puede pensar que los lenguajes se pueden definir por enumeración de las cadenas que pertenecen a dicho lenguaje, pero este método además de ineficiente, es en muchos casos imposible (habitualmente un lenguaje tiene infinitas cadenas). Así los lenguajes se definen por las propiedades que cumplen las cadenas del lenguaje. Ejemplo 7.El conjunto de palíndromos (cadenas que se leen igual hacia adelante, que hacia atrás) sobre el alfabeto {Ø,l}. Evidentemente este lenguaje tiene infinitas cadenas.

Algunas cadenas de este lenguaje son:

ε

0 1 00 11 010 0110 000000 01101 111111

100001 001100 1101011

CAPITULO 1


-

1.8 Lenguaje vació

Existe un lenguaje denominado el lenguaje vacío, que es un conjunto vacío y que se denota por { Ø }. El lenguaje vacío no debe confundirse con un lenguaje que contenga una sola cadena, y que ésta sea la cadena vacía, es decir { ε }, ya que el número de elementos

(cardinalidad) de estos dos conjuntos es diferente. donde ε no nada mas puede ser vacía, puede ser cualquier cadena.

Cardinal ({Ø }) = O

Cardinal ({ε }) = 1

CAPITULO 1


-

-

CAPÍTULO 2

AUTÓMATAS

En este capitulo se explica que es un autómata, así como los diferentes componentes que lo forman. 2.1 Introducción

La palabra autómata evoca algo que pretende imitar las funciones propias de los seres vivos, especialmente relacionadas con el movimiento. En el campo de los Traductores, Procesadores, Compiladores e Intérpretes, lo fundamental no es la simulación del movimiento, sino la simulación de procesos para tratar información.

La información se codifica en cadenas de símbolos, y un autómata es un dispositivo

que manipula cadenas de símbolos que se le presentan a su entrada, produciendo otras tiras o cadenas de símbolos a su salida.

El autómata recibe los símbolos de entrada, uno detrás de otro, es decir

secuencialmente. El símbolo de salida que en un instante determinado produce un autómata, no sólo depende del último símbolo recibido a la entrada, sino de toda la secuencia o cadena, que ha recibido hasta ese instante.

Todo lo anterior conduce a definir un concepto fundamental: estado de un

autómata. El estado de un autómata es toda la información necesaria en un momento dado, para poder deducir, dado un símbolo de entrada en ese momento, cual será el símbolo de salida. Es decir, conocer el estado de un autómata, es lo mismo que conocer toda la historia de símbolos de entrada, así como el estado inicial, estado en que se encontraba el autómata al recibir el primero de los símbolos de entrada.

El autómata tendrá un determinado número de estados (este numero es finito), y se encontrará en uno u otro según sea la historia de símbolos que le han llegado.

Si un autómata se encuentra en un estado determinado, recibe un símbolo también

determinado y efectuará un cambio o transición a otro estado (también puede quedarse en el mismo estado).

CAPITULO 2

AUTÓMATAS

-

El campo de estudio de los Traductores, Procesadores e Intérpretes son los lenguajes y las gramáticas que los generan. Los elementos del lenguaje son sentencias, palabras, etc. formadas a partir de un alfabeto o vocabulario, que no es otra cosa que un conjunto finito de símbolos. Establecidas las reglas gramaticales, una cadena de símbolos pertenecerá al correspondiente lenguaje si tal cadena se ha formado obedeciendo esas reglas. Entonces un autómata reconocedor de ese lenguaje, funciona de tal forma que cuando reciba a su entrada una determinada cadena de símbolos indica si dicha cadena pertenece o no al lenguaje. También se mostrará como existe un tipo de autómata para reconocer cada uno de los tipos de lenguajes generados por las correspondientes gramáticas. 2.2 Definición Autómata finito deterministico Un autómata consiste en una quíntupla (S, V, δ, i, F) donde:

V =conjunto de entradas o alfabeto de entrada S = conjunto finito de estados δ: S x V → S es una función llamada la función de transición i є S: es el estado inicial F є S es el conjunto (posiblemente vació) de estados finales

donde: V es un conjunto finito, y sus elementos se llaman entradas o símbolos de entrada. S es el conjunto de estados finitos δ es la función de transición o función del estado siguiente, y para un par del conjunto S x V devuelve un estado perteneciente al conjunto S. S x V es el conjunto producto cartesiano de V por S. i es el estado inicial siempre el inicio del lenguaje a analizar comienza en este estado. F Es el estado final que indica que el ultimo símbolo del lenguaje llego e este, entonces el lenguaje se dice que es aceptado este estado puede o no tener transición.

CAPITULO 2

AUTÓMATAS

-

2.3 Representación de autómatas

Los autómatas se pueden representar mediante: Tabla de transiciones Diagrama de transiciones

2.3.1 Tabla de transiciones

Las función δ puede representarse mediante una tabla, con tantas filas como estados y tantas columnas como entradas. Así por ejemplo se puede representar el autómata, donde :

V = {a, b}, S = {q1 q2, q3}, i=q1 , F={ q1, q2 ,q3} y las funciones δ se puede representar

por la siguiente tabla la cual se llama tabla de transición:

δ (a, q1)= q1 δ (b, q1)= q2

Así se tiene que δ (a, q2)= q3 δ (b, q2)= q2 δ (a, q3)= q3 δ (b, q3)= q1

2.3.2 Diagramas de transiciones

Los diagramas de transiciones son otra forma de representar las funciones de

transición de un autómata. El diagrama de transición es un grafo orientado en el que cada nodo corresponde a

un estado: Nodo inicial o nodo intermedio Nodo Final

f a b

q1 q1 q2

q2 q3 q2

q3 q3 q1

CAPITULO 2

AUTÓMATAS

-

Y si δ (a , qi) = qj existe un arco dirigido del nodo qj al correspondiente qj sobre el

que se pone la etiqueta ∝, tal y como se muestra en la figura .

Ejemplo 1.

V = {a,b}, S = {q1 q2, q3}, i=q1 , F={ q1, q2 ,q3} y las funciones δ se puede representar por la siguiente tabla de transición:

El lenguaje que podría aceptar este autómata a, ab,aab,aaa, bb,bba,b,babababababa,... es infinito.

f a b

q1 q1 q2

q2 q3 q2

q3 q3 q1

Fig. : Diagrama de transición.

a

qi qj

b

b

a

a

b

q1

q2

q3

Diagrama de transición

Tabla de transición

CAPITULO 2

AUTÓMATAS

a

-

2.4 Autómata Finito No Deterministico Un Autómata Finito No Determinista, que se denotara como AFN, se caracteriza porque en un estado puede haber mas de una transicion posible para un mismo sımbolo de entrada.

Un Autómata Finito No Deterministico (AFD) en una quíntupla (S, V, δ, i, F) donde:

V =conjunto de entradas o alfabeto de entrada S = conjunto finito de estados y no vacio δ: S x V → 2S es una función llamada la función de transición i є S: es el estado inicial F є S es el conjunto (posiblemente vació) de estados finales

Donde el autómata solo acepte un lenguaje finito tal que decimos que una cadena

es aceptada si empezamos en un estado inicial y terminamos en el estado final.

Ejemplo 2. V = {a, b}, S = {q1, q2, q3}, i=q1 , F={q3} y las funciones δ se puede representar por la siguiente tabla de transición:

En este caso las cadenas que son aceptadas por el autómata son las siguientes:

a*aa, a*ba

f a b

q1 q2, q1 q2

q2 q3 -

q3 - -

a,b a q1 q2

Tabla de transición

q3

CAPITULO 2

AUTÓMATAS

a

-

-

CAPITULO 3

ALGORITMOS GENÉTICOS

En este capitulo se explica que es un algoritmo genético, así como su funcionamiento. También se muestra una aplicación de estos. 3.1 Introducción

El algoritmo genético es una técnica de búsqueda basada en la teoría de la evolución de Darwin, que ha cobrado tremenda popularidad alrededor del mundo durante los últimos años. Se presentan aquí los conceptos básicos que se requieren para abordarla, así como un sencillo ejemplo que permita comprender cómo aplicarla al problema de su elección. 3.2 Algoritmos Genéticos 3.2.1 Orígenes.

En los últimos años, la comunidad científica internacional ha mostrado un creciente interés en una nueva técnica de búsqueda basada en la teoría de la evolución y que se conoce como el algoritmo genético. Esta técnica se basa en los mecanismos de selección que utiliza la naturaleza, de acuerdo a los cuales los individuos más aptos de una población son los que sobreviven, al adaptarse más fácilmente a los cambios que se producen en su entorno. Hoy en día se sabe que estos cambios se efectúan en los genes (unidad básica de codificación de cada uno de los atributos de un ser vivo) de un individuo, y que los atributos más deseables (i.e., los que le permiten a un individuo adaptarse mejor a su entorno) del mismo se transmiten a sus descendientes, cuando éste se reproduce sexualmente.

Un investigador de la Universidad de Michigan llamado John Holland estaba consciente de la importancia de la selección natural, y a fines de los 60’s desarrolló una técnica que permitió incorporarla en un programa de computadora. Su objetivo era lograr que las computadoras aprendieran por sí mismas. A la técnica que inventó Holland se le llamó originalmente "planes reproductivos", pero se hizo popular en 1975.

CAPITULO 3


-

3.2.2 Descripción

Los algoritmos genéticos son, a groso modo, un método de optimización: dada una función objetivo, el AG lleva a cabo una búsqueda en el espacio de soluciones intentando encontrar la solución que minimiza dicha función objetivo. Por lo tanto, los algoritmos genéticos están indicados para resolver todo tipo de problemas que puedan ser expresados como un problema de optimización: basta con encontrar la representación adecuada para las soluciones y la función a optimizar.

Básicamente, los algoritmos genéticos funcionan como sigue: dada una población

de soluciones, y en base al valor de la función objetivo para cada una de los individuos (soluciones) de esa población, se seleccionan los mejores individuos (los que minimizan la función objetivo) y se combinan para generar otras nuevos. Este proceso se repite cíclicamente.

Como se pude ver, el proceso es similar al que se da en la naturaleza: una serie

de individuos compiten por su supervivencia; los mejor adaptados al medio (los que optimizan la función objetivo) sobreviven y tienen más posibilidades de aparearse, transmitiendo así parte de su material genético "mejor adaptado" a las generaciones siguientes. De esta manera, generación tras generación, la especie consigue una mayor y mejor adaptación al medio en el que vive. 3.3 Funcionamiento 3.3.1 Bases biológicas

Como ya se ha dicho, los algoritmos genéticos están inspirados en la naturaleza, en la evolución de las especies. Por ello, para comprender su funcionamiento es aconsejable conocer primero cómo funcionan los mecanismos de la evolución desde un punto de vista meramente biológico.

En primer lugar, hay que percatarse de que el primer factor clave en el proceso evolutivo es la presión selectiva que ejerce el medio sobre las poblaciones que lo habitan. Básicamente, ni el espacio vital ni el alimento son suficientes para todos, de modo que algunos individuos, concretamente aquéllos más débiles (o más correctamente, peor adaptados), tienen menos probabilidades de sobrevivir y de aparearse.

CAPITULO 3


-

Se genera así un mecanismo de selección que filtra el conjunto de la población.

Este filtro, el de la adaptación al medio, permite seleccionar a aquellos individuos cuyas características se ajustan mejor a las vicisitudes que plantea la supervivencia en el entorno natural en el que se desarrolla su existencia. Así mismo, se desechan las "soluciones" inadecuadas, esto es, las características de los individuos no adaptados.

Se dijo antes que el primer factor clave en la evolución es la presión selectiva del medio. Pues bien, el segundo factor clave es la información genética y su transmisión entre generaciones. La información genética, codificada en el ADN, describe a un individuo concreto de forma completa, determinando las características que dicho individuo desarrollará a lo largo de su vida. De esta manera, el que un individuo se adapte o no al medio depende básicamente de la información contenida en su material genético. La transmisión de dicha información mediante la reproducción es la que articula el proceso evolutivo, el cual se vale de la recombinación del material genético aportado por los progenitores para "ensayar" nuevos conjuntos de características, generando así una descendencia que hereda en lo posible todas aquéllas que resultan ventajosas.

Todos los seres vivos están formados por células. En cada célula hay el mismo número de cromosomas. Los cromosomas son cadenas de ADN y definen cómo es un ser vivo. Un cromosoma se divide en genes (bloques de ADN). Cada gen codifica una proteína particular. Se puede decir que cada gen codifica una característica de un ser vivo (Por ejemplo el color de ojos).

Al conjunto de todos los cromosomas se denomina genoma. Cada ser vivo posee un conjunto de cromosomas particular, diferente en mayor o menor medida del resto de seres vivos, incluso de su especie. A este conjunto se denomina genotipo. A la manifestación externa (Color de ojos, inteligencia...) del genotipo en un ser vivo se llama fenotipo.

Al reproducirse los seres vivos ocurre en primer lugar el proceso que se denomina cruce: los genes de los padres se combinan para generar un nuevo cromosoma (retoño o offspring). Este nuevo cromosoma puede sufrir ahora el proceso llamado mutación. Los genes sufren cambios, normalmente por errores al ser copiados de sus padres.

Otro concepto interesante es el fitness (grado de adaptación al entorno) de un ser vivo: El fitness es una medida de lo bueno que es un individuo según su grado de adaptación al entorno. Si es adapta bien, se puede asegurar su supervivencia y por tanto tendrá un fitness mayor.

CAPITULO 3


-

De este modo, a lo largo de generaciones sucesivas, el material genético de los

individuos mejor adaptados prevalece, generándose en cada ciclo reproductor individuos mejor adaptados, en promedio, que aquéllos de los que descienden. 3.4 Algoritmo Genético

Podemos decir que un Algoritmo Genético es un procedimiento de resolución de problemas que se basa en los métodos de Evolución Genética de los seres vivos para solucionar problemas de búsqueda (en cuyo proceso analiza las posibles soluciones para el problema) y optimización (la cual encuentra el mejor resultado para un problema específico).

Los algoritmos Genéticos están basados en integrar e implementar eficientemente dos ideas fundamentales:

1. Las representaciones simples como cadenas binarias de las soluciones del problema.

2. La realización de transformaciones simples para modificar y mejorar estas representaciones.

Un Algoritmo Genético debe especificar los siguientes elementos:

Una representación de individuos (cromosomas). Una población inicial Una medida de evaluación Un criterio de selección / eliminación de cromosomas Una o varias operaciones de recombinación Una o varias operaciones de mutación

Las decisiones que hay que tomar para implementar un algoritmo genético son:

Criterio de codificación. Como se va a almacenar la información en el genoma (Individuo).

Criterio de tratamiento de individuos no factibles. Como se van a tratar a los individuos que no cumplan las restricciones.

Criterio de inicialización. Cómo se va a construir la población inicial del algoritmo genético.

Criterio de parada. Determina cuándo el algoritmo ha llegado a una solución aceptable.

Función de adaptación. Corresponde a la función de costo de la investigación operativa tradicional, también llamada fitness.

CAPITULO 3


-

Operadores genéticos. Se emplean para determinar cómo va a ser la nueva generación. Básicamente son los operadores de cruzamiento y mutación. Tanto el cruzamiento como la mutación pueden ser realizados de muchas formas distintas.

Criterios de reemplazo. Los criterios que determinan quiénes se van a cruzar. No tienen que ser obligatoriamente los mismos que los criterios de selección de los padres.

Parámetros de funcionamiento. Determinados parámetros que, sin poder ser englobados en ninguno de los anteriores, son fundamentales para el funcionamiento de un algoritmo genético.

3.5 Descripción algorítmica

A continuación se describe un algoritmo genético básico. Las similitudes con el proceso natural de la evolución son evidentes pero, de todos modos, se expondrán a medida que surjan.

En primer lugar, debe definirse el problema. Para que el AG funcione, será necesario dar una función que permita medir cómo de acertada es una solución respecto a otra. En otros términos, el problema debe poder definirse como un problema de minimización (o maximización) de una función objetivo, que representa la presión selectiva del medio.

En segundo lugar, deberá especificarse la manera de codificar las soluciones. Lo más usual es escoger una representación en forma de cadena de binaria. La interpretación que se dé a esa cadena dependerá de la naturaleza de la solución (puede ser la codificación de un valor entero, de un real, una ristra de valores booleanos...)

Una vez se conoce el problema y la manera de representar sus soluciones, se procede a implementar el AG. Para facilitar la comprensión de la explicación que sigue, se expondrá mediante pseudocódigo, el cual se comentará a continuación.

CAPITULO 3


-

1. Inicializar la población 2. Selección

1. Aplicar función objetivo 2. Seleccionar individuos para el cruce

3. Cruce 4. Mutación 5. Inserción 6. Si se_cumple_criterio_parada entonces parar otro caso volver a 2

En primer lugar (1) se procede a la inicialización de la población. Para cada

individuo de la población se selecciona un valor completamente aleatorio. Después se aplica a cada individuo la función objetivo (2.1), lo que da una medida de lo adaptado que está cada uno de ellos. Se seleccionan entonces los individuos que se van a cruzar (2.3). Suponiendo que se han seleccionado dos, se procede a cruzarlos (3): se escoge un punto de corte, y la cadena de números binarios que representa a cada progenitor se divide en dos por ese punto. A continuación se generan dos individuos nuevos uniendo las subcadenas generadas como se muestra en la siguiente figura:

Progenitores: 00110101 01110011 ^ Corte: 001 10101 011 10011 Cruce: 001 10011 011 10101 Descendencia: 00110011 01110101

En el paso 4 se genera en la descendencia una mutación en un gen (bit) aleatorio. Esto sucede con una probabilidad baja (esto es, en la mayoría de los casos, el paso 4 no tiene efecto).

CAPITULO 3


-

Una vez se ha generado la descendencia, deberá insertarse en la población (5).

Para llevar a cabo la inserción existen diversas políticas. Una de ellas consiste simplemente en eliminar los dos individuos peor adaptados e insertar los recién generados.

Por último, en el paso 6 se comprueba si alguno de los individuos disponibles satisface los criterios establecidos y se puede considerar como solución al problema. En este paso también se puede comprobar si se ha excedido un número de iteraciones o un límite de tiempo. Si no es así y ningún individuo cumple los criterios de parada, se vuelve al paso 2. 3.6 ¿Cómo saber si es posible usar el Algoritmo Genético?

La aplicación más común de los algoritmos genéticos ha sido la solución de problemas de optimización, en donde han mostrado ser muy eficientes y confiables. Sin embargo, no todos los problemas pudieran ser apropiados para la técnica, y se recomienda en general tomar en cuenta las siguientes características del mismo antes de intentar usarla:

Su espacio de búsqueda (i.e., sus posibles soluciones) debe estar delimitado dentro de un cierto rango.

Debe poderse definir una función de aptitud que nos indique qué tan buena o mala es una cierta respuesta.

Las soluciones deben codificarse de una forma que resulte relativamente fácil de implementar en la computadora.

El primer punto es muy importante, y lo más recomendable es intentar resolver problemas que tengan espacios de búsqueda discretos, aunque éstos sean muy grandes. Sin embargo, también podrá intentarse usar la técnica con espacios de búsqueda continuos, pero preferentemente cuando exista un rango de soluciones relativamente pequeño.

mutación (2º bit) 00110011 ===================> 01110011

CAPITULO 3


-

El algoritmo genético únicamente maximiza, pero la minimización puede realizarse fácilmente utilizando el recíproco de la función maximizante (debe cuidarse, por supuesto, que el recíproco de la función no genere una división por cero). Una característica que debe tener esta función es que debe ser capaz de "castigar" a las malas soluciones, y de "premiar" a las buenas, de forma que sean estas últimas las que se propaguen con mayor rapidez.

La codificación más común de las respuestas es a través de cadenas binarias, aunque

se han utilizado también números reales y letras. El primero de estos esquemas ha gozado de mucha popularidad debido a que es el que propuso originalmente Holland, y además porque resulta muy sencillo de implementar.

3.7 Selección

Como ya se ha visto los individuos se seleccionan para reproducirse, ahora bien el problema está en cómo seleccionar. De acuerdo con la teoría de la evolución de Darwin, sólo los mejores individuos se reproducen. Basándose en esto existen varios métodos que son utilizados por los genéticos: Selección por la Regla de la Ruleta, Selección por Ranking, Selección de Estado Fijo por citar algunos de los más utilizados.

3.7 .1 Selección por la Regla de la Ruleta

Los padres se seleccionan de acuerdo a su fitness. Los individuos mejores (con mayor fitness) son los que tienen mayores posibilidades de ser elegidos. Intuitivamente el proceso construye una ruleta o un "tarta" en la que cada uno de las porciones representa a un individuo. La porción de tarta que le toca a cada individuo es proporcional a su fitness. Así los individuos buenos se llevarán las mayores porciones y al revés ocurrirá con los peores. El siguiente ejemplo clarifica el proceso:

CAPITULO 3


-

Ahora, al igual que en un casino se lanza a la ruleta una canica. En el lugar que pare dicha canica, será un lugar ocupado por un cromosoma que será elegido. Resulta claro que los individuos con mayor fitness son los que más a menudo son elegidos.

Existe un algoritmo para realizar este proceso:

1. [SumaTotal] Calcular la suma total acumulada de los fitness de todos los individuos de la población actual.

2. [Elegir un número aleatorio r] Generar un número aleatorio entre 0 y la SumaTotal.

3. [Recorrer] Recorrer la población acumulando nuevamente los fitness. Cuando la suma que se lleve sea mayor o igual a r seleccionamos el individuo donde se vaya recorriendo.

3.7.2 Selección por Ranking

El anterior tipo de selección funciona mal cuando existan grandes diferencias entre los fitness de los individuos de la población. Por ejemplo si un cromosoma ocupa el 90% de la ruleta el resto de los cromosomas tienen muy pocas posibilidades de ser elegidos. La selección por ranking da solución a este problema.

Los individuos son ordenados de acuerdo a su ranking de fitness. De esta manera si tenemos n cromosomas el individuo con peor fitness se le asignará un 1 y el que tenga el mejor fitness se le asignará la n.

Véase en las dos siguientes figuras cómo cambia la situación antes y después del ranking.

Situación antes del Ranking (Ruleta)

CAPITULO 3

ALGORITMOS GENETICOS

-

Situación después del Ranking

Ahora todos los cromosomas tienen la oportunidad de ser seleccionados. Sin embargo este método puede hacer que el genético converja lentamente a la solución, ya que los mejores individuos no se diferencian apenas de los peores.

A este esquema se le pueden aplicar otros criterios; por ejemplo, se crea la descendencia de uno de los paladines/amazonas, y esta sustituye al más parecido entre los perdedores. Esto se denomina crowding, y fue introducido por DeJong. Una variante de este es el muestreado estocástico universal, que trata de evitar que los individuos con más fitness copen la población; en vez de dar la vuelta a una ruleta con una ranura, da la vuelta a la ruleta con N ranuras, tantas como la población; de esta forma, la distribución estadística de descendientes en la nueva población es más parecida a la real.

3.7.3 Selección de Estado Fijo

No es un tipo específico de selección de padres. La principal idea de este tipo de selección es que un gran número de individuos de la actual pasarán sin modificar a la siguiente generación.

Un AG de selección de estado fijo funciona del siguiente modo: En cada generación se eligen unos pocos cromosomas con alto fitness para reproducir. Los peores individuos de la actual generación son eliminados y los nuevos individuos ocupan su lugar. El resto de individuos pasan sin modificar a la siguiente generación.

3.8 Elitismo

Este concepto expresa la idea de que el mejor individuo de la actual generación pase sin modificar a la siguiente generación. De esta forma no se perderá el mejor cromosoma. Al resto de la población se le aplica la reproducción normalmente.

CAPITULO 3


-

Por otra parte existen algoritmos genéticos llamados elitistas debido a que convergen muy rápidamente a la solución. Esto se debe al tipo de problema que se trate. Más adelante se verá un caso concreto El problema del coloreamiento de un grafo.

3.9 Operadores de un AG 3.9.1 Operador de cruce

Los operadores de cruce tratan de crear una generación de individuos nuevos pidiendo información a sus ancestros. Aunque estos operadores parecen corresponderse con la representación basada en precedencia, realizando un estudio más minucioso se observa que su funcionamiento está influenciado por otros factores.

3.9.2 Cruce en un punto

Se copian los genes del primer padre hasta el punto de corte y se rellena con el resto de elementos que hagan la solución válida en el orden en que aparecen en el segundo padre considerando la cadena de genes como cíclica. En el caso de que se haya utilizado una codificación binaria simplemente se copian el resto de genes del segundo padre.

11001011+11011111 = 11001111

(1 2 3 4 5 6 7 8 9) + (4 5 3 6 8 9 7 2 1) = (1 2 3 4 5 6 8 9 7)

3.9.3 Cruce en dos puntos

Se copian los genes del primer padre comprendidos entre los dos puntos de cruce y se rellenan los que faltan con los del segundo padre considerando la cadena de genes como cíclica.

11001011 + 11011111 = 11011111

CAPITULO 3


-

3.9.4 Cruce uniforme

No se puede aplicar a la representación basada en permutaciones. Se escoge aleatoriamente si el gen i-ésimo del hijo se toma del primer o del segundo padre.

11001011 + 11011101 = 11011111

3.9.5 Cruce aritmético

No se puede aplicar a la representación basada en permutaciones. Se realizan operaciones aritméticas con los genes de los padres para resultar la codificación genética del hijo.

11001011 + 11011111 = 11001001 (AND)

3.10 Operador de mutación 3.10.1 Inversión de genes

Se seleccionan genes aleatoriamente y se invierte su valor. Se utiliza en representaciones de bits, cambiando 0s por 1s o viceversa.

11001001 => 10001001

CAPITULO 3


-

3.10.2 Cambio de orden

Se seleccionan dos genes aleatoriamente y se intercambian sus posiciones. Se utiliza en representaciones basadas en permutaciones.

(1 2 3 4 5 6 8 9 7) => (1 8 3 4 5 6 2 9 7)

3.10.3 Modificación de genes

Se realizan pequeñas modificaciones en los genes. Por ejemplo en una codificación basada en números reales se realizan sumas de números muy pequeños positivos o negativos.

(1.29 5.68 2.86 4.11 5.55) => (1.29 5.68 2.73 4.22 5.55)

3.11 Parámetros de los AGs 3.11.1 Porcentaje de Cruce (Pc)

Indica con qué frecuencia se cruzarán los individuos. Si éste es 0% , los hijos serán como los padres y sólo serán alterados por la mutación. Si éste es 100% todos los individuos nuevos serán creados mediante cruce de los padres de la generación previa. Cuanto más se crucen los individuos se supone que los hijos serán mejores. Sin embargo es recomendable, por la naturaleza del genético, que algunos individuos pasen sin modificar a la siguiente generación.

CAPITULO 3


-

3.11.2 Porcentaje de Mutación (Pm)

Establece la probabilidad con la cual los individuos serán mutados. Si éste porcentaje es 0% los individuos generados después de aplicarse el cruce no sufrirán ningún cambio por el contrario si es de 100% todos lo individuos de la población sufrirán cambios o mutaciones. La mutación trata de impedir que la búsqueda del genético caiga en extremos locales por eso es conveniente que ocurra de vez en cuando. No es bueno, sin embargo, que la mutación ocurra continuamente, ya que la búsqueda del genético pasa de ser "inteligente" a búsqueda aleatoria.

3.11.3 Tamaño de la Población (tam-pob)

Establece cuántos individuos habrá en cada una de las generaciones. Si el tamaño de la población es muy bajo, el algoritmo genético tiene pocas posibilidades de evolucionar por el cruce y los los individuos nuevos se parecerán mucho a sus padres. Tampoco un tamaño excesivo es adecuado porque se llega a un punto en el que los resultados no mejoran por mucho que se incremente el tamaño de la población. Lo ideal es, en función del problema y la codificación, establecer un límite adecuado del tamaño de la población.

3.11.4 Número de Generaciones (nro-gen)

Con el paso de las generaciones la población del genético evolucionará obteniendo cada vez mejores individuos. Conviene, al igual que con el tamaño de la población, fijar un número de generaciones adecuado para conseguir el resultado deseado.

3.11.5 Tamaño del Individuo (tam-ind)

Dependerá del número de elementos que constituyan una solución. Varía con el problema a resolver.

3.12 Representación del genotipo

Es esencial distinguir en una solución a un problema entre el genotipo y el fenotipo. El genotipo es la representación interna que nosotros utilizamos para trabajar con la solución, mientras que el fenotipo es la solución en sí misma. Los operadores del algoritmo trabajarán con el genotipo. Se ha de elegir una representación para el genotipo:

CAPITULO 3


-

3.12.1 Representación Binaria

La representación binaria es la más común. En ella, un cromosoma es una cadena de bits 0 ó 1. Las primeras investigaciones en genéticos utilizaron este tipo de codificación debido a su sencillez. Es una representación indirecta.

CROMOSOMA A 101100101100101011100101

CROMOSOMA B 111111100000110000011111 3.12.2 Representación Directa

En este tipo de representación se usa directamente en problemas que utilizan valores difíciles de representar. Por ejemplo si se usan número reales. Se trata de problemas en los que una codificación binaria sería demasiado complicada.

Cada cromosoma es una secuencia de valores. Los valores son cualquier cosa relacionada con el tipo problema.(Números reales, caracteres u otros tipos de objetos).

CROMOSOMA A

1.2324 5.3243 0.4556 2.3293 2.4545

CROMOSOMA B

ABDJEIFJDHDIERJFDLDFLFEGT

CROMOSOMA C

(atrás), (atrás), (derecha), (hacia delante), (izquierda)

3.13 Ejemplo de un Algoritmo Genético Vamos a partir de una función f(x) muy sencilla:

f(x)=x^2 (es decir, x al cuadrado).

CAPITULO 3


-

Queremos encontrar el valor de x que hace que la función f(x) alcance su valor

máximo, pero restringiendo a la variable x a tomar valores comprendidos entre 0 y 31. Aún más, a x sólo le vamos a permitir tomar valores enteros, es decir: 0,1,2,3,...,30, 31. Obviamente el máximo se tiene para x = 31, donde f vale 961. No necesitamos saber algoritmos genéticos para resolver este problema, pero su sencillez hace que el algoritmo sea más fácil de comprender.

Lo primero que debemos hacer es encontrar una manera de codificar las posibles

soluciones (posible valores de x). Una manera de hacerlo es con la codificación binaria. Con esta codificación un posible valor de x es:

(0, 1, 0, 1, 1) Se comienza de derecha a izquierda se multiplica la última componente ( 1 * 20 ) + ( 1 * 21 ) + ( 0 * 22 ) + ( 1 * 23 ) + ( 0 * 24 ) y la suma es 11. Observa que (0, 0, 0, 0, 0) equivale a x=0 y que (1,1,1,1,1) equivale a x = 31. A cada posible valor de la variable x en representación binaria le vamos a llamar individuo. Una colección de individuos constituye lo que se denomina población y el número de individuos que la componen es el tamaño de la población. Una vez que tenemos codificada la solución, debemos escoger un tamaño de población, para este ejemplo utilizamos 6 individuos.

Debemos partir de una población inicial. Una manera de generarla

es aletoriamente. Nuestro siguiente paso es hacer competir a los individuos entre sí. Este proceso

se conoce como selección. La tabla 1 resume el proceso.

CAPITULO 3


-

Cada fila en la tabla 1 está asociada a un individuo de la población inicial. El significado de cada columna de la tabla es el siguiente:

(1) = Número que le asignamos al individuo.

(2) = Individuo en codificación binaria.

(3) = Valor de x.

(4) = Valor de f(x).

Observa que el mejor individuo es el 5 con f = 676. Calcula la media de f y obtendrás f_med =324.3. Una manera de realizar el proceso de selección es mediante un torneo entre dos. A cada individuo de la población se le asigna una pareja y entre ellos se establece un torneo: el mejor genera dos copias y el peor se desecha. La columna (5) indica la pareja asignada a cada individuo, lo cual se ha realizado aleatoreamente. Existen muchas variantes de este proceso de selección. Después de realizar el proceso de selección, la población que tenemos es la mostrada en la columna (2) de la tabla 2. Por ejemplo, que en el torneo entre el individuo 1 y el 6 de la población inicial, el primero de ellos ha recibido dos copias, mientras que el segundo cae en el olvido.

Tabla 1 – SELECCIÓN (1) (2) (3) (4) (5)

1 (0,1,1,0,0) 12 144 6

2 (1,0,0,1,0) 18 324 3

3 (0,1,1,1,1) 15 225 2

4 (1,1,0,0,0) 24 576 5

5 (1,1,0,1,0) 26 676 4

6 (0,0,0,0,1) 1 1 1

CAPITULO 3


-

Tras realizar la selección, se realiza el cruce. Una manera de hacerlo es mediante el cruce 1 X: se forman parejas entre los individuos aleatoriamente de forma similar a la selección. Dados dos individuos pareja se establece un punto de cruce aleatorio, que no es más que un número aleatorio entre 1 y 4 (la longitud del individuo menos 1). Por ejemplo, en la pareja 2-3 el punto de cruce es 3, lo que significa que un hijo de la pareja conserva los tres primeros bits del padre y hereda los dos últimos de la madre, mientras que el otro hijo de la pareja conserva los tres primeros bits de la madre y hereda los dos últimos del padre. La población resultante se muestra en la columna (2) de la tabla 3.

(1) (2) (3) (4)

1 (0,1,0,1,0) 10 100

2 (1,1,1,0,0) 28 784

3 (0,1,1,1,0) 14 196

4 (1,0,0,0,0) 16 256

5 (1,1,0,1,0) 26 676

6 (1,0,0,1,0) 18 324

Tabla 2 - CRUCE

(1) (2) (3) (4)

1 (0,1,1,0,0) 5 1

2 (0,1,1,0,0) 3 3

3 (1,0,0,1,0) 2 3

4 (1,0,0,1,0) 6 1

5 (1,1,0,1,0) 1 1

6 (1,1,0,1,0) 4 1

CAPITULO 3


-

En la columna (3) tiene el valor de x; en la siguiente tiene el valor de f

correspondiente.

Ahora el valor máximo de f es 784 (para el individuo 2), mientras que antes de la selección y el cruce era de 676. Además f_med ha subido de 324.3 a 389.3. Se observa que los individuos después de la selección y el cruce son mejores que antes de estas transformaciones.

El siguiente paso es volver a realizar la selección y el cruce tomando como población inicial la de la tabla 3. Esta manera de proceder se repite tantas veces como número de iteraciones. ¿Y cuál es el óptimo?. En realidad un algoritmo genético no te garantiza la obtención del óptimo pero, si está bien construido, te proporciona una solución razonablemente buena. Puede que se obtenga el óptimo, pero el algoritmo no confirma que lo sea. Así que se queda con la mejor solución de la última iteración.

También es bueno ir guardando la mejor solución de todas las iteraciones anteriores y al final quedarte con la mejor solución de las exploradas. 3.14 APLICACIÓN DE LOS ALGORITMOS GENÉTICOS

3.14.1 El problema

Esta aplicación consiste en encontrar el máximo de una función utilizando un algoritmo genético. El dominio de las variables de la función son mapeados a un dominio entre 0 y 1, utilizando una transformación lineal. 3.14.2 Implementación

Se utiliza una población de 25 individuos. Se utiliza una codificación basada en cadenas binarias.

Se hicieron dos versiones para esta aplicación la diferencia entre ellas es la forma en que se seleccionan los individuos para formar la nueva generación.

El tipo de cruzamiento es de dos puntos, los dos individuos que se van a cruzar se escogen aleatoriamente.

CAPITULO 3


-

La mutación es la siguiente, una variable se muta (cambiar de 0 a 1 o viceversa)

si un número aleatorio x (que esta entre 0 y 1) es menor que la probabilidad de mutación.

Para la primera versión se seleccionan por medio de la ruleta, para la segunda versión se seleccionan a dos individuos contiguos y sobrevive el que mejor se adapte al entorno.

El programa escribe en un archivo quien fue el mejor individuo, así como su valor de adaptación (fitness). 3.14.3 Funciones que se utilizaron 3.14.3.1 initialize():

Procedimiento initialize: Inicializa los valores de los genes, así como los valores fitness para cada individuo de la población. Lee los limites inferior y superior de cada variable de el "archivo gadata.txt". El formato del archivo de entrada "gadat.txt" es el siguiente: var1_limite_inferior var1_limite_superior

var2_limite_inferior var2_limite_superior .... 3.14.3.2 evaluate():

Procedimiento evaluate: Evalúa cada uno de los individuos en una función. La

función para este ejemplo es x2-x*y+z. 3.14.3.3 keep_the_best();

Procedimiento keep_the_best: Esta función guarda el mejor individuo de la población. En la última entrada en el arreglo population se tiene una copia del mejor individuo. 3.14.3.4 select();

Este procedimiento selecciona a los individuos que estarán en la siguiente

generación. Como se menciono arriba se hicieron dos versiones utilizando diferente tipo de selección.

CAPITULO 3

APLICACIÓN ALGORITMOS GENÉTICOS

-

3.14.3.5 crossover();

Procedimiento crossover: Selecciona dos individuos para cruzarlos utilizando el cruzamiento de dos puntos. 3.14.3.6 mutate();

Procedimiento mutate: Manda a todos los individuos de la población a al procedimiento mutar el cual es el que se encarga de mutar al individuo. 3.14.3.7 report();

Procedimiento report: Reporta los progresos de la simulación, mandándolos a un archivo de salida "Galog.txt". 3.14.3.8 evaluate();

Procedimiento evaluate: Se evalua cada uno de los individuos en la función.

3.14.3.9 elitist():

Procedimiento elitist: El mejor individuo de la generación anterior es guardado en la última casilla del arreglo. Si el mejor individuo de la generación reciente es peor que el mejor individuo de la generación anterior, entonces se reemplaza el mejor individuo de la generación anterior por el mejor individuo de la generación reciente. 3.14.3.10 Resultados El archivo de entrada es el siguiente:

-4 4 -3 3 -5 5

CAPITULO 3


-

Resultados de la Primer versión: El máximo se alcanza en la generación 78 y es el siguiente: mejor individuo es : 0000001010100100011110101001011111010000100011010111111110011001101000 00011100001000010001100110 x=4.000 y=-2.847 z=4.771 fitness = x^2 - x*y + z = 32.156 Resultados de la Segunda versión: El máximo se alcanza en la generación 61 y es el siguiente: mejor individuo: 111110101101110001111000010100100001000110001110010101001100110010100000001011001011000000111110 x=3.989 y=-2.962 z=3.490 fitness = x^2 - x*y + z =31.216 3.14.3.11 Conclusiones

Con los resultados se puede concluir que la segunda versión que se implemento es la más eficiente ya que el número máximo que encontró es el máximo de las dos versiones además de que este número se alcanza en la generación 61.

CAPITULO 3


-

-

CAPITULO 4

APLICACIÓN DE ALGORITMOS GENÉTICOS PARA EL APRENDIZAJE DE AUTÓMATAS FINITOS.

En este capitulo se describe el análisis del algoritmo genético para el

aprendizaje de autómatas finitos deterministico (AFD). El autómata que se espera obtener es que reconozca un conjunto de cadenas en español, el cual estará en un archivo.txt. 4.1 Introducción

La aplicación que se desarrollo esta basada en el modelo de Anja Belz este modelo fue desarrollado para el reconocimiento de cadenas en RUSSO . Aprendizaje del autómata genético

Los componentes de un algoritmo genético simple son usados en el algoritmo del aprendizaje del autómata genético.

El Aprendizaje del Autómata Genético (AAG) es una aplicación genética de búsqueda genética de generalización del idioma regular descrito en el capitulo 2 . Usa un nuevo esquema para la representación del genotipo, una nueva composición para la función aptitud compuesta, un nuevo operador de cruzamiento y 2 nuevos operadores de problemas específicos que incrementa la eficacia con el cual se exploran los espacios de búsqueda. El efecto combinado de los componentes uso en AAG es mostrar una gramática que aprende. Representación del genotipo del autómata

CAPITULO 4 APLICACIÓN DE ALGORITMOS GENÉTICOS PARA EL APRENDIZAJE DE AUTÓMATAS FINITOS

Figura 1. Es un ejemplo de lenguajes de cadenas con 3 lenguajes ab cd ef

-

Figura 2. Muestra el AFD mínimo que reconoce las cadenas de la figura 1.

Por la convención descrita en el capitulo 2 un autómata se denota como una quíntupla : i, V, F,δ,S, donde : i={0} , Q={0,1,2,3,4} , V={a,b,c,d,e,f} , F={4} La función de transición δ puede ser representada por la matriz de transición mostrada en la figura3. Figura3. Matriz de transición para δ

δ(SxV) a b c d e f 0 1 - 2 - 3 - 1 - 4 - - - - 2 - - - 4 - - 3 - - - - - 44 - - - - -

Las casillas de la matriz que tienen un guión indican que no hay

ninguna transición de un estado vía un símbolo dado.

4

1

0

3

2

a b

cd

e f

CAPITULO 4

APLICACIÓN DE ALGORITMOS GENÉTICOS PARA EL APRENDIZAJE DE AUTÓMATAS FINITOS

-

El esquema del genotipo para el AFD es usado en AAG directamente de la

matriz de transición. El genotipo equivale al ejemplo anterior que se muestra en la figura 3. Los genotipos son vectores de una dimensión dentro de una lista (este ejemplo se muestra en dos dimensiones para la facilidad de comparar la representación de la matriz de la figura 3). Los nombres de los estados y el alfabeto de entrada de la matriz de transiciones no se ponen explícitamente en código, solo existen implícitamente como índices de acceso a los genes individuales. La matriz de este genotipo difiere de la matriz de la figura 3 porque adiciona una columna la cual guarda información acerca del conjunto de estados finales. Esta considerada como una columna de etiquetas que indican que el estado es final si tiene un valor de –1 y no final si tiene un valor de 1. Las columnas restantes contienen las transiciones vía un elemento, el –1 nos indica que no hay transición. El estado inicial ( estado cero ) nunca puede ser estado final, el número de estados es variable. El esquema para el AAG lo muestra la figura4.

Figura 4.matriz de transición para AAG.

f/n a b C d e f 1 1 -1 2 -1 3 -11 -1 4 -1 -1 -1 -11 -1 -1 -1 4 -1 -11 -1 -1 -1 -1 -1 4 -1 -1 -1 -1 -1 -1 -1

4.2 Estructura de la población

La población es representada por una matriz de tamaño N x N donde N = 2, 3, 4, 5, 6, 7, 8.

La matriz es interpretada como un modelo torus, es decir cada individuo tiene 8 vecinos.

CAPITULO 4


-

Cada celda de la matriz representa un individuo.

Figura5. Modelo Torus

La figura 5 muestra un ejemplo para tres vecindades en una población de tamaño de 8 X 8. La vecindad del individuo 40 esta formada por los individuo 24, 31, 32, 33, 39, 41, 47, 48; como se puede observar cada uno de los individuos tiene 8 vecinos debido a la interpretación del modelo torus.

Estructurando la población de esta manera se reduce la velocidad de reproducción de individuos a través de una población. Esto tiene efecto que compitiendo con soluciones ( con valores de aptitud similares) pueda durante algún tiempo vaya evolucionando en paralelo dominando una mejor aptitud y eliminando las peores aptitudes dentro de la población. Estructura y pseudocódigo del AAG se muestra en la figura 6.

Individuo 1

individuo 40

CAPITULO 4


-

Se observa que en la figura6. el pseudocódigo del procedimiento AAG empieza por la inicialización de la población inicial; es decir, se crea cada individuo aleatoreamente (línea 3), posteriormente cada individuo se valida (línea 4) y se evalúa ( línea 5); se reproducen las nuevas generaciones hasta cumplir la condición de paro que es alcanzando el número máximo de generaciones especificado (línea 7), para producir una nueva población cada individuo (pi) de la población actual (línea 9) se convierte en el padre 1 (línea 10), se determina la vecindad del individuo pi (línea 11), el padre 2 es el mejor individuo de la vecindad (línea 12). Un hijo se produce de los dos padres por el cruzamiento con una probabilidad de cruzamiento dada (líneas 13 - 17), muta (línea 18), valida (línea 19), evalúa (línea 20). Si el hijo tiene un mejor fitness que el padre 1, el hijo reemplaza al individuo pi en la población (líneas 21 - 23). Se definen los parámetros correspondientes y los operadores adicionales state_split() y state_merge() son aplicados (líneas 25 - 32). Cuando todos los individuos de la población han sido considerados hay una nueva población y el ciclo de la próxima generación comienza (línea 7).

CAPITULO 4


-

Figura6. Procedimiento 1 AAG

Procedimiento 1 AAG 1: generación 0 2: para toda la población haz 3: iniciliza_población 4: valida_población 5: evalua_poblacion 6: fin para 7: mientras (no condicion de paro) haz 8: incrementa generación 9: para toda la población haz 10: padre1 (pi) 11: selecciona_vecino 12: padre2 <- mejor_vecino 13: Si random(0,1) > probabilidad_cruzamiento entonces 14: hijo <- padre1 15: en otro caso 16: hijo <- cruzamiento(padre1,padre2) 17: fin si 18: muta(hijo) 19: valida(hijo) 20: evalua(hijo) 21: Si fitness (padre1) < fitness (hijo) entonces 22: remplaza (padre1,hijo) 23: fin si 24: fin para 25: Si pobabilidad_statemerge entonces 26: state_merge() 27: fin si 28: Si probabilidad_statesplit entonces 31: state_split() 32: fin si 33: fin mientras

CAPITULO 4


-

4.3 Inicialización El número de estados de cada individuo en la población inicial es determinado aleatoreamente dentro de un rango pequeño [ Min , Max ] (experimentos hechos por Anja Belz muestran que se trabaja bien con el rango que esta entre [2 ,4] ); la matriz de transiciones de cada individuo es generada aleatoreamente con números entre –1 y el número de estados que tiene el individuo, la primer columna toma valores de –1 (estado final) y 1(estado no final). 4.4 Selección y reemplazo En cada iteración de la generación cada individuo es considerado como el padre 1, el padre 2 es considerado como el mejor vecino del padre 1 (considerando que puede ser el mismo). La estrategia de reemplazo es que el hijo reemplaza al padre 1 si su fitness es mayor y el hijo toma la posición del padre1 en la población. 4.5 Función de evaluación (fitness) El lenguaje en el AAG restringe las soluciones de los idiomas a ser finito y la solución del AFD a ser no cíclico. Si el lenguaje generado por el autómata no es finito o es cíclico, la función valida garantiza que el lenguaje generado por el autómata es no cíclico y finito. La definición de la función de evaluación esta formada por tres criterios: C1(consistencia), C2(tamaño) y C3(generalización). Al combinarse estos tres criterios el problema radia en como combinarlos para obtener un solo valor de fitness. Los experimentos de Anja Belz mostraron que para cada criterio se multiplica por un peso y el resultado es la suma total de cada criterio. F (i) = w1 C1 + w2 C2 + w3 C3

CAPITULO 4


-

4.5.1 Consistencia (C1): Un autómata cuando es generado es muy difícil que acepte en primera instancia todas las cadenas que se esperan, por esta razón una letra de cada cadena que es aceptada por el autómata es premiada, además se toma en cuenta si se acepta la cadena. Una cadena es aceptada si el número de letras que el autómata acepta es igual a la longitud de la cadena y se termina en estado final. Cada letra aceptada se premia con valor de una unidad y si la cadena se acepta se le da una unidad más. La función sería la siguiente: letras_aceptadas + β C1individual= ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ longitud_cadena +1 donde: β = 1 si es aceptada la cadena (si letras_aceptadas=longitud_cadena y si se termina en estado final ) β = 0 en otro caso La función es normalizada, por lo que esta regresará a lo más un valor de 1 y este es cuando se acepte la cadena. C1total sería la suma de todos los valores que regresa la función C1individual al aplicarse a cada una de las cadenas. Sea N el número total de cadenas que tiene el archivo, por lo tanto. N

C1total=∑ C1individual ( i )

i=1

Ejemplo. Considérense las 3 cadenas y el autómata siguiente: ab, cd, ef

1

0

3

2

a b

c d

e f

4

Como se puede observar el autómata acepta las tres cadenas, por lo que al aplicar la función esta regresara un valor para C1total=3. A continuación se explica como se obtuvo este valor.

CAPITULO 4


-

La cadena ab regresa un valor C1individual=1, al sustituir los siguientes valores en la función C1individual vemos el porque de ese valor. letras_aceptadas=2, longitud_cadena=2 y β=1 ya que es aceptada la cadena 2+1 C1individual= ⎯⎯⎯⎯ = 1 2+1 C1individual se aplica a las otras dos cadenas que de igual manera que la primera son aceptadas por el autómata, por lo tanto cada una tiene un valor de C1individual=1. Como se menciono arriba C1total es la suma del valor que regresa C1individual al aplicarse a cada una de las cadenas, por lo tanto C1total = 1(ab) + 1(cd)+ 1(ef) = 3 4.5.2 Tamaño (C2): El tamaño del autómata se define de acuerdo al número de estados que tiene. En otros contextos, el tamaño del autómata es definido tanto por el número de estados como por el número de transiciones. En el contexto presente el número de estados se va a considerar para el tamaño del autómata, ya que hay transiciones que no son utilizadas. Existe un número máximo de estados, esto es debido a que se quiere tener el AFD minimal; es decir, con el menor número de estados que pueda tener el autómata y que acepte el lenguaje. Si no se fijara un número que controle el máximo tal vez el autómata crecería por lo tanto no se obtendría el AFD minimal. Sea | Qte | el número máximo de estados que puede tener un autómata y | Q | el número de estados que tiene un autómata, para | Q | > | Qte | el valor de C2 = 0, en otro caso C2=|Qte|-|Q| / |Qte| . 4.5.3 Generalización (C3): Sea s el tamaño del lenguaje obtenido a partir del archivo que contiene las cadenas. El proceso del algoritmo genético intenta encontrar un autómata que acepte el lenguaje s.

CAPITULO 4


-

La función de generalización se define cono la diferencia entre del lenguaje que acepta el autómata y el que tendría que aceptar, la función es la siguiente.

f(x) donde x=lenguaje que tiene que aceptar – lenguaje que acepta

Sin tener la definición de f exacta, f(x) debe tener las dos siguientes características: Debe regresar el valor más grande para x = 0 y para valores x ≠ 0 decrementa cuando incrementa | x | .

Una función con estas características puede ser lineal o no lineal. La función lineal tiene la forma general:

f1 (x) = (-m1 *| x | ) + max1

donde m1 controla las pendientes de f1(x)y max1 es el valor más grande que regresa.

Claramente, esta función regresa valores positivos así como negativos lo cual significa que el fitness podría llegar a ser negativo. Otra aproximación es tener una función no lineal de la siguiente forma

max2 f2 (x)= ⎯⎯⎯⎯⎯⎯⎯⎯ 1 + ( m2 * x 2 ) donde m2 controla las pendientes de la función y max2 es el valor mas grande, esta función solo regresa valores positivos, aproximándose a 0 en los limites. 4.6 Operador de Cruzamiento.

El cruzamiento uniforme proporcional al fitness, usado en AAG se relaciona con el cruzamiento uniforme.

En el cruzamiento uniforme estándar, los hijos heredan los genes de sus padres con la misma probabilidad (0.5). Otra combinación de probabilidades es la siguiente, el hijo hereda los genes del padre 1 con una probabilidad p y del padre 2 con una probabilidad de 1-p.

Si el fitness del padre 1 es 2 veces más grande que la del padre 2 entonces el hijo heredará más genes del padre 1 que del 2.

En AAG, los genotipos son de longitud variable, por lo tanto los padres pueden ser de tamaños diferentes. Ya que el tamaño del AFD puede aumentar o disminuir, el tamaño del hijo puede ser diferente al de sus padres.

CAPITULO 4


-

El tamaño del hijo se determina aleatoreamente entre un rango definido por el tamaño del padre1 + ó – un offset (línea 1). La función de cruzamiento uniforme proporcional al fitness se describe en la primer parte del procedimiento anterior (líneas 2 - 10). En esa parte se determina el valor para cada gen del hijo.

Procedimiento Cruzamiento 1. tamaño (hijo) = tamaño (padre1) + offset (-2 ,2) 2. Mientras( (i < tamaño (hijo) ) && (i< tamaño (padre1)) && (i < tamaño (padre2))) 3. Para k=0 hasta k<=tamaño_lenguaje 4. Si random(0, fitness (padre1) + fitness (padre2)) > fitness (padre1) 5. hijo->transicion[k]=padre2->transicion[k] 6. en otro caso 5. hijo->transicion[k]=padre1->transicion[k] 7. Fin Si 8. Fin Para 9. i <- i + 1 10. Fin Mientras 11. Si (i < tamaño (hijo)) 12. Mientras (i < tamaño (padre1) && i < tamaño (hijo)) 13. Para k=0 hasta k<=tamaño_lenguaje 14. hijo->transicion[k]=padre1->transicion[k] 15. Fin Para 16. i <- i + 1 17. Fin Mientras 18. Mientras (i < tamaño (padre2) && (i < tamaño (hijo)) 19. Para k=0 hasta k<=tamaño_lenguaje 20. hijo->transicion[k]=padre2->transicion[k] 21. Fin Para 22. i <- i + 1 23. Fin Mientras 24. Mientras ((i < tamaño (hijo)) 25. Para k=0 hasta k<=tamaño_lenguaje 26. hijo->transicion[k]=inicializa() 27. Fin Para 28. i <- i + 1 29. Fin Mientras 30. Fin_Si

CAPITULO 4


-

El cruzamiento uniforme proporcional al fitness determina que padre le hereda al hijo, si un valor aleatorio entre 0 y fitness (padre 1) + fitness (padre 2) es más grande que el fitness del padre 1, entonces el hijo hereda del padre 2, en otro caso el hijo hereda del padre 1. Si uno de los padres es más corto que el hijo y el otro padre, entonces el hijo hereda el resto de los genes del padre más largo (líneas 11 - 23). Si el hijo es mas largo que ambos padres entonces los genes que le faltan son seleccionados aleatoreamente (líneas 24 -29). Ejemplo: Aplicación del cruzamiento.

En este ejemplo el padre2 tiene mejor fitness que el padre1 y los padres e hijo tienen diferente tamaño. El tamaño del hijo se eligió aleatoreamente entre un rango de 0 y tamaño del padre1 más 2 que nos da un valor de 5. El padre más pequeño es el del padre1 con 3 estados, por lo tanto los genes de los tres primeros estados del hijo son determinados por el cruzamiento uniforme proporcional al fitness. En este ejemplo el hijo hereda todas las transiciones de ambos padres así como las etiquetas de los estados; como se puede ver en el dibujo los padres tienen una transición en común δ(0,1) = 1. El padre más largo tiene un estado más (estado 3) el cual se copia tal cual al hijo, así que el estado restante (estado 4) se llena aleatoreamente. Finalmente se crea una nueva transición la cual lleva al estado 4 δ(3.a)=4.

F a b c0 1 1 -1 -11 1 -1 -1 22 -1 -1 -1 -1

padre 1

0 11a c

2

F a b c0 1 1 2 -11 1 -1 3 -12 1 -1 -1 33 -1 -1 -1 -1

padre 2

2

b a

b

0

c

1

3

F a b c0 1 -1 2 -11 1 -1 3 22 -1 -1 -1 33 -1 4 -1 -14 1 -1 -1 -1

hijo

3

2

b a

b

0

c

1

c a 4

CAPITULO 4


-

La función de cruzamiento es aplicada con una probabilidad dada. Experimentos realizados por Anja Belz mostraron que un valor entre 0.8 y 1 generalmente producen menores resultados, además de que el cruzamiento uniforme normal con probabilidades similares para heredar de los padres produjeron resultados no muy buenos.

El cruzamiento en el AAG no siempre produce resultados tan ordenados como en el ejemplo anterior, ya que el hijo desconecta los estados. 4.7 Operador de Mutación.

Después del cruzamiento, cada gen en cada hijo es mutado con una probabilidad de 1/tamaño del hijo.

El procedimiento anterior comienza por fijar la probabilidad de mutación (línea 1), para todos los estados del hijo si un número aleatorio entre 0 y 1 es menor que la probabilidad de mutación se cambia la etiqueta del hijo, es decir si tiene un valor de -1 se cambia por un 1 y viceversa (-1 indica estado final, 1 indica estado no final) (líneas 4 - 5). Para todos los genes del hijo si un número aleatorio entre 0 y1 es menor que la probabilidad de mutación entonces se cambia ese gen por otro que este entre -1 y el tamaño del hijo.

Procedimiento Mutacion 1. p=1.0/tamaño (hijo) 2. Para (i=1;i<tamaño (hijo);i++) 4. Si (random(0,1) < p) 5. cambia_etiqueta (hijo) 6. Para (j=1;j<=tamaño_lenguaje;j++) 7. Si (random(0,1) < p) 8. hijo->transicion[j]=inicializa() 15. Fin Si 16. Fin Para 17. Fin Si 18. Fin Para

CAPITULO 4


-

4.8 Otros Operadores 4.8.1 Validación

Es un operador no genético, el cual hace lo siguiente: Tienen dos componentes, el primero borra las transiciones que forman un ciclo y el segundo borra las transiciones que no se ocupan. El efecto del primer componente de la función de validación reduce el espacio de búsqueda del conjunto de todos los lenguajes regulares a el conjunto de todos los lenguajes finitos. El segundo componente borra todas las transiciones en el autómata que no son usadas por cualquier elemento de los datos de muestra, esto tienen el efecto de reducir la generalización para unir estados. Ejemplo del operador de Validación En este ejemplo tanto los ciclos y las transiciones que nos son usados se van a eliminar

El operador de validación detecta que la transición δ(4,b) = 1 forma un ciclo en el autómata por lo tanto es borrada. Las transiciones δ(0,b) = 4 y δ(2,a) = 3 no se usan por las cadenas del conjunto de muestra por lo tanto también son borradas.

a b a b0 1 4 0 1 -1 2 3 1 2 32 3 4 2 - 43 - 4 3 - 44 - 1 4 - -

Después de aplicar Validación = >

ab

a b

b

b

b 0

1

4

3

2

a

ab

b

b

0

1

4

3

2

a

CAPITULO 4


-

4.8.2 Operador State Merge

El operador STATE_MERGE es un operador no genético, el cual se aplica con una probabilidad dada (normalmente un valor muy pequeño alrededor de 0.01), consiste en determinar el conjunto de todos los pares de estados idénticos en el autómata (dos estados son idénticos si todas sus transiciones son iguales). De este conjunto de pares de estados es seleccionado uno aleatoreamente, de este par se escoge un estado aleatoreamente el cual va a ser borrado y el otro va a permanecer. Todas las transiciones del autómata que lleguen al estado que va a ser borrado se cambian por el estado que va a quedarse. Por ultimo se borra el estado. Ejemplo del operador SATE_MERGE

En este ejemplo, STATE_MERGE encuentra dos pares idénticos de estados, los estados 1 y 5 y los estados 3 y 4. El primer par (1 y 5) es seleccionado aleatoreamente para unirse, el segundo estado del par ( 5 ) es seleccionado aleatoreamente para ser borrado. Hay solo una transición que lleva al estado que se va a borrar δ(2,d) = 5, esta es remplaza con la transición hacia el estado 1 que es el que se queda. Finalmente el estado 5 es borrado. 4.8.3 Operador State Split

El operador STATE_SPLIT también es un operador no genético y se aplica con una probabilidad muy baja (normalmente igual que STATE_MERGE). El operador consiste en determinar el conjunto de todos los pares de estados que tienen más de una transición. De este conjunto de pares se escoge una aleatoreamente s1 representa al primer estado del par y s2 al segundo. Se crea un nuevo estado y se le copian las transiciones de s2, este se añade al final de AFD. Finalmente se selecciona una transición en s1 aleatoreamente y se cambia por una nueva transición que lleva al estado que se creo.

F a b c d e0 -1 1 1 -1 -1 -11 -1 -1 -1 3 4 -12 -1 -1 -1 -1 5 -13 1 -1 -1 -1 -1 -14 1 -1 -1 -1 -1 -15 1 -1 -1 3 4 -1

F a b c d e0 -1 1 1 -1 -1 -11 -1 -1 -1 3 4 -12 -1 -1 -1 -1 1 -13 1 -1 -1 -1 -1 -14 1 -1 -1 -1 -1 -1

Después de aplicar STATE_MERGE

= >

CAPITULO 4


-

Ejemplo del operador STATE_SPLIT:

Aquí solo hay una par de estados que tienen más de una transición, estado 0 y 1. El estado 1 es copiado al final de la matriz, creando así un nuevo estado ( 5 ). La transición δ(0,b) = 1 es seleccionada para ser remplaza con una transición que lleve al nuevo estado δ(0,b) = 5

Los operadores SATE_SPLIT y STATE_MERGE tienen un pequeño efecto sobre el valor de fitness sin cambiar la funcionalidad del autómata. Los operadores son aplicados a individuos los han sido seleccionados para estar en la nueva generación.

F a b c d e0 -1 1 1 -1 -1 -11 -1 -1 -1 3 4 -12 -1 -1 -1 -1 1 -13 1 -1 -1 -1 -1 -14 1 -1 -1 -1 -1 -1

F a b c d e0 -1 1 5 -1 -1 -11 -1 -1 -1 3 4 -12 -1 -1 -1 -1 1 -13 1 -1 -1 -1 -1 -14 1 -1 -1 -1 -1 -15 1 -1 -1 3 4 -1

Después de aplicar STATE_SPLIT = >

CAPITULO 4


-

-

CAPITULO 5

CODIFICACIÓN PARA EL APRENDIZAJE DE AUTÓMATAS FINITOS QUE RECONOZCAN CADENAS

En este capítulo se explica el problema al cual se tiene que dar solución, así

como la manera en que se implemento. 5.1 Descripción y estructuras de datos del programa

El programa lo que tiene que hacer es generar autómatas finitos no cíclicos los cuales deben de reconocer cadenas, las cuales están en un archivo.

Como ya hemos visto un algoritmo genético parte de una población inicial y esta población esta formada por individuos, para esta aplicación un individuo representa un autómata finito no cíclico y la población se guarda en una matriz de estructuras de tamaño n*n.

Esta matriz esta formada por dos estructuras, la primera es la estructura cromosoma y contiene lo siguiente: id: Un identificador de individuo fitness: Su valor de adaptación al medio total_estados: El número de estados que tiene el autómata estado *raiz: Un apuntador hacia el primer estado del autómata

La segunda estructura llamada estado representa el autómata finito no cíclico y es una lista ligada dinámicamente, contiene lo siguiente: id_estado: Un identificador de estado transicion[ ]: Un arreglo, el cual contiene las transiciones del estado tran_utilizada: Un arreglo, el cual contiene las transiciones que si se ocupan estado *sig: Un apuntador hacia otro estado y es con lo que se hace la lista ligada

CAPITULO 5 CODIFICACIÓN PARA EL APRENDIZAJE DE AUTÓMATAS FINITOS QUE RECONOZCAN CADENAS

-

5.2 Procedimiento Principal del programa

Procedimiento principal

opcion=menu(); pide_datos(); selecciona_len(); Si opcion=1 genera_pob_inicial(); validar_poblacion(); evalua_poblacion(); en otro caso carga_archivo(); Fin_Si Mientras contador < num_gen algoritmo_genetico(); contador++; Fin_Mientras encuentra_mejor(); visualiza_poblacion(); genera_archivo();

5.3 Descripción de cada función 5.3.1 Genera_pob_inicial:

Como su nombre lo dice se encarga de generar la población inicial, es decir; se llena la matriz y las estructuras. Se comienza con un número de estados aleatorio entre 2 y 4, con el paso de las generaciones crece o disminuye según las cadenas a reconocer. El arreglo de transición se llena con números aleatorios que están entre –1 y el número de estados. 5.3.2 Validar_población:

Esta función se encarga de quitar ciclos hacia el mismo estado, ciclos entre más de dos estados y transiciones que no se ocupen.


-

5.3.3 Evalúa_población:

Esta función se encarga de que tanto los individuos se adaptan al medio, es decir; ver cuantas cadenas reconoce el autómata. Esta formada por tres partes. La primera se encarga de ver cuantas cadenas reconoce el autómata, la segunda trata el tamaño del autómata con esta se dice que el autómata debe de ser minimal y con la tercera tiene que ver con cuantas cadenas reconoce el autómata y cuantas cadenas tiene el archivo, ya que el autómata puede reconocer mas cadenas de las que se quiere. 5.3.3.1 Pseudocódigo para c1

calcula_c1 (num_letras_aceptadas, longitud_cadena) Si num_letras_aceptadas=longitud_cadena y termina en estado final regresa (num_letras_aceptadas + 1 ) / (longitud_cadena+1) en otro caso regresa ((num_letras_aceptadas) / (longitud_cadena+1)); Fin_Si

5.3.3.2 Pseudocódigo para c2 calcula_c2 (individuo)

Si tamaño_individuo >= máximo_num_estados regresa 0 en otro caso c2 <- (maximo_num_estados – tamaño_individuo) / máximo_num_estados regresa(c2); Fin_Si

CAPITULO 5


-

5.3.3.3 Pseudocódigo para c3

calcula_c3(Individuo ind) Para i=0 hasta i<MAXES ultimaposicion[i]=0; ultimoestado[i]=0; Fin_Para ultimaposicion[0]=1; ultimoestado[0]=0; i=0 Mientras (i>=0) pos=ultimaposicion[i] transicion=ultimoestado[i] Mientras (pos<=tam_lenguaje) edo_a=Colocarse_estado_correcto transicion_ant=transicion; transicion=edo_a->transicion[pos] Si (edo_a->transicion[0]==-1 && pos==1) sil_rec <- sil_rec + 1 Fin_Si Si(transicion==-1) transicion=transicion_ant pos <- pos + 1 en otro caso ultimaposicion[i]=pos+1; ultimoestado[i]=transicion_ant; i <- i +1 pos=1 Fin_Si Si (i >= MAXES) return 0 Fin_Si Fin_Mientras i <- i – 1 Fin_Mientras regresa sil_rec


-

5.3.4 Carga_archivo:

El programa puede empezar de dos formas, la primera es que la población inicial

se genere aleatoriamente o que se cargue de un archivo. Esta función es la que se encarga de abrir el archivo y llenar las estructuras con los datos del archivo. 5.3.5 Algoritmo_genético:

Esta función es en donde se llevan acabo los operadores cruzamiento y

mutación, además de dos operadores más estos son state_split y state_merge. Más abajo se explica como se implementaron estos operadores. El pseudocódigo es el siguiente:

Para r=0 hasta r<N

Para c=0 hasta c<N padre1 <- matriz [r] [c]

Si (RANDOM(0,1) > Probabilidad de Cruzamiento hijo <- padre1; en otro caso padre2 = mejor_vecino; hijo <- cruza_individuo(padre1,padre2); Fin_Si

hijo=mutacion(hijo); validar_individuo(&hijo); hijo.fitness=evalua_hijo(hijo); Si padre1.fitness < hijo.fitness reemplazar(hijo) Fin_Si x<- RANDOM(0,N) y<- RANDOM(0,N) Si (RANDOM(0,1)<= Probabilidad de aplicar state_merge state_merge(matriz[x][y]) Fin_Si Si (RANDOM(0,1)<= Probabilidad de aplicar state_splite state_splite(matriz[x][y]) Fin_Si

CAPITULO 5


-

En donde mejor_vecino se utiliza la forma de un toroidal, es decir se escoge el

mejor individuo de sus 8 vecinos que lo rodean. 5.3.6 Encuentra_mejor:

Se encarga de encontrar el mejor individuo, es decir; el autómata que reconoce a todas las cadenas ó a la mayoría. 5.3.7 Visualiza_población:

Esta función se encarga de mandar a un archivo los resultados obtenidos de la última generación. 5.3.8 Genera_archivo:

Como se menciono antes la población inicial se puede obtener de un archivo, esta función hace lo mismo que visualiza_población, la diferencia radica en que aquí se le da un formato especial el cual nos sirve a la hora de cargar el archivo y llenar las estructuras.

5.3.9 Cruzamiento:

El operador de cruzamiento se implemento de la siguiente forma:

Para llevar a cabo este operador necesitamos dos individuos padres para poder generar a otro (hijo).

El tamaño del autómata del hijo depende del tamaño del padre 1 más un offset

(un número aleatorio entre –2 y 2), las transiciones del hijo dependen de una probabilidad y de acuerdo a esta se copia la transición del padre1 o del padre 2. El pseudocódigo es el siguiente:

CAPITULO 5


-

cruza_individuo (padre1, padre2) tamaño_hijo = tamaño_padre1 + offset i=0 Mientras i < tamaño_hijo y i < tamaño_padre1 y i < tamaño_padre2

Para j=0 hasta j<tamaño_lenguaje_reconocido Si RANDOM(0, Fitness(padre1) + Fitnes (padre2)) > Fitness del padre1 entonces

hijo[i] <- padre2[i] en otro caso

hijo[i] <- padre1[i] Fin_Si Fin_Para i <- i + 1; Fin_Mientras

Si i < tamaño_hijo Mientras i < tamaño_padre1 y i < tamñano_hijo

Para j=0 hasta j<tamaño_lenguaje_reconocido hijo[j] <- padre1[j] Fin_Para i <- i + 1; Fin_Mientras Mientras i < tamaño_padre2 y i < tamñano_hijo

Para j=0 hasta j<tamaño_lenguaje_reconocido hijo[j] <- padre2[j] Fin_Para i <- i + 1; Fin_Mientras Mientras i < tamaño_hijo

Para j=0 hasta j<tamaño_lenguaje_reconocido hijo[j] <- inicializa[j] Fin_Para i <- i + 1; Fin_Mientras Fin_Si

CAPITULO 5


-

5.3.10 Mutación:

El operador de mutación se implemento de la siguiente forma: Este operador se le aplica al hijo obtenido del cruzamiento.

mutación (hijo) p = 1 / tamaño_hijo Para i = 0 hasta i < tamaño_hijo x= RANDOM (0,1)

Si (RANDOM (0,1) < P){ Si hijo.transición[0] =0) cambia_etiqueta Fin_si Para j=1 hasta j < = tamaño_lenguaje_aceptado Si (RANDOM(0,1) < p hijo.transicion[j]=RANDOM(0,tamaño_hijo) Fin_Si Fin_Para Fin_Si Fin_Para

5.3.11 State_Merge:

Este operador se implemento de la siguiente forma: Este operador se aplico a un solo individuo de la población el cual se escogio aleatoriamente, se utilizó una probabilidad de 0.01 y como se explico en el capitulo anterior este operador consiste en encontrar pares de estados iguales en el autómata y unir un par de estados en uno solo. El pseudocódigo es el siguiente:

CAPITULO 5


-

state_merge (individuo) i=0 Mientras ( estado1 no sea el último) estado2 <- estado1 siguiente Mientras (estado2 no sea el último) j <- compara(estado1,estado2); Si (j =1) arreglo1[i]=estado1 arreglo2[i]=estado2 estado2 <- estadp2 siguiente Si (estado2 no es el último) estado1 <- estado1 siguiente Fin_Si i <- i +1 en otro caso estado2 <- estado2 siguiente Si (estado2 es el último estado) estado1 <- estado1 siguiente Fin_Si Fin_Si Fin_Mientras Fin_Mientras Si (arreglo1[0] ≠ -1){ par_selecccionado= RANDOM (0, i) estado_borrar=RANDOM (0,1) Si (estado_borrar=0){ estado_b <- arreglo1[par_seleccionado]) estado_p <- arreglo2[par_seleccionado]) en otro caso estado_b <- arreglo2[par_seleccionado]) estado_p <- arreglo1[par_seleccionado]) Fin_si Fin_si Para j=1hasta j<=total_estados buscar transiciones que lleven al estado_b y cambiarlas al estado_P Fin_Para total_estados <- total_estados -1 5.3.12 State_Split:

El operador state_split se implemento de la siguiente forma:

De la misma manera que el operador state_merge, este se aplicó a un solo individuo con una probabilidad de 0.01.

CAPITULO 5


-

Consiste en formar pares de estados que tengan mas de una transición, de este conjunto de pares se escogió uno aleatoriamente, de este par se escoge al primer estado que hace el par se duplica y se coloca al final del autómata, en el otro estado se escoge una transición y se cambia por una que lleve al nuevo estado. El número de estados se incrementa en 1. El pseudogódigo es el siguiente:

state_split (individuo) i=1 j=0 Mientras (estado1 no sea el último) Mientras (i <= tamaño_lenguaje ){ Si (estado1.transicion ≠ -1) numero_transiciones <- numero_transicones + 1 Si (num_transiciones > 1){ Si (par==0) arreglo1[j]=estado1 par<- 1 en otro caso arreglo2[j]=id_estado; j++; par=0; Fin_Si Fin_Si i++ en otro caso i++ Fin_Mientras estado1<- estado1 siguiente i <- 1; num_transiciones=0; Fin_Mientras Si (j>0) i=RANDOM ( 0, j) estados1 <- arreglo1[i] estados2 <- arreglo2[i] Para i=0 hasta i<=tamaño_lenguaje estado2.transicion[i]=estados2.transicion[i] Fin_Para j <- RANDOM(1,tamaño_lenguaje) estados1.transicion[j] <- total_estados total_estados <- total_estado + 1 Fin_Si

CAPITULO 5


-

-

CAPITULO 6

PRUEBAS Y RESULTADOS

En este capítulo como su nombre lo dice, se hablan de las pruebas que se hicieron así como los resultados que se obtuvieron.

Para ver que resultados se obtienen del programa Se realizo antes 3 autómatas

los cuales se escogieron pequeños para poder hacer su diagrama de transición como su tabla, y así poder comparar los resultados que da el programa con los esperados. 6.1 Descripción de la prueba 1 Dado el siguiente lenguaje

ab cd ef

Para el lenguaje anterior se tomaron los parámetros de todas las constantes de

Anja Belz que sugiere para encontrar el óptimo resultado.

Se escogió este lenguaje, por que es fácil construir su AFD con un mínimo de estados y así poder comparar con el que se vaya generando con el programa.

El AFD que reconoce el lenguaje tiene 5 estados y se muestra en la siguiente figura.

Figura 1.AFD para la prueba 1.

Se hicieron tres pruebas utilizando el mismo lenguaje la diferencia entre estas son los valores de los parámetros.

0 2 4

3

a

c

e

b

d

f

Estado final Estado inicial

1

CAPITULO 6


Lenguaje 1

-

6.1.1. Primer prueba utilizando el lenguaje 1 Esta prueba se hizo para 35, 50, 80, 130, y 180 generaciones; el valor de constantes utilizadas son las siguientes: El tamaño de la matriz de población NxN donde N = 8, Individuos = 64 El número máximo de estados que puede tener un autómata es igual o menor 10 Probabilidad de cruzamiento = 0.5000 Probabilidad para que se aplique state merge = 0.0100 Probabilidad para que se aplique state split = 0.0100 Numero máximo de símbolos que estén en una cadena = 10 Numero máximo de símbolos para el lenguaje = 27 Fitness = C1 * W1 +C2 * W2 +C3 * W3

donde:

C1 Es la consistencia W1 peso de 1 C2 Es el tamaño del autómata W2 peso de 1 C3 Generalización numero de cadenas que acepta W3 peso de 1

Para la función de fitness.

En generalización MAX = 20 y M2 = 0.0250 El valor máximo de cada variable en la función fitness Consistencia tamaño generalización 3 0.8000 20 El fitness máximo que puede obtener un individuo es = 23.8000 Para observar como se va comportando tenemos la población inicial la cual fue creada aleatoriamente y la salida del programa con el archivo (c:\proyecto\transh.txt ) muestra el siguiente resultado.

CAPITULO 6


-

Para una población de 64 individuos, la generación 1 nos indica que el individuo 22 es el mejor con su tabla de transición:

El 3 let nos indica que acepta tres cadenas las cuales son a, c, ef Seguimos con la búsqueda del mejor autómata y seleccionamos la opción 2 cargar un archivo (generado.txt) del programa de Después de 5 generaciones, el mejor individuo es el 18.

Se puede observar que el autómata acepta tres cadenas las cuales son ab, cd, ed. No es optimo seguimos buscando el optimo autómata. a) Para 35 generaciones, el mejor individuo es el 2

Este autómata también acepta tres cadenas las cuales son ab, cd, efb.

CAPITULO 6


-

b) Después de 50 generaciones, el mejor individuo es el 6

Este autómata también acepta tres cadenas las cuales son ab, cd, ef pero no es óptimo, ya hay un estado que no se ocupa. c) Para 80 generaciones

El autómata acepta tres cadenas las cuales son ab, cd, ef pero no hay cambio, los demás individuos se van acercando a este modelo.

CAPITULO 6


-

d) Para 130 generaciones

No cambia el individuo 5, los demás siguen aumentando su fitness. Esto es por como se hace la selección de individuos al mutar y como el es el mejor individuo dentro de el conjunto de individuos dentro de la vecindad. e) Para 180 generaciones

CAPITULO 6


-

En la generación 180 observando la información tenemos que el fitness para el individuo 11 le falto poco para alcanzar el máximo valor de fitness, pero no puede ser y que alcance el máximo fitness de 23.8 por que se alcanza teniendo solo dos estados y que reconozca el lenguaje, no es posible, por lo tanto el valor de 23.5 del individuo 11 es optimo ya que reconoce todo el lenguaje y además tiene un mínimo de estados esto se puede saber ya que tenemos la referencia del autómata que esperábamos. El diagrama de transición del individuo 11 se muestra en la figura2

0

4

2

a

4

3b

c d

e f

Estado inicial Estado final

.

Figura 2 diagrama de transición del individuo 11. 6.1.2 Segunda prueba utilizando el lenguaje 1 Esta prueba se hizo para 100 generaciones. Para la ecuación de fitness:

Fitness = C1 * W1 +C2 * W2 +C3 * W3

donde: C1 Es la consistencia W1 peso de 0.5 C2 Es el tamaño del autómata W2 peso de 0.1 C3 Generalización numero de cadenas que acepta W3 peso de 0.1

Esta prueba se realizo con 100 generaciones Para la función de fitness En generalización MAX = 20 y M2 = 0.0250 Peso w1 : 0.5000 Peso w2 : 1.0000 Peso w3 : 0.1000

CAPITULO 6


-

El valor máximo de variables en la función fitness fue igual a: Consistencia tamaño generalización 3 0.8000 20 El fitness máximo que puede obtener un individuo es: 4.3000. En la generación 100 el mejor individuo y además el autómata encontrado es el esperado.

6.1.3 Tercer prueba utilizando el lenguaje 1 Esta prueba se realizo para 300 generaciones Para la función de fitness En generalización MAX = 20 y M2 = 0.0250 Peso w1 : 0.1000 Peso w2 : 1.0000 Peso w3 : 0.5000 El valor máximo de variables en la función fitness Consistencia tamaño generalización 3 0.8000 20 El fitness máximo que puede obtener un individuo es:11.1000

CAPITULO 6


-

Donde el mejor individuo es el 16

Los resultados obtenidos que primero se realizaron con 100 generaciones y no se tuvo buenos resultados se opto por aumentar a 200 generaciones el resultado fue el mismo que no se mejoraba el autómata no aprendía se aumentaron a 300 lo cual mostró que el mejor individuo su fitness es de 10.9000 y bueno ya eran 300 generaciones suficientes para que se observara que no tendía a un buen autómata se opto por desechar esta prueba. 6.2. Descripción de la prueba utilizando otro lenguaje Dado el siguiente lenguaje. aa ab cd ad

Lenguaje 2

CAPITULO 6


-

Su AFD esta representado por el diagrama de transición en la figura 3.

Figura3.Diagrama de transición de AFD. De igual manera se hicieron tres pruebas con este lenguaje, la diferencia entre estas son los valores de las constantes que se utilizaron. 6.2.1. Primer prueba utilizando el lenguaje 2 Esta prueba se hizo con 30 generaciones, el valor de constantes utilizadas son las siguientes: El tamaño de la matriz de población NxN donde N = 8 Individuos 64 El numero máximo de estados que puede tener un autómata : 10 Probabilidad de cruzamiento: 0.5000 Probabilidad para que se palique state merge: 0.0100 Probabilidad para que se palique state split: 0.0100 Numero máximo de símbolos que esten en una cadena: 10 Numero máximo de símbolos para lenguaje: 27 Para la función de fitness En generalización MAX = 20 y M2 = 0.0250 Peso w1 : 1.0000 Peso w2 : 1.0000 Peso w3 : 1.0000 El valor máximo de variables en fitness alcanzables Consistencia tamaño generalización 4 0.8000 20 El fitness máximo que puede obtener un individuo es:24.8000

PR

3

2

a

cEstado final Estado inicial

d

abd1

CAPITULO 6


-

Para una población de 64 individuos la generación inicial nos indica que el individuo 47 es el mejor con su fitness de 23.9333 .

Analizando su tabla de transición observamos que acepta 4 cadenas y siguiendo la tabla las cadenas son ab, ad, cb, cd de las cuales nada mas debería aceptar ab,cd pero es una muy buena aproximación para el autómata que esperamos obtener. Se aumentaron las generaciones a 15.

Para una población de 64 individuos y en la generación 30 el resultado nos indica que el individuo 18 es el mejor con su fitness de 24.6 y su tabla de transición que es la siguiente:

CAPITULO 6


-

Observamos la información que nos muestra la tabla del individuo 18 que acepta 4 cadenas las cuales son aa, ab, ad, cd es lo que se espera. Realizando su diagrama de transición que se muestra en la figura 4.

FIGURA 4.Diagrama de transición para el individuo 57

0 3

2

a

cEstado final Estado inicial

d

abd1

CAPITULO 6


-

6.2.2 Segunda prueba utilizando el lenguaje 2 Esta prueba se hizo para 15 generaciones, los valores de los parámetros son los siguientes: Para la función de fitness En generalización MAX = 20 y M2 = 0.0250 Peso w1 : 0.5000 Peso w2 : 1.0000 Peso w3 : 0.1000 El valor máximo de variables en la función fitness Consistencia tamaño generalización 4 0.8000 20 El fitness máximo que puede obtener un individuo es: 4.8000 Para 15 generaciones obtenemos que el mejor individuo es el número 57 y su tabla de transición el la siguiente:

En su tabla de transición observamos que el autómata es el esperado. 6.2.2 Tercer prueba utilizando el lenguaje 2 Esta prueba se hizo para 50 generaciones, los valores de los parámetros son los siguientes: Para la función de fitness En generalización MAX = 20 y M2 = 0.0250 Peso w1 : 0.1000 Peso w2 : 1.0000 Peso w3 : 0.5000

CAPITULO 6


-

El valor máximo de variables en la función fitness Consistencia tamaño generalización 4 0.8000 20 El fitness máximo que puede obtener un individuo es: 11.2000 Después de 50 generaciones y analizando la tabla de transiciones se decide no continuar ya que no se acerca al autómata que se espera.

6.3 Prueba con los datos utilizados por Anja Belz Realizamos la prueba para el ejemplo que menciona en su reporte Anja Belz, esta se hizo para 500 y 1500 generaciones. Para un lenguaje más grande es el siguiente el que ocupo Anja Belz:

aaea aafa aaeb aafb aaec aafc aaed aafd abea abfa abeb abfb abec abfc abed abfd acga acha acgb achb acgc achc acgd achdadga adha adgb adhb adgc adhc adgd adhdbaea bafa baeb bafb baec bafc baed bafd bbea bbfa bbeb bbfb bbec bbfc bbed bbfd bcga bcha bcgb bchb bcgc bchc bcgd bchdbdga bdha bdgb bdhb bdgc bdhc bdgd bdhdcaea cafa caeb cafb caec cafc caed cafd cbea cbfa cbeb cbfb cbec cbfc cbed cbfd ccga ccha ccgb cchb ccgc cchc ccgd cchdcdga cdha cdgb cdhb cdgc cdhc cdgd cdhddaea dafa daeb dafb daec dafc daed dafd dbea dbfa dbeb dbfb dbec dbfc dbed dbfd dcga dcha dcgb dchb dcgc dchc dcgd dchdddga ddha ddgb ddhb ddgc ddhc ddgd ddhd

El valor de constantes utilizadas son las siguientes: El tamaño de la matriz de población NxN donde N = 8 Individuos 64 El numero máximo de estados que puede tener un automata : 10 Probabilidad de cruzamiento: 0.5000 Probabilidad para que se palique state merge: 0.0100

CAPITULO 6


-

Probabilidad para que se palique state split: 0.0100 Numero máximo de símbolos que estén en una cadena: 10 Numero máximo de símbolos para lenguaje: 27 Para la función de fitness En generalización MAX = 20 y M2 = 0.0250 Peso w1 : 1.0000 Peso w2 : 1.0000 Peso w3 : 1.0000 El valor máximo de variables en la función fitness Consistencia tamaño generalización 128 0.8000 20 El fitness máximo que puede obtener un individuo es: 148.8000 Los resultados obtenidos son los siguientes: La población inicial se obtuvo el individuo 45 fue el mejor y su tabla de transición es la siguiente:

a) Para 500 generaciones

La información nos dice que este individuo acepta 128 cadenas y su fitness es de 135.6001 su diagrama esta en la figura 5

CAPITULO 6


-

Figura 5.Diagrama de transicion del individuo 1.

b) Para 1500 generaciones

En la tabla de transiciones observamos que tiene un fitness de 148.04 del cual se esperaba 148.8 pero por el tamaño se obtuvo este, y con 128 cadenas aceptadas comparando con el autómata que encontró Anja Belz es el mismo ver figura 6..

abcd

bc

efgh

ad

0 2 3

4

1

5

inicial abcd

final

CAPITULO 6


-

Figura 6. Diagrama de transición del AFD del individuo 45.

abcd

cd

ef

gh

abcd 0 3

2

1

4 5

ab inicial final

CAPITULO 6


-

CONCLUSION

CONCLUSION

Los resultados encontrados fueron los esperados, se encontraron los autómatas de los lenguajes que se optaron para probar el programa .Se encontró que la función de fitness es muy importante por que es fundamental en el algoritmo genético ya que por medio de esta se basa el algoritmo para aprender , se tienen que tomar las consideraciones necesarias apropiadas al problema que se tiene para que el aprendizaje sea optimo como vaya aumentando cada generación del algoritmo genético , en nuestra función de fitness primero se considero nada mas 2 condiciones la de consistencia y la del tamaño de los estados pero los resultados de las pruebas realizadas no fueron satisfactorios ya que se encontraba un autómata que aceptara el lenguaje pero también reconocía mas cadenas, por lo tanto se tuvo que considerar la tercer condición que tomo Anja Belz en su articulo que fue la de generalización con la cual se tendría controlado las cadenas totales que acepta el autómata con esta inclusión en la función de fitness fue la que dio la pauta para mejorar los resultados pero se encontraron limitaciones en el programa, las cuales son: solo funciona para lenguajes pequeños (lista de cadenas no muy grandes menos de 300 cadenas ) o puede analizar listas de cadenas grandes pero el numero de símbolos debe ser pequeño máximo 8 ya que en el lenguaje y la forma de programación en que se realizo esta no soporta lenguajes grandes ya que tiende a que el autómata crezca. El número de estados incrementa y esto hace que la memoria en un determinado momento se termine y aborte el programa. Una solución que se piensa que puede dar resultado para aceptar cualquier tamaño de una lista de cadenas es que la población a la hora que sea generada en vez que se tenga en memoria se guarde en un archivo y que solo este en memoria los individuos que se necesitan para el cruzamiento, mutación, etc. De esta manera se podrá retomar en el momento que se necesite cualquier individuo, también debe guardarse el fitness del individuo en una matriz del tamaño de la población esto es para realizar la selección de la vecindad y así poder escoger los individuos con mayor fitness. Así no habría problemas de memoria.

-

BIBLIOGRAFIA

BIBLIOGRAFIA

Libro: Genetic Algorithms + Data Structures = Evolution Programs Autor Michalewicz, Z. Paginas de Internet. http://www.itri.brighton.ac.uk/~Anja.Belz/ Chapter 3: Learning Object-Based Finite-State Models] Chapter 4: GAL: A Genetic Algorithm for Learning Finite-State Chapter 5: Applications, Tests and Results http://www.redcientifica.com/doc/doc199904260011.html http://www.elrincondelprogramador.com/default.asp?pag=articulos/leer.asp&id=6 http://www.inforg.uniovi.es/ia/Genetico-TSP/Introduccion.htm

-

ANEXOS

ANEXOS

A) MANUAL DE USUARIO

Descargar la carpeta con el nombre de proyecto en c:\ La carpeta contiene los siguientes archivos: • automata.c : Este contiene el código del programa. • prototipo.h : Este contiene las librerias, las estructuras, las variables y los

prototipos de las funciones. • automata.exe : Es el programa ejecutable. Para ejecutar el programa se necesita lo siguiente:

1. La carpeta proyecto deberá contener el archivo de cadenas a reconocer (el nombre del archivo debe de ser de longitud menor a 20).

El formato del archivo de las cadenas es ver anexo 1 a. 2. El programa se puede ejecutar de dos formas:

2.1. a) Dándole doble clic al archivo automata.exe, enseguida se desplegara la siguiente ventana

b) Si selecciona la opción 1, escribir el nombre del archivo de cadenas a reconocer, enseguida el número de generaciones deseadas.

-

ANEXOS

c) Se crean los archivos trans.txt, transh.txt y generado.txt. trans.txt : contiene la descripción de los autómatas finales generados.

d) generado.txt: son los mismos resultados que result.txt, pero este sirve para la

opción 2, que es la ejecución del programa con resultados ya obtenidos. El formato del archivo ver anexo 1 c.

e) Si selecciona la opción 2, se repiten los pasos anteriores, pero pedirá el archivo a cargar (generado.txt)

2.2. Si se desea cambiar los parámetros se tendrá que ejecutar el archivo automata.c con el compilador de c en donde los parámetros se encuentran en el archivo peso1.h, los únicos parámetros a cambiar pueden ser:

El valor de constantes utilizadas son las siguientes : El tamaño de la matriz de población NxN donde N = 8 Individuos 64 El numero máximo de estados que puede tener un autómata : 10 Probabilidad de cruzamiento: 0.5000 Probabilidad para que se palique state merge: 0.0100 Probabilidad para que se palique state split: 0.0100 Numero máximo de símbolos que estén en una cadena: 10 Numero máximo de símbolos para lenguaje: 27 Para la función de fitness

-

En generalización MAX : 20 En generalización M2 0.0250 Peso w1 : 1.0000 Peso w2 : 1.0000 Peso w3 : 1.0000.

ANEXOS

Nota: Al ejecutarlo utilizando el compilador de c se debe especificar la ruta en donde se encuentra el archivo (archivo de cadenas o archivo generado). Ejemplo:

B) Formato de Archivos

a) Formato archivo cadenas

b) Formato archivo result.txt

-

ANEXOS

c) Formato archivo generado.txt

C) Código Fuente

Programa Codificación para el aprendizaje de autómatas finitos que reconozcan cadenas

ARCHIVO PESO1.H

#include<stdio.h> #include<alloc.h> #include<stdlib.h> #include<conio.h> #include<time.h> #include<string.h> #define N 8

-

//Tama¤o de la matriz #define MAXES 10 //Numero maximo de estados que puede tener un automata #define PC 0.5 //Probabilidad de cruzamiento #define SM 0.01 //Probabilidad para que se palique state merge #define SS 0.01 //Probabilidad para que se palique state split #define TS 10 //Maximo tama¤o de silaba #define TA 27 //Numero maximo de simbolos #define MAX 20 #define M2 0.025

ANEXOS

#define W1 1.0 #define W2 1.0 #define W3 1.0 typedef struct cromosoma{ int id; float fitness; int total_estados; int letras_aceptadas; struct estado *raiz; }Individuo; typedef struct estado{ int id_estado; int transicion[TA+1]; int t_utilizada[TA+1]; struct estado *sig; }Estados; Individuo poblacion[N][N]; char alfabeto[]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','¤','o','p','q','r','s','t','u','v','w','x','y','z'}; static char nom_archivo[30]; char *lenguaje=NULL; int tam_lenguaje=0; int num_gen,final=0; int mejor_r=0,mejor_c=0; int consistencia=0,genera=0; float tamano=0; void esquina1(int vecinos[8][2],int i,int j) {

-

vecinos[0][0]=i; vecinos[0][1]=(j+1)%N; vecinos[1][0]=((i+1)%N); vecinos[1][1]=(j+1)%N; vecinos[2][0]=(i+1)%N; vecinos[2][1]=j; vecinos[3][0]=(i+1)%N; vecinos[3][1]=N-1; vecinos[4][0]=i; vecinos[4][1]=N-1;

ANEXOS

vecinos[5][0]=N-1; vecinos[5][1]=N-1; vecinos[6][0]=N-1; vecinos[6][1]=j; vecinos[7][0]=N-1; vecinos[7][1]=(j+1)%N; } void esquina2(int vecinos[8][2], int i, int j) { vecinos[0][0]=i; vecinos[0][1]=i; vecinos[1][0]=(i+1)%N; vecinos[1][1]=i; vecinos[2][0]=(i+1)%N; vecinos[2][1]=j; vecinos[3][0]=(i+1)%N; vecinos[3][1]=j-1; vecinos[4][0]=i; vecinos[4][1]=j-1; vecinos[5][0]=j; vecinos[5][1]=j-1; vecinos[6][0]=j; vecinos[6][1]=j; vecinos[7][0]=j; vecinos[7][1]=i; } void esquina3(int vecinos[8][2], int i, int j) {

-

vecinos[0][0]=i; vecinos[0][1]=(j+1)%N; vecinos[1][0]=j; //0 vecinos[1][1]=(j+1)%N; vecinos[2][0]=j; vecinos[2][1]=j; vecinos[3][0]=j; vecinos[3][1]=i; vecinos[4][0]=i; vecinos[4][1]=i;

ANEXOS

vecinos[5][0]=i-1; vecinos[5][1]=i; vecinos[6][0]=i-1; vecinos[6][1]=j; vecinos[7][0]=i-1; vecinos[7][1]=(j+1)%N; } void esquina4(int vecinos[8][2], int i, int j) { vecinos[0][0]=i; vecinos[0][1]=0; vecinos[1][0]=0; vecinos[1][1]=0; vecinos[2][0]=0; vecinos[2][1]=j; vecinos[3][0]=0; vecinos[3][1]=j-1; vecinos[4][0]=i; vecinos[4][1]=j-1; vecinos[5][0]=i-1; vecinos[5][1]=j-1; vecinos[6][0]=i-1; vecinos[6][1]=j; vecinos[7][0]=i-1; vecinos[7][1]=0; } void orrilla_arriba(int vecinos[8][2], int i, int j) { vecinos[0][0]=i; vecinos[0][1]=(j+1)%N; vecinos[1][0]=i+1;

-

vecinos[1][1]=(j+1)%N; vecinos[2][0]=(i+1)%N; vecinos[2][1]=j; vecinos[3][0]=(i+1)%N; vecinos[3][1]=j-1; vecinos[4][0]=i; vecinos[4][1]=j-1; vecinos[5][0]=N-1; vecinos[5][1]=j-1; vecinos[6][0]=N-1;

ANEXOS

vecinos[6][1]=j; vecinos[7][0]=N-1; vecinos[7][1]=(j+1)%N; } void orrilla_abajo(int vecinos[8][2], int i, int j) { vecinos[0][0]=i; vecinos[0][1]=(j+1)%N; vecinos[1][0]=(i+1)%N; vecinos[1][1]=(j+1)%N; vecinos[2][0]=(i+1)%N; vecinos[2][1]=j; vecinos[3][0]=(i+1)%N; vecinos[3][1]=j-1; vecinos[4][0]=i; vecinos[4][1]=j-1; vecinos[5][0]=i-1; vecinos[5][1]=j-1; vecinos[6][0]=i-1; vecinos[6][1]=j; vecinos[7][0]=i-1; vecinos[7][1]=(j+1)%N; } void orrilla_derecha(int vecinos[8][2], int i, int j) { vecinos[0][0]=i; vecinos[0][1]=0; vecinos[1][0]=(i+1)%N; vecinos[1][1]=0; vecinos[2][0]=(i+1)%N;

-

vecinos[2][1]=j; vecinos[3][0]=(i+1)%N; vecinos[3][1]=j-1; vecinos[4][0]=i; vecinos[4][1]=j-1; vecinos[5][0]=i-1; vecinos[5][1]=j-1; vecinos[6][0]=i-1; vecinos[6][1]=j; vecinos[7][0]=i-1;

ANEXOS

vecinos[7][1]=0; } void orrilla_izquierda(int vecinos[8][2], int i, int j) { vecinos[0][0]=i; vecinos[0][1]=(j+1)%N; vecinos[1][0]=(i+1)%N; vecinos[1][1]=(j+1)%N; vecinos[2][0]=(i+1)%N; vecinos[2][1]=j; vecinos[3][0]=(i+1)%N; vecinos[3][1]=N-1; vecinos[4][0]=i; vecinos[4][1]=N-1; vecinos[5][0]=i-1; vecinos[5][1]=N-1; vecinos[6][0]=i-1; vecinos[6][1]=j; vecinos[7][0]=i-1; vecinos[7][1]=(j+1)%N; } void centro(int vecinos[8][2], int i, int j) { vecinos[0][0]=i; vecinos[0][1]=(j+1)%N; vecinos[1][0]=(i+1)%N; vecinos[1][1]=(j+1)%N; vecinos[2][0]=(i+1)%N; vecinos[2][1]=j; vecinos[3][0]=(i+1)%N; vecinos[3][1]=j-1;

-

vecinos[4][0]=i; vecinos[4][1]=j-1; vecinos[5][0]=i-1; vecinos[5][1]=j-1; vecinos[6][0]=i-1; vecinos[6][1]=j; vecinos[7][0]=i-1; vecinos[7][1]=(j+1)%N; } void busca_mejor_vecino(int vecindad[8][2],int mejor_vecino[2])

ANEXOS

{ int r, c; mejor_vecino[0]=vecindad[0][0]; mejor_vecino[1]=vecindad[0][1]; for(r=1;r<8;r++){ if(poblacion[mejor_vecino[0]][mejor_vecino[1]].fitness < poblacion[vecindad[r][0]][vecindad[r][1]].fitness) { mejor_vecino[0]=vecindad[r][0]; mejor_vecino[1]=vecindad[r][1]; } } } void busca_vecinos(int i, int j,int vecinos[8][2], int mejor_vecino[2]) { int r,c; for(r=0;r<8;r++) for(c=0;c<2;c++) vecinos[r][c]=0; if(i==0 && j==0) esquina1(vecinos,i,j); if(i==0 && j==N-1) esquina2(vecinos,i,j); if(i==N-1 && j==0) esquina3(vecinos,i,j); if(i==N-1 && j==N-1) esquina4(vecinos,i,j); if(i==0 && (j>0 && j<N-1)) orrilla_arriba(vecinos,i,j);

-

if((i>0 && i<N-1) && j==N-1) orrilla_derecha(vecinos,i,j); if(i==N-1 &&(j>0 && j<N-1)) orrilla_abajo(vecinos,i,j); if((i>0 && i<N-1) && j==0) orrilla_izquierda(vecinos,i,j); if((i>0 && i<N-1) && (j>0 && j<N-1)) centro(vecinos,i,j); busca_mejor_vecino(vecinos,mejor_vecino); }

ANEXOS

ARCHIVO AUTOMATA.C #include "c:\proyecto\peso1.h" /* Pide el nombre del archivo que contiene las silabas y numero de generaciones al usuario */ void pide_datos(void) { clrscr(); printf("\nNombre del archivo(cadena) para encontrar su AFD: "); scanf("%s",nom_archivo ); fflush(stdin); printf("\nNumero de generaciones : "); scanf("%d",&num_gen); fflush(stdin); } /* Identifica el lenguje formado por las silabas del archivo de entrada */ void selecciona_len(void) { FILE *infile; int alfa[TA],j; char letra[5]; int i,longitud=0,tam_c=0; clrscr(); for(j=0;j<TA;j++) alfa[j]=0; if((infile=fopen(nom_archivo,"r"))==NULL){ printf("\nNo se puede abrir el archivo de cadena para reconocer ellenguaje \n"); exit(1); }

-

do{ fscanf(infile,"%s",letra ); fflush(stdin); tam_c=strlen(letra); for(i=0;i<tam_c;i++) { j=0; while ( alfabeto[j] !=letra[i]) j++; alfa[j]=1;

ANEXOS

} consistencia++; }while (!feof(infile)); fclose(infile); for(i=0;i<TA;i++) if(alfa[i]==1) longitud++; lenguaje = (char *)malloc(sizeof( char)*longitud); for(i=0;i<longitud;i++) lenguaje[i]='0'; j=0; for(i=0;i<TA;i++) if(alfa[i]==1){ lenguaje[j]=alfabeto[i]; j++; } tam_lenguaje=longitud; } /* Buscar un estado determinado del automata en la lista*/ Estados *buscar(Estados *cabecera, int num_estado) { Estados *actual = cabecera; if(num_estado==-1){ printf("%d\n",num_estado); getch(); } if(num_estado!=-1){ while (actual != NULL && num_estado != actual->id_estado){ if(actual==NULL) printf("\n actual = NULL en buscar"); actual = actual->sig; }

-

} return (actual); } /* Recibe la cantidad de letras que reconoce el automata en una silaba y regresa un número el cual involucra las letras reconocidas por el automata así como el estado en que termina*/

ANEXOS

float calcula_c1(int num_recibidos,int longitud, int aux) { if(num_recibidos==longitud && aux==1) return((float)(num_recibidos+1)/(float)(longitud+1)); else return((float)(num_recibidos)/(float)(longitud+1)); } /* Regresa un número relacionado con el tamaño del automata (número de estados) y el número de estados máximo que puede tener un automata*/ float calcula_c2(int t_estados) { float c2; if(t_estados>=MAXES) return(0.0); else { c2=(float)(MAXES -t_estados)/(float)(MAXES); return(c2); } } /* Cuenta las cadenas que reconoce el automata */ int calcula_c3(Individuo *ind){ Estados *edo_a=NULL; int i=0, sil_rec=0,pos,transicion,transicion_ant; int ultimaposicion[MAXES], ultimoestado[MAXES]; for(i=0; i<MAXES; i++){ ultimaposicion[i]=0; ultimoestado[i]=0; } ultimaposicion[0]=1;

-

ultimoestado[0]=0; i=0; while(i>=0){ pos=ultimaposicion[i]; transicion=ultimoestado[i]; while(pos<=tam_lenguaje){ edo_a=buscar(ind->raiz,transicion); transicion_ant=transicion;

ANEXOS

transicion=edo_a->transicion[pos]; if( edo_a->transicion[0]==-1 && pos==1 ) { sil_rec++; } if(transicion==-1) { transicion=transicion_ant; pos++; } else{ ultimaposicion[i]=pos+1; ultimoestado[i]=transicion_ant; i++; pos=1; } if(i >= MAXES) { return 0; } } i--; } return sil_rec; } /* Le asigna el grado de adaptación (fitness) que tiene el hijo, este fitness se calcula utilizando a las funciones calcula_c1, calcula_c2 y calcula_c3 */ void evalua_hijo(Individuo *hijo) { FILE *infile; char silabas[TS]="" ;

-

int n=0,i=0,longitud=0,num_silabas=0, num_sil_acep=0; int letras_aceptadas=0,aux1=0; int edo_final=0,t_estados=0; float fitness_c1=0.0,fitness_c2=0.0,x_max=0.0,fitness_c3=0.0; Estados *aux=NULL,*aux_e=NULL; if ((infile=fopen(nom_archivo,"r"))==NULL){ printf("\nNo se puede abrir el archivo de entrada para evaluar.\n"); exit(1);

ANEXOS

} do{ fscanf(infile,"%s",silabas); fflush(stdin); longitud=strlen(silabas); aux=hijo->raiz; while (i<longitud && aux1!=-1){ n=0; aux_e=buscar(aux,aux1); while (silabas[i]!=lenguaje[n]) n++; aux1=aux_e->transicion[n+1]; if (aux1!=-1) letras_aceptadas++; i++; } i=0; if (aux1!=-1) aux_e=buscar(aux,aux1); if (longitud==letras_aceptadas && aux_e->transicion[0]==-1) edo_final=1; fitness_c1+=calcula_c1(letras_aceptadas,longitud,edo_final); num_silabas++; aux1=0; letras_aceptadas=0; edo_final=0; }while (!feof(infile)); fclose(infile); t_estados=hijo->total_estados; fitness_c2+=calcula_c2(t_estados); num_sil_acep=calcula_c3(hijo);

-

x_max=num_sil_acep-num_silabas; x_max=x_max*x_max; fitness_c3=(float)MAX/(float)(1+((float)M2*x_max)); hijo->fitness=fitness_c1*W1+(float)fitness_c2*W2+(float)fitness_c3*W3; hijo->letras_aceptadas=num_sil_acep; } /* Manda a evaluar a toda la población */ void evalua_poblacion(void)

ANEXOS

{ int r=0,c=0; for(r=0;r<N;r++) for(c=0;c<N;c++){ evalua_hijo(&poblacion[r][c]); } } /* Imprime mensaje de error cuando no hay memoria */ void error(void) { perror("Espacio Insuficiente"); exit (1); } /* Regresa un número flotante */ float num_float(void) { float x; x=(float)(rand()%1000)/1000.0; return x; } /* Visualizar la lista */ /* Se encarga de mandar los resultados a un archivo trans es el resultado final*/ void visualiza_poblacion(void) { FILE *salida; int r,c,k; float maximo=0.0; Individuo *actual=NULL; Estados *actual_es=NULL; if ((salida=fopen("c:\\proyecto\\trans.txt","w"))==NULL){ printf("\nNo se puede crear el archivo de salida.\n"); exit(1);

-

} maximo=consistencia*W1+tamano*W2+genera*W3; fprintf(salida,"El valor de constantes utilizadas son las siguientes :\n"); fprintf(salida,"El tama¤o de la matriz de poblacion NxN donde N = %d Individuos %d \n",N,N*N); fprintf(salida,"El numero maximo de estados que puede tener un automata : %d\n",MAXES); fprintf(salida,"Probabilidad de cruzamiento : %4.4f\n",PC); fprintf(salida,"Probabilidad para que se palique state merge: %4.4f\n",SM);

ANEXOS

fprintf(salida,"Probabilidad para que se palique state split: %4.4f\n",SS); fprintf(salida,"Numero maximo de simbolos que esten en una silaba: %d\n",TS); fprintf(salida,"Numero maximo de simbolos para lenguaje: %d\n",TA); fprintf(salida,"Para la funcion de fitness\n"); fprintf(salida,"\tEn generalizacion MAX : %d\n",MAX); fprintf(salida,"\tEn generalizacion M2 %4.4f\n",M2); fprintf(salida,"\tPeso w1 : %4.4f\n",W1); fprintf(salida,"\tPeso w2 : %4.4f\n",W2); fprintf(salida,"\tPeso w3 : %4.4f\n",W3); fprintf(salida,"El valor maximo de variables en la funcion fitness\n"); fprintf(salida,"\tConsistencia tama¤o generalizacion\n"); fprintf(salida,"\t %d %4.4f %d\n",consistencia,tamano,MAX); fprintf(salida,"El fitness maximo que puede optener un individuo es:%4.4f\n\n\n\n",maximo); fprintf(salida,"El mejor individuo es:%d\n",poblacion[mejor_r][mejor_c].id); for (r=0;r<N;r++) for (c=0;c<N;c++){ actual=&poblacion[r][c]; fprintf(salida,"\nINDIVIDUO : %d fitness%4.4f\n",actual->id,actual->fitness); fprintf(salida,"%d let\n",actual->letras_aceptadas); fprintf(salida,"\n |I/F"); for (k=0;k<tam_lenguaje;k++) fprintf(salida,"| %c ",lenguaje[k]); fprintf(salida,"\n"); actual_es=actual->raiz; while (actual_es != NULL){ fprintf(salida,"ESTADO %d ", actual_es->id_estado); for(k=0;k<=tam_lenguaje;k++) fprintf(salida,"|%2d ",actual_es->transicion[k]);

-

fprintf(salida,"\n"); actual_es=actual_es->sig; } } fclose(salida); } /* Visualizar la lista crea archivo transh*/

ANEXOS

/* Se encarga de mandar los resultados a un archivo el archivo es al inicio de la poblacion*/ void visualiza_poblacionh(void) { FILE *salida; int r,c,k; Individuo *actual=NULL; Estados *actual_es=NULL; if ((salida=fopen("c:\\proyecto\\transh.txt","w"))==NULL){ printf("\nNo se puede crear el archivo de salida.\n"); exit(1); } fprintf(salida,"El mejor individuo es:%d\n",poblacion[mejor_r][mejor_c].id); for (r=0;r<N;r++) for (c=0;c<N;c++){ actual=&poblacion[r][c]; fprintf(salida,"\nINDIVIDUO : %d fitness%4.4f\n",actual->id,actual->fitness); fprintf(salida,"%d let\n",actual->letras_aceptadas); fprintf(salida,"\n |I/F"); for (k=0;k<tam_lenguaje;k++) fprintf(salida,"| %c ",lenguaje[k]); fprintf(salida,"\n"); actual_es=actual->raiz; while (actual_es != NULL){ fprintf(salida,"ESTADO %d ", actual_es->id_estado); for(k=0;k<=tam_lenguaje;k++) fprintf(salida,"|%2d ",actual_es->transicion[k]); fprintf(salida,"\n"); actual_es=actual_es->sig; } }

-

fclose(salida); } /* Se encarga de mandar los resultados a un archivo, pero con un formato especial ya que este archivo que se genera se utiliza para generar la poblacion */ void genera_archivo(void)

ANEXOS

{ FILE *salida; int r,c,k; Individuo *actual=NULL; Estados *actual_es=NULL; if ((salida=fopen("c:\\proyecto\\generado.txt","w"))==NULL){ printf("\nNo se puede crear el archivo generado.\n"); exit(1); } for (r=0;r<N;r++) for (c=0;c<N;c++){ actual=&poblacion[r][c]; fprintf(salida,"%4.4f\n",actual->fitness); actual_es=actual->raiz; while (actual_es != NULL){ for(k=0;k<=tam_lenguaje;k++) fprintf(salida,"%4d",actual_es->transicion[k]); fprintf(salida,"\n"); actual_es=actual_es->sig; } fprintf(salida,"te\n"); } fclose(salida); } /*Genera un numero aleatorio para decir la transicion*/ /*Genera un número aleatorio en 0 y total de estados menos uno */ int random0(int tot_es) { int x;

-

x=(rand()%(tot_es+1)-1); return x; } /* Regresa un numero (-1 o 1) */ int etiqueta(void) { int x;

ANEXOS

x=rand()%2; if(x==0) x=-1; return x; } /*Genera un numero aleatorio entre un limite inferior y otro superior*/ int num_estados(int inferior, int superior) { int x; x=(rand()%(superior-inferior+1))+inferior; return x; } /* Se encarga de llenar un estado, le pone un identificar el cual es un número consecutivo, al arreglo transicion lo llena la primer casilla con -1 o 1 (-1 indica si es estado final y 1 si no lo es) , el arregla t_utilizada lo llena con -1's*/ void inicializa_estado(Individuo *ind) { int j=0,i=0,t_estados=0; Estados *aux=NULL,*aux1=NULL; t_estados=ind->total_estados; for(i=0;i<t_estados;i++){ aux1=(Estados *)malloc(sizeof(Estados)); if(!aux1) { error(); } aux1->id_estado=i; //CAMBIOS DE ETIQUETA EN EL EDO CERO if(i==0){

-

aux1->t_utilizada[0]=-1; aux1->transicion[0]=1; } else { aux1->t_utilizada[0]=-1; aux1->transicion[0]=etiqueta(); } for (j=1;j<=tam_lenguaje;j++){

ANEXOS

aux1->transicion[j]=random0(t_estados); aux1->t_utilizada[j]=-1; } aux1->sig=NULL; aux=ind->raiz; if (ind->raiz==NULL) ind->raiz=aux1; else { while (aux->sig!=NULL) aux=aux->sig; aux->sig=aux1; } } } /*Como su nombre lo dice genera la población total con la que se va a empezar */ void genera_pob_inicial(void) { int r,c,n_estados,n=1,i; time_t t; srand((unsigned) time(&t)); for (r=0;r<N;r++) for (c=0;c<N;c++){ poblacion[r][c].id=n; poblacion[r][c].raiz=NULL; poblacion[r][c].total_estados=num_estados(2,4); poblacion[r][c].fitness=0.0; poblacion[r][c].letras_aceptadas=0; inicializa_estado(&poblacion[r][c]); n++; } } /*Muestra las opciones que tiene el programa */ int menu(void)

-

{ int opcion; do{ clrscr(); printf("\n 1. Generacion de una poblacion aleatoria"); printf("\n 2. Continuar con la busqueda del AFD. Cargar archivo "); printf("\n Seleciona una opcion: "); scanf("%d",&opcion);

ANEXOS

fflush(stdin); }while(opcion!=1 && opcion!=2); return opcion; } /* Quita los ciclos del automata que tiene hacia el mismo estado */ void quitar_cm(Individuo *individuo) { Estados *aux=NULL; int i,j; aux=individuo->raiz; while(aux!=NULL){ for(i=1;i<=tam_lenguaje;i++){ if(aux->transicion[i]==aux->id_estado || aux->transicion[i]==0){ do{ j=random0(individuo->total_estados); }while(j==aux->id_estado || j==0); aux->transicion[i]=j; } } aux=aux->sig; } } /* Quita ciclos que se hacen con mas de dos estados */ void quitar_ciclos(Individuo *individuo) { FILE *infile; Estados *aux=NULL,*raiz=individuo->raiz; int i,j,m,longitud,guarda_estado[TS],bandera, transicion; char silaba[TS]; if ((infile=fopen(nom_archivo,"r"))==NULL){ printf("\nNo se puede abrir el archivo %s %d de entrada para quitar ciclos.\n",nom_archivo,infile);

-

exit(1); } do{ bandera=0; transicion=0; for(i=0;i<TS;i++) guarda_estado[i]=-1;

ANEXOS

guarda_estado[0]=0; fscanf(infile,"%s",silaba); fflush(stdin); longitud=strlen(silaba); i=0; while(i<longitud && transicion!=-1){ aux=buscar(raiz,transicion); j=0; while(silaba[i]!=lenguaje[j]) j++; transicion=aux->transicion[j+1]; m=0; while(transicion!=-1 && m<=i && bandera==0){ if(guarda_estado[m]!=transicion) m++; else bandera=1; } if(bandera==0 && transicion!=-1) guarda_estado[i+1]=transicion; else transicion=aux->transicion[j+1]=-1; if(aux->transicion[j+1]!=-1) aux->t_utilizada[j+1]=1; i++; } }while(!feof(infile)); fclose(infile); } /* Quita las transicones que no son utilizadas */ void quitar_transiciones(Individuo *individuo) {

-

Estados *aux=individuo->raiz; int i; while(aux!=NULL){ for(i=1;i<=tam_lenguaje;i++) if(aux->transicion[i]!=-1 && aux->t_utilizada[i]==-1) aux->transicion[i]=-1; aux=aux->sig;

ANEXOS

} } /*Quita ciclos restantes que tiene el automata */ int quitar_cic_res(Individuo *ind,int cadena[MAXES],int renglon,int j){ int i=0,cad=0,edo_final=0,c=0,aux=0,t=0,ren_ant=0,rcj=0; Estados *lista=NULL; lista=buscar(ind->raiz,renglon); if(renglon!=0) for(t=0;t<j;t++){ aux=cadena[t]; if (aux!=final) { for(c=1;c<=tam_lenguaje;c++){ if (aux==lista->transicion[c]){ lista->transicion[c]=-1; cad=1; } } if (cad==1) return cad=1; } } else if (renglon==0) final=0; for(i=1;i<=tam_lenguaje;i++) { lista=buscar(ind->raiz,renglon); if(lista->transicion[i]!=-1 ) { cadena[j]=lista->transicion[i]; rcj=j; j++; ren_ant=renglon; renglon=lista->transicion[i]; cad=quitar_cic_res(ind,cadena,renglon,j); renglon=ren_ant;

-

j=rcj; } else edo_final++; if(edo_final==tam_lenguaje ){ final=renglon; return(cad=1); }

ANEXOS

} return(cad); } /* Se encarga de quitar todos los ciclos que tiene el automata así como las transiciones que no son utilizadas, esto lo hace con la ayuda de los procedimientos quitar_cm, quitar_ciclos, quitar_transiciones y con la funcion quitar_cic_res */ void validar_individuo(Individuo *individuo) { int i=0,aux=0,cadena[MAXES]; for (i=0;i<MAXES;i++) cadena[i]=0; quitar_cm(individuo); quitar_ciclos(individuo); quitar_transiciones(individuo); aux=quitar_cic_res(individuo,cadena,0,0); if (i==100) printf("exito %d",aux); } /*Procedimiento que manda a validar a toda la poblacion */ void validar_poblacion(void) { int r,c; for(r=0;r<N;r++) for(c=0;c<N;c++) validar_individuo(&poblacion[r][c]); } /* Procedimiento que duplica un individuo */ void copiar(Individuo *padre,Individuo *hijo) {

-

int i,j,t,b; Estados *estadoh=NULL,*estadop=NULL; hijo->id=padre->id; hijo->total_estados=padre->total_estados; hijo->fitness=padre->fitness; hijo->letras_aceptadas=padre->letras_aceptadas; hijo->raiz=NULL; inicializa_estado(hijo);

ANEXOS

estadoh=hijo->raiz; estadop=padre->raiz; while(estadoh!=NULL){ for(i=0;i<=tam_lenguaje;i++) estadoh->transicion[i]=estadop->transicion[i]; estadoh=estadoh->sig; estadop=estadop->sig; } } /* Procedimiento que libera la mamoria de un individuo */ void libera_memoria(Individuo *ind) { Estados *aux=NULL,*aux1=NULL; do{ aux1=ind->raiz; aux=aux1->sig; ind->raiz=aux; free(aux1) ; }while (ind->raiz!=NULL); } /*Procedimiento que se encarga de llevar a cabo el operador de cruzamiento del algoritmo genetico*/ void cruza_individuo(Individuo *padre1, Individuo *padre2,Individuo *hijo) { int offset=0, i=0, j=0,k=0,te=0,aleatorio=0; int ifinal=0,taux=0; float p; Estados *auxh=NULL,*auxp1=NULL,*auxp2=NULL; hijo->id=padre1->id; hijo->total_estados=0;

-

hijo->fitness=0.0; hijo->letras_aceptadas=0; hijo->raiz=NULL; do{ offset=num_estados(-2,2); hijo->total_estados=(padre1->total_estados)+offset; }while(hijo->total_estados<=2 || hijo->total_estados>=MAXES); inicializa_estado(hijo);

ANEXOS

i=0; while((i<hijo->total_estados) && (i< padre1->total_estados) && (i<padre2->total_estados)){ te= hijo->total_estados; auxp1=buscar(padre1->raiz,i); auxp2=buscar(padre2->raiz,i); auxh=buscar(hijo->raiz,i); for(k=0;k<=tam_lenguaje;k++){ aleatorio=random(padre1->fitness+padre2->fitness); if (aleatorio > padre1->fitness){ auxh->transicion[k]=auxp2->transicion[k]; if(auxh->transicion[k]>=te){ do{ auxh->transicion[k]=random0(te); }while (auxh->transicion[k]>=te); } } else{ auxh->transicion[k]=auxp1->transicion[k]; if(auxh->transicion[k]>=te){ do{ auxh->transicion[k]=random0(te); }while (auxh->transicion[k]>=te); } }

-

} i++; } if(i<hijo->total_estados){ while(i<padre1->total_estados && i<hijo->total_estados){ auxp1=buscar(padre1->raiz,i); auxh=buscar(hijo->raiz,i); for(j=0;j<=tam_lenguaje;j++){

ANEXOS

auxh->transicion[j]=auxp1->transicion[j]; if(auxh->transicion[j]>=te){ do{ auxh->transicion[j]=random0(te); }while (auxh->transicion[j]>=te); } } ///*** ifinal=i; i++; } while(i<padre2->total_estados && i<hijo->total_estados){ auxp2=buscar(padre2->raiz,i); auxh=buscar(hijo->raiz,i); for(j=0;j<=tam_lenguaje;j++){ auxh->transicion[j]=auxp2->transicion[j]; if(auxh->transicion[j]>=te) do{ auxh->transicion[j]=random0(te); }while (auxh->transicion[j]>=te); } ///// ifinal=i; i++; } } ////

-

if (i-1<hijo->total_estados){ auxp2=buscar(hijo->raiz,ifinal); taux =rand () %(tam_lenguaje-1); taux=taux+1; auxp2->transicion[taux]=i; } }

ANEXOS

/* Regresa un -1 si recibe un 1 y un 1 si recibe un -1 */ int cambia_etiqueta(int etiqueta) { if(etiqueta==1) etiqueta=-1; else etiqueta=1; return(etiqueta); } /*Procedimiento que se encarga de llevar a cabo el operador de mutacion del algoritmo genetico*/ void mutacion(Individuo *hijo) { float p,x; int i,j,t_estados=0,ca; Estados *mut=NULL,*aux1=NULL; t_estados=hijo->total_estados; p=1.0/(float)(t_estados); aux1=hijo->raiz; for(i=1;i<t_estados;i++){ x=num_float(); if(x<p){ mut=buscar(aux1,i); ca=mut->transicion[0]; mut->transicion[0]=cambia_etiqueta(ca); for(j=1;j<=tam_lenguaje;j++){ x=num_float(); if(x<p) mut->transicion[j]=random0(t_estados); } } }

-

} /* Compara si dos arreglos son iguales */ int compara(Estados *aux1, Estados *aux2){ int i=1, bandera=0; while(i<=tam_lenguaje && bandera!=1){ if(aux1->transicion[i]==aux2->transicion[i]) i++;

ANEXOS

else bandera=1; } if(bandera==1) return 0; else return 1; } /* Asigna memoria de tipo Estados */ Estados *nuevo_elemento(void) { Estados *p=(Estados *)malloc(sizeof(Estados)); if(!p) error(); return(p); } /* Inserta un estado a la lista recibida */ Estados *inserta_estado(Estados *cabecera, Estados *aux) { Estados *aux1=NULL; if (cabecera==NULL) cabecera=aux; else{ aux1=cabecera; while (aux1->sig!=NULL) aux1=aux1->sig; aux1->sig=aux; } return cabecera; }

-

/* Le asigna al individuo recibido un identificador y a la raiz de la lista la incializa a NULL*/ void inicializa_individuo(Individuo *individuo,int i) { individuo->id=i; individuo->raiz=NULL; } /* Crea e inicializa un nuevo estado para el automata */

ANEXOS

Estados *crea_estado(int i) { Estados *aux=NULL; aux=nuevo_elemento(); aux->id_estado=i; aux->sig=NULL; return aux; } /*Procedimiento que se encarga de llevar a cabo el operador state_merge del algoritmo genetico*/ void state_merge(Individuo *individuo){ Estados *aux1=NULL, *aux2=NULL,*aux4=NULL; int par1[MAXES], par2[MAXES], i=0, j=0, par_selec,estado_borrar,num_es=0; for(i=0;i< MAXES;i++){ par1[i]=-1; par2[i]=-1; } i=0; aux1=individuo->raiz; while(aux1->sig!=NULL){ aux2=aux1->sig; while(aux2 !=NULL){ j=compara(aux1,aux2); if(j==1){ par1[i]=aux1->id_estado; par2[i]=aux2->id_estado; aux2=aux2->sig; if(aux2==NULL) aux1=aux1->sig; i++; } else{

-

aux2=aux2->sig; if(aux2==NULL) aux1=aux1->sig; } } } if(par1[0]!=-1){

ANEXOS

par_selec=rand()%i; estado_borrar=rand()%2; if(estado_borrar==0){ aux1=buscar(individuo->raiz,par1[par_selec]); aux2=buscar(individuo->raiz,par2[par_selec]); } else{ aux1=buscar(individuo->raiz,par2[par_selec]); aux2=buscar(individuo->raiz,par1[par_selec]); } /*Quita transiciones que llevan al estado aux1 que va hacer borrado y las cambia a aux2*/ if (aux1->id_estado==0) individuo->raiz=aux1->sig; else{ if (aux1->id_estado==individuo->total_estados-1){ aux4=buscar(individuo->raiz,aux1->id_estado-1); aux4->sig=NULL; } else{ aux4=buscar(individuo->raiz,aux1->id_estado-1); aux4->sig=aux1->sig; aux1->sig=NULL; } } aux4=individuo->raiz; num_es=0; while (aux4!=NULL){ aux4->id_estado=num_es; for(j=1;j<=tam_lenguaje;j++) if(aux4->transicion[j]==aux1->id_estado) aux4->transicion[j]=aux2->id_estado;

-

num_es++; aux4=aux4->sig; } free(aux1); individuo->total_estados=num_es; } }

ANEXOS

/*Procedimiento que se encarga de llevar a cabo el operador state_split del algoritmo genetico*/ void state_split(Individuo *individuo){ Estados *aux1=NULL, *auxs1=NULL,*auxs2=NULL, *aux3=NULL; int num_transiciones=0, i=1, bandera=0, j; int arreglo[MAXES],par=0, arreglo1[MAXES]; for (j=0;j<MAXES;j++){ arreglo[j]=-1; arreglo1[j]=-1; } aux1=individuo->raiz; j=0; while(aux1->sig !=NULL){ while(i<=tam_lenguaje && bandera!=1){ if(aux1->transicion[i]!=-1){ num_transiciones++; if(num_transiciones>1){ if (par==0){ arreglo[j]=aux1->id_estado; par=1; bandera=1; } else{ arreglo1[j]=aux1->id_estado; j++; par=0; bandera=1; } //fin else } //finif tran>1 i++; } else i++;

-

} aux1=aux1->sig; i=1; bandera=0; num_transiciones=0; } if (j>0){ i=rand()%(j);

ANEXOS

auxs1=buscar(individuo->raiz,arreglo[i]); auxs2=buscar(individuo->raiz,arreglo1[i]); aux3=crea_estado(individuo->total_estados); individuo->raiz=inserta_estado(individuo->raiz,aux3); for(i=0;i<=tam_lenguaje;i++) aux3->transicion[i]=auxs2->transicion[i]; do{ j=num_estados(1,tam_lenguaje); }while(auxs1->transicion[j]==-1); auxs1->transicion[j]=individuo->total_estados; individuo->total_estados+=1; } } /*Procedimiento que lleva a cabo el algoritmo genetico */ void algoritmo_genetico(void) { int m_vecino[2], vecinos[8][2], r=0, c=0,vc=0,vr=0,x,y; float num_a; Individuo *padre1=NULL,*padre2=NULL,hijo; for(r=0;r<N;r++) for(c=0;c<N;c++){ padre1=&poblacion[r][c]; num_a=num_float(); if(num_a>PC) copiar(padre1,&hijo); else{ busca_vecinos(r,c,vecinos,m_vecino); vr=m_vecino[0]; vc=m_vecino[1]; if(padre1->fitness > poblacion[vr][vc].fitness) padre2=&poblacion[r][c]; else

-

padre2=&poblacion[vr][vc]; cruza_individuo(padre1,padre2,&hijo); } mutacion(&hijo); validar_individuo(&hijo); evalua_hijo(&hijo); if(padre1->fitness < hijo.fitness){ libera_memoria (padre1);

ANEXOS

copiar(&hijo,padre1); } libera_memoria(&hijo); } x=rand()%N; y=rand()%N; if(num_float()<=SM){ state_merge(&poblacion[x][y]); //printf("empiezavalidater marget\n"); validar_individuo(&poblacion[x][y]); evalua_hijo(&poblacion[x][y]); } if(num_float()<=SS){ if (poblacion[x][y].total_estados<MAXES){ state_split(&poblacion[x][y]); //printf("\nstatesplit"); validar_individuo(&poblacion[x][y]); evalua_hijo(&poblacion[x][y]); } } } /* Procedimiento que libera la memoria de los individuos */ void libera_memoria_t(void){ int r,c; for (r=0;r<N;r++) for (c=0;c<N;c++) libera_memoria(&poblacion[r][c]); free(lenguaje); } /*Procedimiento que se encarga incicializar la poblacion con los datos del archivo */

-

void carga_archivo() { FILE *generado=NULL; Individuo *aux_in; Estados *aux_es; char cargado[30], aux_sil[10]="", fin[]="te"; int id_ind, id_edo, i, r, c; printf("\nNombre del archivo a cargar: ");

ANEXOS

scanf("%s",cargado); fflush(stdin); if ((generado=fopen(cargado,"r"))==NULL){ printf("\nNo se puede abrir el archivo a cargar.\n"); exit(1); } id_ind=1; for(r=0;r<N;r++) for(c=0;c<N;c++){ aux_in=&poblacion[r][c]; inicializa_individuo(aux_in,id_ind); id_edo=0; fscanf(generado,"%s",aux_sil); fflush(stdin); aux_in->fitness=atof(aux_sil); fscanf(generado,"%s",aux_sil); fflush(stdin); while((strcmp(aux_sil,fin))!=0){ aux_es=crea_estado(id_edo); for(i=0;i<=tam_lenguaje;i++) aux_es->t_utilizada[i]=-1; aux_es->transicion[0]=atoi(aux_sil); for(i=1;i<=tam_lenguaje;i++){ fscanf(generado,"%s",aux_sil); fflush(stdin); aux_es->transicion[i]=atoi(aux_sil); if(aux_es->transicion[i]!=-1) aux_es->t_utilizada[i]=1; } aux_in->raiz=inserta_estado(aux_in->raiz,aux_es); id_edo++; fscanf(generado,"%s",aux_sil); fflush(stdin);

-

} poblacion[r][c].total_estados=id_edo; id_ind++; } fclose(generado); } /*Procedimiento que encuentra en el mejor individuo de la población */ void encuentra_mejor() {

ANEXOS

int r,c,totfin; mejor_r=0; mejor_c=0; for(r=0;r<N;r++) for(c=0;c<N;c++){ if(poblacion[r][c].fitness>poblacion[mejor_r][mejor_c].fitness){ mejor_r=r; mejor_c=c; } else if(poblacion[r][c].fitness==poblacion[mejor_r][mejor_c].fitness){ if(poblacion[mejor_r][mejor_c].total_estados > poblacion[r][c].total_estados) { mejor_r=r; mejor_c=c; } } } } /*Procedimiento principal*/ void main(void) { float x=0.0; int con=0, opcion; clrscr(); printf( "ESTE PROGRAMA LEE UN ARCHIVO TEXTO SU CONTENIDO ES UNA LISTA DE CADENAS DE SIMBOLOS "

-

"( CADENAS ). SE TIENE COMO RESULTADO UN ARCHIVO QUE CONTIENE LA TABLA DE TRANSICION " "POR INDIVIDUO DE LA POBLACION.\n " " \n\n\toprima cualquier tecla para continuar" ); getch (); opcion=menu(); pide_datos(); selecciona_len();

ANEXOS

x=MAXES; tamano=(x-2)/x; genera= MAX; if(opcion==1){ genera_pob_inicial(); validar_poblacion(); evalua_poblacion(); visualiza_poblacionh(); } else { carga_archivo(); visualiza_poblacionh(); evalua_poblacion(); } while(con<num_gen){ con++; printf("generacion %d\n",con); algoritmo_genetico(); } encuentra_mejor(); visualiza_poblacion(); genera_archivo(); libera_memoria_t(); printf("\nExito"); getch(); }

-

ANEXOS

D) PRUEBA DE DIGITOS

El valor de constantes utilizadas son las siguientes: El tamaño de la matriz de población NxN donde N = 6 Individuos 36 El numero máximo de estados que puede tener un autómata : 10 Probabilidad de cruzamiento: 0.5000 Probabilidad para que se palique state merge: 0.0100 Probabilidad para que se palique state split: 0.0100 Numero máximo de símbolos que estén en una cadenaa: 10 Numero máximo de símbolos para lenguaje: 27 Para la función de fitness En generalización MAX : 20 En generalización M2 0.0250 Peso w1 : 0.5000 Peso w2 : 1.0000 Peso w3 : 0.1000 El valor máximo de variables en la función fitness Consistencia tamaño generalización 17 0.8000 20 El fitness máximo que puede obtener un individuo es:11.3000 Después de 1000 El mejor individuo es:2

-

Después de 2000

para 3000 generaciones ya no cambio todos los individuo tomaron el valor de 9.3750

-

Su diagrama de transición es el siguiente:

1

2

3 4

5

6

7

0 8

c

d

n

o,u

r

s

t,v

a e

r

o

e

i

o

o

u

e,o,u

h

i

Documents

CBI - 148.206.53.84148.206.53.84/tesiuami/UAMI12078.pdflenguajes y expresiones regulares.....9 1.1 símbolos ... manual de usuario