Ajuste de controladores difusos mediante algoritmos genéticos

INSTITUTO TECNOLÓGICO Y DE ESTUDIOS SUPERIORES DE MONTERREY

CAMPUS ESTADO DE MEXICO

DIVISIÓN DE GRADUADOS E INVESTIGACIÓN DIRECCIÓ!'i DE MAESTRÍAS EN INGENIEPÍ .i

AJUSTE DE CONTROLADORES DIFUSOS MEDIANTE ALGORITMOS GENÉ,TICOS

TESIS QUE PARA OPTAR EL GRADO DE MAESTRO EN CIENCIAS COMPUTACIONALES

PRESENTA

ANTONIO VÍCTOR MEJÍA OLVERA

Asesor: Dr. Cuauhtémoc Carbajal Fer.míndez

Comité de Tesis: Dr. Jesús Figueroa Nazuno

M. en C. Arturo Cuahutle Pére1:

Jurado: M. en C. Edgar Vallejo Clemente

Dr. Cuauhtémoc Carbajal Fernández

Dr. Jesús Figueroa Nazuno

M. en C. Arturo Cuahutle Pére:~

Atizapán de Zaragoza, México, agosto de 1995.

Presidente

Secretario

Vocal

Vocal

Contenido

l. Introducción ..................................................................................................... 1

1.1 La Lógica Difusa en el ITESM-CEM .............................. ....................... 1

1.2 Objetivo de la Tesis ................................................................................ 2

1.3 Organización del documento ....................................... ........................... 2

2. Lógica Difusa .................................................................................................... 4

2.1 Lógica clásica y multivaluada ..... ......... .... .... .... .... .... ....... ....... .......... ....... 4

2.2 Conjuntos Difusos ................................................................. ................ 5

2.2.1 Notación y terminología ................. .... .... .... ... .... ....... ... .... ... ....... 5

2.2.2 Representación ......... .... ............. ............ ....... .............. .............. 6

2.2.3 Operaciones de los conjuntos difusos ........................................ 7

2.3 Relaciones difusas .................................................................................. 8

2.3.1 Operaciones entre relaciones difusas ............................................................ 9

2.4 Variables Lingüísticas ....... .... ................................. .... ....... .... ... ... ........... 1 O

3. Controladores Difusos ........................................................................................ 12

3. 1 Arquitectura............. .... .... ......... .... ......... .... .... .... ........... ....... .......... .. . . . . . . 12

3.2 Metodología de diseño ...................................... .... .... .... ... .... ... .......... ..... 12

3.3 Ciclo de un Controlador Difuso ................. .... .... .... .... ....... ... .... ... ............ 13

3.3.1 Fuzzificación ............................................. .. ............................. 14

Ajuste de Controladores Difusos mediante Algoritmos Genéticos

3. 3. l. 1 Fuzzificación para composición ................................... 14

3 .3 .1.2 Fuzzificación para disparo individual de reglas ...... ...... 14

3.3.2 Evaluación de Reglas ................................................................ 15

3. 3. 2.1 Inferencia basada en composición ............................... 16

3.3.2.2 Inferencia basada en reglas individuales ....................... 17

3 .3.3 Defuzzificación .................... .. ... .. .. .. ... .. .... .. ......... .. ..... .. ..... .. ...... 18

3 .4 Aplicación de Controladores Difusos .... .. ... ....... .. .. .. .. .. ...... ... ... .. .. ....... .... 19

3. 5 Herramientas de desarrollo ..................................................................... 21

4. Algoritmos Genéticos ......................................................................................... 23

4. 1 ¿ Qué son los Algoritmos Genéticos ? ......................................... ........... 23

4.2 Elementos de un Algoritmo Genético ..................................................... 24

4.2.1 Selección .................................................................................. 25

4 .2.2 Cruzamiento ............................................................................. 26

4.2.3 Mutación .................................................. ................................ 27

4.3 Esquemas ............................................................................................... 28

4. 3. 1 Teorema de Esquemas .............................................................. 2 9

4. 3. 1. 1 Selección ...... ... .. .................... ... .. ................. ............... 3 O

4.3.1.2 Cruzamiento ......... ......... .... ........... .... ....... ... ....... ... ...... 31

4.3.1.3 Mutación .................................................................... 32

4 .4 U so de los AG para ajuste de controladores ............ .. ............. ....... ... ...... 3 3 1

5. Diseño del Controlador Difuso y del Algoritmo Genético .............................. 34

5. 1 Sistema del Péndulo Invertido ......... ............. ............... ....... ....... ... ... ....... 34

5.2 Diseño del Controlador Difuso .................................. ............................. 36

5. 2.1 Identificación de las variables .................................................... 36

11

Contenido

5.2.2 Definición de los conjuntos difusos ............. ....... ........... ....... ..... 37

5.2.3 Definición de las reglas de control. ............................................ 38

5.3 Características del Algoritmo Genético .................................................. 39

5.3.1 Generación de los individuos .................................................... 40

5. 3. 2 Evaluación de las soluciones .............. ........ ....... ....... .... ... .... ...... 41

6. Resultados de la simulación ............................................................................. 42

6.1. Controlador original ............................................................. .................. 42

6.2. Controlador optimizado ........ ............. .................... .... ....... ....... ... ........... 43

6.3. Modelado difuso .................................................................................... 48

7. Ampliación del problema ................................................................................... 51

7. 1 Péndulo invertido con desplazamiento ....................... ....... ....... .......... ..... 51

7.2 Controlador Difuso de cuatro variables .................................................. 55

7.3 Condiciones iniciales diferentes a cero ....... .... .... ........... ....... ....... ... .... ..... 57

8. Prueba del Controlador Difuso en un sistema real ........................................ 60

8.1 Descripción ......................... .... .... ..... ......................... ............................. 60

8.2 Resultados ............................................................................................. 62

8.2.1 Controlador MEL ............................... ........... ....... .......... .......... 62

8.2.2 Controlador Difuso ........................................... ....... ... ....... ....... 63

8.2.2.1 Primer día .................................................. ... .............. 63

8.2.2.2 Segundo día ........................................ ........................ 64

9. Conclusiones y líneas futuras .......................................................................... 65

10. Referencias Bibliográficas ................................................................................ 67

lll


Apéndices

A. Listado .............................................................................................................. 71

A.1 Operador.h ............................................................................................ 72

A.2 Péndulo.h ............................................................................................... 78

A.3 Estruct.h ................................................................................................ 85

A.4 Cld-g.h ........ .................... .... ......... .... .... .................... .............. ... ....... ..... 87

A.5 Gráfica.h ................................................................................................ 89

A.6 Genetico.c ....................... ........ .... ......... .... .... .... .... .... ... .... ... .... ... ... ......... 95

B. Optimización de Reglas mediante Algoritmos Genéticos ............................... 99

B. 1 Diseño del Algoritmo Genético .............................................................. 99

B.2 Resultados ............................................................................................. 100

lV

Capítulo 1

l. Introducción

La Lógica Difusa es una teoría que fue presentada en 1965 por el Profesor Lotfi A. Zadeh de la

Universidad de California en Berkeley. Esta teoría provee un medio efectivo para capturar la

naturaleza inexacta y aproximada del mundo real ya que descansa en la idea de que todas las

cosas, como por ejemplo la temperatura y la distancia admiten grados [Lee, 1990]. La Lógica

Difusa ha madurado a través de los años y ahora ya es reconocida internacionalmente como una

disciplina científica seria, como lo muestra la organización de varios congresos especializados

como el "IEEE International Conference on Fuzzy Systems" que se lleva a cabo anualmente desde

1992 y la publicación de la revista "IEEE Transactions on Fuzzy Systems" cuyo primer número

apareció en febrero de 1993. Además, se ha convertido en el componente esencial de una nueva

generación de productos comerciales.

A decir de Toshiro Terano, director del "Laboratory for International Fuzzy Engineering

Research" (LIFE) perteneciente al Ministerio de Comercio Internacional e Industria (MITI) del

Japón, "El siglo XXI será el siglo de la tecnología difusa"[Terano, 1993].

1.1 La Lógica Difusa en el ITESM-CEM

Las primeras investigaciones de Lógica Difusa aplicada al control de procesos en el ITESM-CEM

las realizó el M. en C. Arturo Cuahutle a principios de 1992.

Como resultado de este trabajo se creó un Editor Difuso [Cuahutle y Carbajal, 1993] que permite

crear y modificar en una forma sencilla y rápida las reglas de control y las funciones de membresía

de las variables de Controladores Difusos.


Este editor es la base de los siguientes proyectos de Lógica Difusa en el ITESM-CEM:

• Interpolador difuso de 2 entradas-1 salida [Mejía, 1993]

• Síntesis de Controladores Difusos [Mejía, 1994]

• Controlador PID-Fuzzy [Lozano, 1993]

• Aplicación de la Lógica Difusa al área de robótica [Volberg and Grasa, 1993], [Grasa et al,

1993]

Un trabajo que no está basado en el Editor Difuso pero que es necesario mencionar por su

importancia dentro del Laboratorio de Electrónica Avanzada es el de Controladores Difusos

Jerárquicos [Aceves, 1994].

La elección de las funciones de membresía juega un papel esencial en el desempeño final de los

controladores, y por lo tanto es muy importante ajustar estas funciones. En general, las funciones

de membresía son ajustadas en base a prueba y error [Takagi, 1990] lo que ocasiona que el tiempo

de desarrollo del controlador se incremente, ya que cada vez que se hace una modificación se tiene

que utilizar el editor.

1.2 Objetivo de la Tesis

Tomando en consideración lo anterior, en este trabajo se presenta una estrategia de Ajuste de las

Funciones de Membresía de un Controlador Difuso mediante el uso de Algoritmos Genéticos

congruente con el desarrollo realizado hasta el momento. Esto significa que el Algoritmo Genético

está desarrollado para utilizar al máximo las propiedades de los Controladores Difusos en

funcionamiento actualmente en el ITESM-CEM sin alterar sus características, constituyéndose

como un módulo independiente que puede ser acondicionado fácilmente para cumplir con

diferentes necesidades o aplicaciones.

1.3 Organización del documento

El presente documento está dividido en los siguientes capítulos.

Los Capítulos 2, 3 y 4 establecen el marco conceptual de la Tesis presentando los conceptos de la

Lógica Difusa, Controladores Difusos y Algoritmos Genéticos, respectivamente.

El Capítulo 5 explica el diseño de un Controlador Difuso que se aplica al problema del péndulo

invertido y un Algoritmo Genético utilizado para ajustar el controlador.

2

Introducción

El Capítulo 6 muestra los resultados obtenidos en la simulación del Controlador Difuso y el

Capítulo 7 describe su utilización en un péndulo invertido real. El Capítulo 8 presenta un

Controlador Difuso utilizado en la ampliación del problema del péndulo invertido.

Finalmente, en el Capítulo 9 se presentan las conclusiones obtenidas durante el desarrollo de la

Tesis y se introducen las posibles extensiones que pueden desarrollarse en un futuro para ampliar

el alcance del trabajo realizado.

Este trabajo cuenta también con dos Apéndices. El primero presenta el código del Algoritmo

Genético usado, así como las rutinas que lo unen con el Controlador Difuso. El segundo apéndice

muestra los resultados preliminares de la continuación de este trabajo, la optimización de las reglas

de un controlador difuso mediante Algoritmos Genéticos.

3

Capítulo 2

2. Lógica Difusa

En este capítulo se dará una introducción teórica de la Lógica Difusa cuya base son los conjuntos

difusos. Los conceptos aquí presentados son necesarios para comprender el funcionamiento de los

Controladores Difusos.

2.1 Lógica clásica y multivaluada

Un conjunto en la lógica clásica se define como una colección de objetos o elementos

pertenecientes a un universo de discurso U Cada elemento de U puede pertenecer o no a un

conjunto A, AcU.

Un conjunto clásico A puede definirse por medio de una función característica X (también

denominada función de membresía) que asigna uno a los miembros del conjunto y cero a los no

miembros:

XA:U---, {0,1}

xA(u} = t si u EA

si u ~A

Lógica Difusa

A principios del presente siglo, Jan Lukasiewicz presentó un trabajo sobre Lógica Multivaluada,

en la que además de los valores binarios de la lógica clásica (0,1) agregaba un tercer valor (1/2);

después afirmó que podía insertar no sólo uno, sino un número infinito de valores todos ellos entre

cero y uno. De la misma fonna, en 1937 Max Black propuso los "conjuntos vagos", que pueden

ser considerados los antecesores de los Conjuntos Difusos presentados en 1965 por Lotfi Zadeh

[Kosko, 1993].

2.2 Conjuntos Difusos

A diferencia de los conjuntos en la lógica clásica, el concepto clave en los conjuntos difusos es el

de membresía gradual. Un conjunto puede tener miembros que pertenecen a él parcialmente, o

sea, en grados [McNeilland and Freiberger, 1993]. Esto lo podemos observar en la definición de

conjuntos difusos dada por Zadeh [Zadeh, 1965]:

Un conjunto difuso A de un universo de discurso U está representado por una

función de membresía µA: U ~ [ O, 1] la cual asocia a cada elemento y de U un

número µ )y) en el intervalo [ 0,1], el cual representa el "grado de membresía" de y en A.

2.2.1 Notación y terminología

Partiendo de la definición anterior se establece la siguiente notación y terminología [Zadeh, 1973].

El soporte de A es el conjunto de puntos en U en los cuales µ)y) es positivo. Un punto de

cruce en A es un elemento de U cuyo grado de membresía en A es 0.5. Un singleton es un

conjunto difuso cuyo soporte es un único punto en U; si A es un singleton cuyo soporte es el

punto y, se puede denotar como:

A= µ/y donde µ es el grado de membresía de y en A.

Confonne a lo anterior, un conjunto difuso A puede ser visto como la unión de sus singletones, así

A puede ser denotado como

5


Si A tiene un soporte finito {y1,y2,. ··YnL puede ser denotado con la sumatoria siguiente:

Por ejemplo, considere el conjunto universo U={O, 1,2, ... , 10} y el siguiente conjunto difuso A.

A= 0/0 + 0.25/1 + 0.35/2 + 0.56/3 + 0.83/4 + 1.0/5 + 0.83/6 + 0.56/7 + 0.35/8 + 0.25/9 + 0/10

Este conjunto difuso puede ser representado como se muestra en la figura 2-1.

,v 1 '¡ a,

0.8 0.83 .83 .. .e E a, 0.6

/ 0.56 E a, ~6

0.4 "C ~0.35 -~ o

"C / \25 ca 0.2 .. e,

""' o 11------+

o 1 2 3 4 5 6 7 8 9 10

Enteros (U)

Fig 2-1 Definición del conjunto difuso A

2.2.2 Representación

Las funciones de membresía pueden ser representadas de muy diversas formas, trapezoidal,

triangular, en forma de campana, etc. La forma trapezoidal es una de las más comunes [Harris et

al, 1993] y está definida por la función Il(u;a,p,y,b)~[O, l].

ro 1 (u-a)/(~-a)

TI(u;a, ~' y,8) = ~ 1 l ~y - u)/(¡; - y)

u(a

a~u(~

í3 ~ll ~ y

y (u ~8

u)o

La gráfica de un ejemplo de esta función se muestra en la figura 2-2.

6

Lógica Difusa

µ

0.5

o 15 16 17 18 19 20 21 22 23 24 25 26 27

y 8

Fig 2-2 Ejemplo de la función II(u; 18,20,24,26)

2.2.3 Operaciones de los conjuntos difusos

Así como se tiene operaciones en los conjuntos clásicos tales como unión, intersección y

complemento, también los conjuntos difusos cuentan con operaciones, definidas por sus funciones

de membresía.

• Intersección

La intersección de dos conjuntos difusos A y B definidos en U es un conjunto difuso definido

en U con grado de membresía para todo x e U definida por:

• Unión

La unión de dos conjuntos difusos A y B definidos en U es un conjunto difuso definido en U

con grado de membresía para todo xe U definida por:

• Complemento

El complemento de un conjunto difuso A definido en U es un conjunto difuso definido en U con

función de membresía para todo xe U definida por:

7


2.3 Relaciones difusas Una relación difusa R de un conjunto X a un conjunto Y es un conjunto difuso de pares ordenados

(x,y) que pertenecen a X x Y. R se caracteriza por una función de membresía µR ( x, y) y se

expresa como:

R= f µR(x,y)/(x,y) XxY

Por una relación difusa R se entiende un mapeo µR: X x Y ---, [ 0,1]. Así, a cada ( x, y) E X x Y se

asigna un número dentro del intervalo [ 0,1] que expresa la fuerza de unión que se tiene entre los

elementos del par ordenado, mientras más cercano sea este valor a uno, más fuerte es la relación

que existe.

Otra forma ele representar una relación difusa entre dos

X = { x 1 , x 2 , ..• , x m } , Y = { y 1 , y 2 , ••. , y n } , es mediante una matriz de tamaño m x n

R=

µR(x1,Y1)

µR(x2,Y1)

µR(Xi,Y2)

µR(x2,Y2)

µR(x1,Yn)

µR(x2,Yn)

conjuntos

Esta matriz se conoce como matriz difusa. Dado que µR tiene valores dentro del intervalo [ 0,1],

todos los elementos de la matriz difusa tienen también valores dentro del intervalo [ 0,1].

8

Lógica Difusa

2.3.1 Operaciones entre relaciones difusas

Existen dos operaciones importantes cuando tratamos con conjuntos y relaciones difusas; éstas

son la proyección y la extensión cilíndrica [Driankov et al, 1993]. La proyección convierte una

relación ternaria en una relación binaria o una relación binaria en un conjunto difuso. La extensión

cilíndrica extiende un conjunto difuso a una relación binaria, una relación binaria la extiende a una

ternaria y así sucesivamente.

Sea R una relación definida en X x Y definida como:

Yl Y2 Y3 Y4

0.8 1 0.1 0.7

i o i 0.8 o I o i ................................................................ ,t,,,, ................. ;

1 0.9 1 1 0.7 i 0.8 i x3

La proyección de R en Y está dada por:

proy R en Y= Lm~ µR (x,y)/y

Sea F un conjunto difuso definido en X, la extensión cilíndrica de F en X x Y es el conjunto de

tuplas (x,y) e Xx Y con grados de membresía iguales a µF(x).

Por ejemplo, sea F = .7/x1 + .8/x2 + 1/x3

Su extensión cilíndrica en el dominio X X Y está dado por:

9


Yl Y2 Y3 Y4

! 0.7 l 0.7 0.7 1 0.7 !

i 0.8 ¡ 0.8 0.8 1 0.8 i 1 1 1 1

La combinación de los conjuntos y relaciones difusas con la ayuda de la extensión cilíndrica y la

proyección se denomina composición y se denota por o.

Sea A un conjunto difuso definido en X y R una relación difusa definida en X x Y, entonces la

composición de A y R que resulta en un conjunto difuso B definido en Y está dada por:

B = A o R = proy (ec(A)nR) en Y

Esta composición recibe el nombre de composición max-min y se usa en el proceso de inferencia

de los Controladores Difusos.

2.4 Variables Lingüísticas Por variable lingüística se entiende una variable cuyos valores son palabras u oraciones en un

lenguaje natural. Por ejemplo, edad es una variable lingüística si sus valores en lugar de ser

numéricos son lingüísticos, como joven, muy joven, viejo, muy viejo, etc.

Por lo regular una variable lingüística está definida por el siguiente cuarteto:

(X,.lX,X,Mx)

X denota el nombre simbólico de la variable lingüística, como por ejemplo edad, peso, velocidad o

temperatura .

.lX es el conjunto de valores lingüísticos que puede tomar X, un valor lingüístico es un símbolo

para una propiedad particular de X. En el caso de una variable lingüística temperatura se puede

tener:

.lX = {helado, frío, confortable, tibio, caliente}

10

Lógica Difusa

J; es el dominio fisico sobre el que la variable lingüística toma sus valores cuantitativos, J; puede

ser por ejemplo (0°C, 100°C] para la variable temperatura.

Mx es una función semántica que toma un valor lingüístico como argumento y regresa su

significado en términos de un conjunto difuso. Si LX denota un elemento arbitrario de JX

entonces

Mx:LX~LX

donde LX es una notación para un conjunto difuso definido en X, por ejemplo:

en el caso de X continuo

en el caso de J; discreto

11

,

Capítulo 3

3. Controladores Difusos

El control es una de las áreas en donde más se ha aplicado la Lógica Difusa. En este capítulo

explicaremos en forma detallada la estructura y metodología de diseño de un Controlador Difuso.

3.1 Arquitectura

La arquitectura típica para implementar un Controlador Difuso [White and Sofge, 1992] se

muestra en la figura 3-1.

e V

Fig 3-1 Arquitectura de un sistema de control difuso

3.2 Metodología de diseño

En el diseño de un Controlador Difuso se debe primero identificar las variables principales de

control y determinar un conjunto de funciones de membresía que tenga una granularidad

suficiente para describir los valores de estas variables lingüísticas.

Controladores Difusos

A continuación debe diseñarse un algoritmo de control basado en reglas lingüísticas de la forma

si-entonces que involucren las variables de control. Para diseñar el algoritmo se han sugerido en

la literatura cuatro métodos.

• Conocimiento y experiencia de un experto.

• Modelado de las acciones de control de un operador.

• Modelado del proceso.

• Autoorganización.

En el primer método las reglas reflejan el conocimiento empírico que tiene un operador del

proceso a controlar. En el segundo método, en lugar de entrevistar al operador, las acciones de

control realizadas por el operador se modelan pasivamente. El tercer método consiste en

desarrollar un modelo difuso de la planta que describe los posibles estados del sistema y en base a

este modelo construir un Controlador Difuso para controlar la planta. El cuarto método consiste

en el desarrollo de reglas que pueden ser ajustadas automáticamente para mejorar el desempeño

de los controladores..

3.3 Ciclo de un Controlador Difuso

El ciclo de trabajo de un Controlador Difuso se muestra en la figura 3-2.

Grados de membresía

1

ENTRADAS SALIDAS del sistema del sistema

Funelones de Membresía

Base de reglas

Fig 3-2 Ciclo de un Controlador Difuso

13

H

Intensidad de la salida


Los Controladores Difusos están divididos en tres etapas principales

• Fuzzificación

• Evaluación de reglas

• Defuzzificación

3.3.1 Fuzzificación

La fuzzificación es el proceso por el cual las entradas al sistema se transforman en conjuntos

difusos [Driankov et al, 1993]. Este proceso depende de la manera en que se evaluarán

posteriormente las reglas lingüísticas (difusas). Existen dos métodos para realizar la fuzzificación:

para composición y para disparo individual de reglas.

3.3.1.1 Fuzzificación para composición

Este tipo de fuzzificación convierte un valor de entrada e* en un conjunto difuso cuya función de

membresía para cualquier elemento e en el dominio de la variable correspondiente está dada por:

st e e

cualquier otro caso

Por ejemplo, si tenemos que el dominio de la variable es {-3, -2, -1, O, 1, 2, 3}, el conjunto difuso

A resultante del valor de entrada 2 es:

0/-3 + O/ -2 + 0/-1 + 0/0 + 0/1 + 1/2 + 0/3

3.3.1.2 Fuzzificación para disparo individual de reglas

En este tipo de fuzzificación se calcula el grado de membresía del valor de entrada para cada uno

de los conjuntos difusos de la variable correspondiente.

Por ejemplo para la función de membresia trapezoidal mostrada en la figura 3-3, el grado de

membresía correpondiente a un valor de entrada igual a 19 es O. 5

14


µ

0.5

o X 15 16 17 18 20 21 22 23 24 25 26 27

x=19

Fig 3-3 Fuzzificación

3.3.2 Evaluación de Reglas

JJA(X)=(x-a)/(b-a)

JJA(19)=(19-18)/(20-18)

JJA(19)=0.5

Las reglas difusas son la base de los controladores difusos ya que guardan el conocimiento del

operador acerca del proceso a controlar.

Una regla difusa se expresa como:

si <proposición difusa> entonces <proposición difusa>

Una proposición difusa está expresada ya sea en lenguaje natural, como por ejemplo "el error

tiene un valor grande", o en términos de variables lingüísticas. En este último caso, por ejemplo,

si se utiliza el símbolo E para identificar la variable física error y el símbolo G para el valor

particular de error grande, una proposición difusa podría quedar expresada como:

EesG

Un ejemplo de una regla difusa es:

si X es A entonces Y es B

Esta regla se representa como una relación difusa definida en X x V· donde X y V son los dominios

de las variables lingüísticas X y Y. "X es A" se conoce como antecedente de la regla y se

representa por un conjunto difuso. De la misma manera, "Y es B" se conoce como

consecuencia de la regla y se representa por otro conjunto difuso.

15


El condicional si-entonces es una relación difusa µR tal que:

donde * puede ser cualquier operador de implicación difuso. En la literatura se pueden encontrar

varios tipos de implicaciones tales como la de Lukasiewicz, Zadeh, Estocástica, Kleene-Dienes,

Sharp, Goedel e Implicación General. Si se trata de control difuso, la implicación más importante

es la de Mamdani que se define como:

por lo que la relación R está definida como:

El proceso de evaluación de reglas tiene como propósito inferir un conjunto difuso de salida a

partir del resultado del proceso de fuzzificación y de la base de reglas.

Para mostrar el proceso de evaluación de las reglas difusas tomaremos la siguiente regla como

ejemplo:

si e es PM entonces u es NS

3.3.2.1 Inferencia basada en composición

La función de membresía NS está dada por la composición de la función de membresía PM

obtenida después de: la fuzzificación para composición del valor de entrada e* con la relación

difusa (e,u) del condicional si-entonces tomando la implicación de Mamdani.

Recordando la fuzzificación para composición, el valor de entrada e* se convierte en un conjunto

difuso definido de la siguiente manera

s1 e e

cualquier otro caso

16

•

'


La función de membresía en la parte consecuente de la regla estará modificada por la

composición y se le denominará ~Ns

Para un conjunto d~: reglas primero se unen todas las relaciones si-entonces para obtener una

relación difusa final sobre la cual se efectúa la composición.

3.3.2.2 Inferencia basada en reglas individuales

Otra forma de obtener el conjunto difuso modicado NS en la parte consecuente de la regla es el

siguiente:

1. Para el valor de 1;!ntrada e se determina su grado de membresía en PM µpM( e) mediante la

fuzzificación para disparo individual de reglas.

2. Se crea la versión modificada de NS de acuerdo a la siguiente regla:

si µ NS (u) ~ µ PM (e) cualquier otro caso

El resultado de la evaluación de la regla podemos observarla en forma gráfica en la figura 3-4, en

la que se muestra la modificación en la forma de la función de rnembresía de la parte consecuente

de la regla

Si e es PM entonces u es NS

o e u

* e

Fig 3-4 Representación gráfica del disparo de una regla difusa

17


El resultado final del disparo de un conjunto de reglas mediante este método será un conjunto de

funciones de membresía modificadas que se combinarán en una función de membresía o conjunto

difuso final, esta función final se obtiene por lo general mediante la unión de todas ellas.

Los dos tipos de inferencia son equivalentes cuando se utiliza la implicación de Mamdani

[Driankov et al, 1993]. En nuestro caso utilizamos la inferencia basada en el disparo de reglas

individuales.

3.3.3 Defuzzificación

Teniendo el conjunto difuso final, resultante de la evaluación de todas las reglas difusas, la

defuzzificación es el proceso por el cual se infiere un valor real de salida para cada una de las

variables consecuentes.

Para esto se han propuesto en la literatura varios métodos, tales como:

• Centro de área/gravedad

• Centro de sumas

• Centro del área más grande

• Alturas

• Mitad del máximo

El método de alturas es simple y muy rápido, la salida u* de la variable consecuente está definida

como:

u* = ~i=~1 ___ _ n

¿µAi i=l

donde:

• i representa cada una de las funciones de membresía en la variable de salida.

• W; es el valor en el dominio de la variable de salida donde se encuentra el pico de cada

función de membresía, en el caso de una función de membresía tipo n (trapezoidal) W¡ es

igual a (f3 +y)/ 2.

18


• µA¡ es la altura de las funciones de membresía modificadas producto de la evaluación de

reglas.

Gráficamente lo podemos observar en la figura 3-5.

1

":. J..IA(l+1)

J..IAI

.... o

W(i) 1 Dominio

W(i+1)

* u

Fig 3-5 Defuzzificación por el método de alturas

3.4 Aplicación de Controladores Difusos

La mayor parte de las aplicaciones que se tienen hoy en día de Lógica Difusa las encontramos en

Japón y Corea. Además de los méritos técnicos que tienen los productos basados en la Lógica

Difusa, el impacto comercial de la palabra FUZZY o NEURO-FUZZY en sus estrategias de

mercadotecnia les ha valido una cálida recepción por parte de los consumidores ya que

actualmente se asocia con un concepto de buena calidad. Un ejemplo del uso de estas palabras en

la mercadotecnia de un producto de aire acondicionado que se encontraba a la venta en 1994 en

Japón se muestra en la figura 3-6; propaganda comercial como ésta se encuentra con gran

facilidad también en la radio y televisión.

Fig J-6 Productos con tecnología difusa

19


Una lista parcial de aplicaciones de sistemas difusos se presenta a continuación [Munakata and

Jani, 1994]:

• La primera aplicación comercial de un sistema difuso se realizó en Dinamarca, consistió en

controlar la temp«::ratura de un horno de cemento y ha estado en operación desde 1980.

• El controlador del sistema de transporte subterráneo de la ciudad de Sendai en Japón,

inaugurado el 15 de julio de 1987, es posiblemente la aplicación de Lógica Difusa más famosa

del mundo. El control de la velocidad y la aplicación de los frenos cerca de las estaciones

fueron determinadas por reglas difusas que procesan señales provenientes de sensores y

consideran factorns como comodidad y seguridad de los usuarios, es un sistema de transporte

donde no se sienten arrancones ni paros abruptos y que tiene un 10% de ahorro en sus costos

de operación al economizar energía.

• Los automóviles son una colección de muchos sistemas (motores, frenos, transmisiones, etc.) y

en algunos de ellos la Lógica Difusa ha intervenido para su perfeccionamiento. Por ejemplo, se

ha patentado una transmisión automática difusa que permite el ahorro de combustible entre un

12 y 1 7% y un sistema antibloqueo de frenos difuso que aplica la mayor cantidad de presión

posible a los frenos pero evitando que éstos se bloqueen.

• Una de las áreas donde la Lógica Difusa ha tenido una gran aceptación es en el área de

electrónica de consumo. Entre estos artículos podemos mencionar a las lavadoras, donde en

base a la cantidad y que tan sucia esté la ropa el Controlador Difuso elige un proceso de lavado

que incluye la cantidad de agua a utilizar, la fuerza y el tiempo de lavado. Actualmente también

existen aspiradoras que ajustan el nivel de succión en base a la cantidad de polvo que exista en

la alfombra o la condición del piso. Otro ejemplo muy conocido lo tenemos en las cámaras de

video donde se incorporan foco automático y sistemas de estabilización de imágenes basados en

Lógica Difusa.

• El área de administración ( evaluación de crédito, análisis del mercado, administración de la

producción, etc.) también se ha visto influenciada recientemente por la Lógica Difusa. Por

ejemplo, el "Yamaichi Fuzzy Fund", todavía en su etapa de pruebas recomendó "vender" 18

días antes del Lunes Negro de 1987.

Como podemos observar en la lista de aplicaciones, la mayor parte de ellas corresponden al área

de control difuso donde el conocimiento simple de una persona se transmite a una computadora y

así se mejora el desempeño de las máquinas, algunas veces de manera notable.

20

t,9f35


3.5 Herramientas de desarrollo

En los últimos años han surgido un gran número de programas de ayuda para la creación de

sistemas difusos, así como microprocesadores y tarjetas de desarrollo difusas. A continuación se

mencionan algunos de estos productos.

La compañía Neuralogix desarrolló el microcontrolador NLX230 que es un dispositivo VLSI de

Lógica Difusa con una capacidad para evaluar hasta 30 millones de reglas por segundo. Este

dispositivo almacena las funciones de membresía y las reglas en su memoria interna y realiza los

cálculos directamente en hardware.

El coprocesador difuso VY86C570 desarrollado por Togai Infralogic es una tarjeta para

computadoras PC ó compatibles que permite que una base de reglas previamente desarrollada sea

cargada desde la computadora. Para desarrollar esta base de reglas, Togai Infralogic ofrece una

herramienta de desarrollo basada en Windows, TILShell, que permite diseñar, depurar y probar un

sistema difuso antes de generar el código que será enviado a la tarjeta.

Últimamente se ha popularizado el uso de un ambiente de desarrollo de sistemas difusos basado en

Windows llamado FJDE (Fuzzy Inference Development Enviroment) para computadoras 386/486

y hecho por Aptronix; este ambiente de desarrollo cuenta con herramientas de depuración, análisis

y simulación que genera código en C o ensamblador para los microcontroladores 68HCOS y

68HC 11 de Motorola.

El área de control di:fuso está considerado por LIFE en la primera etapa del desarrollo que se tiene

contemplado para la Lógica Difusa. Las cuatro etapas de desarrollo se muestran en la figura 3-7

[LIFE, 1992].

El progreso en la tecnología difusa está dirigido a incrementar la afinidad entre las computadoras y

las personas.

Una lista parcial de herramientas de desarrollo e información sobre Lógica Difusa que pueden

obtenerse a través de Internet se encuentra en: http://iberchip.cem.itesm.mx/fuzzy.html

21

•


•

r-iitapa

Cmmm.icación hombre - máquina

Uso de lógica difusa cano wt intermediario para el intercambio do información entre la gente y la computadora medim1te lerw,ajc natural

Robot inteligente Sistema interactivo do toma do decisiones

Fig 3-7 Futuro de la tecnología difusa

22

•

Cauta Etapa

Inteligencia Artificial corn¡:ren.sible

Uso de lógica difusa como la tecnología base l>lr& los sistemas de infonnación conjuntando IA, redes neuronales y personas

SUffllrio de oraciones Traducción do lenguajes Soporte creativo

Capítulo 4

4. Algoritmos Genéticos

Los Algoritmos Genéticos han surgido en los últimos años como métodos prácticos y robustos en

los procesos de optimización y búsqueda. En este capítulo se presentan los conceptos básicos de

su funcionamiento y referencias de su uso en el diseño y ajuste de controladores.

4.1 ¿ Qué son los Algoritmos Genéticos ?

Los Algoritmos Genéticos, desarrollados en la Universidad de Michigan por John Holland, se

basan 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 adapiarse más fácilmente a los

cambios que se producen en su entorno.

Los Algoritmos Genéticos trabajan sobre una población de individuos que representan soluciones

potenciales al problema que se desea resolver; operan en base a una representación codificada de

las soluciones, equivalente al material genético de los individuos en la naturaleza, y no

directamente sobre ellas.

Los Algoritmos Genéticos aplican operadores de cambio sobre la población e incorporan el uso

de la selección para determinar cuáles individuos deben mantenerse en futuras generaciones y

cuáles se eliminan de la población. Los operadores utilizados son el cruzamiento y la mutación

que tienen una semejanza muy grande con los de la genética natural. Estos operadores se aplican

sobre estructuras, d,enominadas cromosomas, que son representadas por lo general mediante

cadenas de bits que ,contienen la información codificada sobre las variables del problema que se

desea resolver.


El uso de los Algoritmos Genéticos se ha vuelto atractivo en los últimos años debido a que:

• Son robustos, ya que se pueden aplicar a una gran variedad de problemas

• Son eficaces y e:ficientes, ya que encuentran óptimas soluciones al problema que se les

presenta y lo hacen en un tiempo razonable.

En términos generaks, un problema se define por un espacio de búsqueda y por las características

que deben cumplir ciertos valores dentro de este espacio para ser considerados soluciones. La

mayoría de las veces no basta con cualquier solución, sino que se debe encontrar la mejor solución

posible dado un cierto criterio, esto es, se debe optimizar una función objetivo.

Los métodos clásicos de optimización, el cálculo diferencial y la programación lineal por ejemplo,

permiten obtener óptimas soluciones a los problemas que se les presentan. Sin embargo, basan su

estrategia en ciertas características de los problemas y su aplicabilidad se restringe severamente

ante problemas donde no se cumplen estas características. En cambio, los Algoritmos Genéticos

requieren poca información sobre el problema específico y prácticamente no hacen suposiciones

sobre las propiedades de la función objetivo ni del espacio de búsqueda. Por esta razón, pueden

ser aplicados en dominios muy variados donde la función objetivo puede ser muy compleja, tener

muchas variables o mido, ser multimodal o donde el espacio de búsqueda sea inmenso.

4.2 Elemen1tos de un Algoritmo Genético

Los Algoritmos Genéticos tienen una mecánica sorprendentemente simple [Goldberg, 1994], ya

que no envuelve nada más complejo que copiar e intercambiar cadenas. Los elementos de un

Algoritmo Genéticos los podemos dividir en:

• Selección

• Cruzamiento

• Mutación

Para comprender m~jor la interacción de estos elementos, el ciclo de un Algoritmo Genético se

presenta en la figura 4-1. Después de generar la población inicial se evalúa cada uno de los

elementos o cromosomas de ella, mientras no se cumplan los criterios de terminación del

problema a resolver se seleccionan a los elementos más aptos, se les aplican los operadores de

cruzamiento y mutación para así generar una nueva población.

24

Algoritmos Genéticos

! i Población vieja !

Evaluació n H .,._.----/SI~r e ecc10n ·

:

--- Población nueva --a

-- -(' Mutación----,

Fig 4-1 Ciclo del Algoritmo Genético

A continuación se explicará más en detalle cada uno de las etapas del funcionamiento de un

Algoritmo Genético.

4.2.1 Selección

El proceso de selección significa la supervivencia del más fuerte dentro de la población del

Algoritmo Genético, existen varias formas de alcanzar una selección efectiva, pero la noción clave

es darle preferencia a los mejores.

A cada miembro de la población se asocia un valor de desempeño o aptitud que refleja que tan

buena es la solución, mientras mejor sea el elemento, su probabilidad de contribuir con elementos

dentro de la siguiente generación aumenta. Quizá la manera más fácil de realizar la selección es

con el método de la ruleta [Coello, 1995]. En este método cada elemento de la población tiene

asociada una porción de una ruleta proporcional a su aptitud, para seleccionar a los mejores

elementos simplemente hacemos "girar" la ruleta. Debido a que los elementos más aptos tienen un

área más grande de la ruleta, es de esperarse que sean seleccionados más veces que los menos

aptos.

Por ejemplo, podemos tener la tabla 4-1, cada elemento tiene asociado un valor de aptitud y éste a

su vez representa un porcentaje del área en la ruleta. Una representación gráfica de la ruleta la

podemos observar en la figura 4-2.

25

•


Tabla 4-1 Ejemplo de la selección por ruleta

Elemento Aptitud : o/o del total

254 24.5

2 47 4.5 ·····················································································-j--·········································1

3 457 , 44.1 ...................................................................................... ;. ........................................... ¡

4 194 j 18. 7 ! 1 :

l--··············=--···+---;·······-·-··-1 ·-··-···---~-·2

-

l ................ !.~-~-~l········· ..... .L .............. ~.?.??. ............... 1 .................. 1.?.?. ................ .

Fig 4-2 Ruleta que representa los valores de aptitud

4.2.2 Cruzamiento

~ 0.245

0.045

0.441

lffll 0.187

nm o.os2

Una vez que se selecc.iona a dos de los miembros más aptos de la población, la recombinación del

material genético en la naturaleza es simulada en los Algoritmos Genéticos a través de un

mecanismo de cruzamiento que intercambia porciones entre las cadenas.

26


El proceso de cruza.miento es el siguiente. Teniendo a dos elementos resultantes del proceso de

selección ( denominados padres) se escoge un sitio de cruce a lo largo de las cadenas y los valores

son intercambiados ,entre ellas después del sitio de cruce para dar lugar a dos nuevos elementos

llamados hijos. Un ~jemplo de cruzamiento se puede observar en la figura 4-3.

A este operador se le! asocia una probabilidad llamada probabilidad de cruzamiento que indica con

qué frecuencia se efectuará este cruce de información, esto significa que no todos los padres se

cruzarán, sino que habrá ocasiones en que pasarán intactos a la siguiente generación.

De esta forma se van generando los elementos de la nueva población.

4.2.3 Mutaci,~n

1010110010101 11100100010

1111~11~11~11 1111111~1:1::: ::::::1111111~111111111111

¡10101100~ , 10111001000101

illllll lí ill~11!i"iiÁ l_:¡_¡u_::_::_::_11_::_::_p_;:_::_:1_:=.::_p.a_:i_::_::_,:_::_::_,~_:¡_¡o_::.::.::.~.::.:o_:_::_::.11.~.:I_P._:1.:::11

1::¡¡

.;.;,;.;.;,;.;,;,;:;:;::··.·.·.·.·.·:·:·:·:·:·:·:·:·:·:·:·:·:·:·:·:·:·:·:·:·:·.

j 1o1o11001 o 1 o 1 1:1:1:~,l~ll l~lllll~il lilll:1 llli~lllil:11111~11li;~I O 11100100010 1

Fig 4-3 Cruzamiento

La última etapa dentro del Algoritmo Genético se denomina mutación, este operador causa

alteraciones esporádicas y aleatorias de los bits dentro de las cadenas.

Actúa como una póliza de seguro contra la perdida de diversidad dentro de la población,

introduciendo nuevo "material cromosómico" tal como sucede con sus equivalentes biológicos.

Cuando se trabaja con cadenas de bits, al efectuarse la mutación (la cual tiene a su vez una

probabilidad de que ocurra llamada probabilidad de mutación) el bit señalado se sustituye por su

complemento

27


Después de que aplicamos éstos tres operadores a la población entera tenemos ahora una nueva

población que nuevamente debe ser evaluada; el ciclo termina cuando un criterio de finalización

es alcanzado, este criterio puede ser un número fijo de generaciones, después que una cadena

alcanza un cierto grado de desempeño o cuando todas las cadenas han alcanzado un cierto grado

de homogeneidad.

4.3 Esquemas

En la descripción anterior del funcionamiento de un AG se ha ignorado una cuestión fundamental:

¿qué información está contenida en la población de cadenas y en los valores de la función de

evaluación que guía la búsqueda hacia una solución óptima?

Supongamos que los datos en la tabla 4-2 son parte de un AG:

Tabla 4-2 Valor de aptitud de un conjunto de ,cadenas

I caden;1 valor de la runtion de fVijhiaciÓn

O 1101 169 =··············· ...................•. i"o"o"ó"""""""""""""""""""""""""""""""" .................................... 576····································: -.---~---------- ----------------------------------------~

01000 64 1·································1·aa"i·1································· ···································j·¿i····································,

-----·-------- ----~-----------------------------------------------'

Si se observa con cuidado se pueden encontrar ciertas similitudes entre las cadenas y si estas

similitudes se explorai11 con mayor profundidad se pueden observar ciertas correlaciones entre las

cadenas y los valores de la función de evaluación. En la tabla anterior es dificil entender la relación

entre las cadenas y sus valores si no se toma en cuenta la similitud entre las mejores cadenas (las

que tienen mejores valores de evaluación). Por ejemplo, en esta muestra las cadenas que empiezan

con 1 tienen valores más altos que las que empiezan con O. La similitud entre cadenas con valores

altos puede servir para guiar una búsqueda. Para formalizar la noción de similitud se usa el

concepto de esquema. Un esquema es una plantilla que describe un conjunto de cadenas con

similitudes en ciertas posiciones [Goldberg, 1989].

28


Para construir esquemas sobre el alfabeto binario { O, 1 } , se agrega el símbolo * para decir que una

posición no está especificada. Así, una cadena binaria pertenece al conjunto C denotado por el

esquema H si en las posiciones donde aparece O en el esquema aparece O en la cadena y donde hay

un 1 en el esquema hay un 1 en la. cadena; no importa qué símbolo está en la cadena si en el

esquema hay un *. Por ejemplo, el esquema H = * * 1 O 1 representa al conjunto de 4 cadenas C =

{00101, 01101, 10101, 11101} y el esquema H = 10011 * representa dos cadenas C = {10110,

10111}.

En los ejemplos anteriores se utilizó una longitud de cadena L = 5. El número total de esquemas

posibles es de 35 = 243 porque en cada posición del esquema puede haber un 1, un O o un *. El

número de esquemas. posibles para cadenas binarias de longitud L es de 3L_ Por otra parte, dado

que una cadena de longitud L representa a zL esquemas ( cada posición de la cadena se puede

sustituir o no por un símbolo *), en una población de n individuos existen entre zL y n·zL

esquemas dependiendo de la diversidad de la población.

No todos los esquemas son iguales, algunos son más específicos que otros. Por ejemplo, el

esquema 011 *O** define mayores similitudes entre cadenas que el esquema 1 ******. Hay

esquemas que se extienden más sobre la longitud de la cadena que otros. Por ejemplo, el esquema

1 *****O se extiende sobre una porción mayor de la cadena que el esquema *** 1 *O*. Para

cuantificar estos conceptos, se introducen dos propiedades de los esquemas: el orden y la longitud

de definición.

El orden de un esquema H, denotado por o(H), es el número de posiciones fijas en el esquema.

Considerando los ejemplos anteriores, el orden del esquema 011 *O** es 4 (simbólicamente,

o(Ol l *0**)=4) y el orden del esquema 1 ****** es l. La longitud de definición de un esquema H,

denotada por o(H), es la distancia entre la primera y la última posiciones fijas en el esquema. Por

ejemplo, la longitud de definición del esquema 1 *****O es 6 y la del esquema*** 1 *O* es 2.

4.3.1 Teorema de Esquemas

Para comprender como los esquemas guían la búsqueda de un AG hay que entender el efecto de la

selección y de los operadores genéticos sobre la tasa de crecimiento de los representantes de un

esquema.

29


4.3.1.1 Selección

Consideremos primffo el efecto de la selección. Supongamos que en el tiempo t existen m

representantes de un esquema particular H en la población, lo que se representa como m=m(H,t).

Durante la selección, utilizando el método de la ruleta, una cadena es copiada con una

probabilidad proporc:ional a su aptitud. Más precisamente, la probabilidad de que una cadena Ai

sea seleccionada parn ser progenitora de la nueva población es

donde fi es el valor d,e la función de evaluación para la cadena Ai y n es el tamaño de la población.

Sumando las probabilidades de cada elemento se obtiene que la probabilidad de que un

representante del esquema H sea seleccionado es

m(H,t)·f(H,t)

L~=1f1

donde f(H,t) es el promedio de las evaluaciones de las cadenas que representan al esquema H en el

tiempo t. Si seleccionamos con reemplazo n cadenas de la población para generar la siguiente

generación, el número esperado m(H, t+ 1) de representantes del esquema H en el tiempo t+ 1 está

dado por la ecuación

m(H,t + 1) = n·m(H,t)· f(lj,t)

L1=1·1¡

Si tomamos en cuenta que el promedio de aptitud de la población se puede representar como

entonces se tiene que la tasa de crecimiento de los esquemas en la selección está dada por

m(H,t + 1) = m(H,t) f(H,t) f

30


Un esquema particular crece según la razón entre el promedio de aptitud del esquema y el

promedio de aptitud de la población. En otras palabras, los esquemas que tengan un promedio de

aptitud superior al de la población recibirán un número creciente de muestras en la siguiente

generación, mientras que los esquemas con promedios de aptitud inferiores al promedio recibirán

un número decreciente de muestras. Hay que resaltar que este comportamiento ocurre en paralelo

para todos los esquemas H representados en la población. A esto se le da el nombre de paralelismo

implícito y es una de las cualidades que hacen de los AGs excelentes métodos de búsqueda.

Hay que observar que la selección por sí sola no hace nada para explorar nuevas regiones en el

espacio de búsqueda ya que no se encuentran nuevos puntos. Si sólo se copian las estructuras sin

hacerles ningún cambio es imposible encontrar soluciones novedosas. Para introducir cambios en

la población se introducen los operadores de cruzamiento y de mutación.

4.3.1.2 Cruza1miento

El cruzamiento es un cambio de información estructurado, pero aleatorio, entre cadenas. Un

esquema sobrevive eX cruzamiento simple si:

1. Este ocurre fuera de su longitud de definición.

2. Por casualidad el cruzamiento se realiza con un individuo que aporta la otra parte del esquema.

Formalmente, considerando que cualquier punto de la cadena tiene la misma probabilidad de ser el

punto de cruzamiento, un esquema H en una cadena de longitud L es destruido en un cruzamiento

con probabilidad

8(H) P <-

d - L-I

por lo tanto, la probabilidad de que un esquema sobreviva un cruzamiento es Ps = 1 - Pd . Si el

cruzamiento se realiza con probabilidad Pe, entonces la probabilidad de supervivencia de un

esquemaH es

El efecto combinado de selección y cruzamiento se obtiene multiplicando el número esperado de

representantes del esquema en la selección por su probabilidad de supervivencia en el cruzamiento

31


m(H, t + 1) ¿: m(H, t)· f(~, t)[l - p · & (H)] f e L-1

Podemos observar que los representantes del esquema H crecen o decrecen por dos factores:

1. La relación del promedio de las evaluaciones de los representantes del esquema con el

promedio de las evaluaciones de la población.

2. La longitud de definición del esquema. Los esquemas con promedio superior al de la población

y con longitudes ele definición cortas serán muestreados a tasas crecientes. A estos esquemas se

les conoce como bloques constructivos.

4.3.1.3 Mutación

La mutación es la a.Iteración aleatoria de una posición con una probabilidad pm. Para que un

esquema H sobreviva a la mutación se necesita que sus o(H) posiciones fijas sobrevivan. Tomando

en cuenta que las mutaciones son estadísticamente independientes, multiplicando la probabilidad

de supervivencia ( 1 - Pm) por sí misma o(H) veces se obtiene que la probabilidad de que un

esquema sobreviva la mutación es (1 - Pm)o(H). Para valores pequeños de Pm, la probabilidad de

supervivencia de un 1:!squema se puede aproximar por la expresión 1-o(H)·pm .

Así, el efecto combinado de selección, cruzamiento y mutación sobre el número esperado de

representantes de un esquema H es :

f(H, t)[ 8 (H) ] m(H,t+l)¿:m(H,t)· _ 1-pc·---o(H)·Pm f L-1

A este resultado se 1,:! conoce como el Teorema de Esquemas o como el Teorema Fundamental de

los Algoritmos Genéticos.

32


4.4 Uso de ]los AG para ajuste de controladores

En estos últimos dos años ha existido un incremento en el número de publicaciones en revistas y

congresos internacionales acerca del uso de Algoritmos Genéticos para el diseño y ajuste de

controladores difusos, esto sin tener en cuenta uno de los congresos más importantes en el área

como es el "Third IEEE International Conference on Fuzzy Systems" realizado en julio del año

pasado que contó con una área dedicada a la integración de la Lógica Difusa y la Computación

Evolutiva.

A estas publicaciones las podemos dividir en dos áreas principales:

• Publicaciones que se concentran en la creación de las reglas de control difuso [Mohammadian

and Stonier,. 1994], [Herrera et al, 1994], [Herrera et al, 1993], [Leitch and Probert, 1994],

[Probert and Leitch, 1994]. Estos trabajos están muy relacionados con el área de identificación

o modelado difuso.

• Trabajos concernientes al ajuste de las reglas o funciones de membresía de los controladores

[Lozano and Herrera. and Verdegay, 1993 ], [Karr and Gentry, 1993 ], [ Stonier and

Mohammadian, 1994]. Estas publicaciones presentan aplicaciones similares al trabajo

desarrollado en esta tesis.

Podemos esperar que en un futuro cercano aumente todavía más la interacción no sólo entre

estas dos áreas, sino también con las redes neuronales, dado que existe un gran interés por la

realización de sistemas inteligentes que puedan explotar la tolerancia por la imprecisión e

incertidumbre, que aprendan de la experiencia y se adapten a cambios en las condiciones de

operación [Zadeh, 1994].

33

Capítulo 5

5. Diseño del Controlador Difuso y del Algoritmo Genético

En este capítulo se describe el problema que trataremos de ahora en adelante, el sistema del

péndulo invertido, además se explica el diseño del Controlador Difuso creado específicamente

para esta aplicación, así como las características principales del Algoritmo Genético que

optimizará las funciones de membresía del Controlador Difuso.

5.1 Sistema del Péndulo Invertido

Un problema típico usado para probar controladores inteligentes es el del péndulo invertido [Jervis

and Fallside, 1992], es atractivo porque es simple de simular pero aún así su solución no es trivial.

Podemos encontrar su uso como problema de control desde principios de los años 60's cuando

Widrow utilizó una red neuronal (ADALINE) para controlarlo. En el área de control difuso

también ha sido usado este problema, como lo demuestra el trabajo de Yamakawa [Yamakawa,

1989] [Yamakawa, 1993] donde además de usar un controlador difuso en hardware para controlar

el péndulo invertido, en la parte superior del péndulo colocó un vaso de vino y un ratón.

Un diagrama del sistema del péndulo invertido se muestra en la figura 5-1. El objetivo de control

es balancear el péndulo aplicando la fuerza necesaria al carro teniendo como información acerca

del sistema la velocidad angular del péndulo y el ángulo de éste con respecto a la vertical.

Diseño del Controlador Difuso y del Algoritmo Genético

6

Fig 5-1 Sistema del péndulo invertido

Sea x1 (t) = B(t) (ángulo del péndulo con respecto al eje y)

. x2 (t) = B(t) ( velocidad angular del péndulo)

El sistema de ecuaciones diferenciales que representan este sistema [Jang, 1992] es:

-F- m*x;*sin(x 1)

g* sin( x 1) + co~ x 1 )* -------me+ m ( ) ---------,(-----,-) _____ = H 2 x1 , x2 , F

m*COS2 X1

l•

donde

• g aceleración debida a la gravedad

• me masa del carro

• m masa del péndulo

• l mitad de la longitud del péndulo

• F fuerza aplicada al carro

35

I


Usando el método de Euler para aproximar estas ecuaciones tenemos:

X 1 (t + 0.5h) = 0.5hx2 (t) + X 1 (t)

x2(t + 0.5h) = 0.5hH2(x1 (t), xz{t), F) + x2 (t)

X1 (t + h) = 0.5hx2 (t + 0.5h) + X1 (t + 0.5h)

x2(t + h) = 0.5hH2(x1 (t + 0.5h),xi(t + 0.5h), F) + x)t + 0.5h)

donde h se denomina incremento o tamaño de paso.

5.2 Diseño del Controlador Difuso

Cuando diseñamos un Controlador Difuso tenemos que poner atención en las variables que

intervienen en el proceso a controlar, en las funciones de membresía de cada una de las variables

anteriormente definidas y en las reglas del controlador que expresan la relación entre las variables.

5.2.1 Identificación de las variables

El diseño del Controlador Difuso comienza con la identificación de las variables que intervienen en

el problema, en este caso tenemos:

• Entradas

* Velocidad angular del péndulo x 1(t)

* Posición angular del péndulo x2(t)

• Salidas

* Fuerza aplicada al carro F(t)

El diagrama del controlador se muestra en la figura 5-2.

~:~~ ==>{ Controlador ]1---F-(tJ__....,._ ( Péndulo J =>x:ii:~ Fig 5-2 Controlador del péndulo invertido

36


5.2.2 Definición de los conjuntos difusos

Teniendo ya seleccionadas las variables que intetvienen en el proceso, el siguiente paso es la

definición de los conjuntos difusos para cada una de las variables.

El dominio físico de cada variable es :

• 11\'lio"iYn = [-1.5707 rad, 1.5707 rad].

•

• 'iuM)a-=[-25 N, 25N] . 11

Para esta aplicación se definieron 5 conjuntos difusos en cada variable, los cuales están definidos

en la tabla 5-1.

Tabla 5-1 Valores que definen a las funciones de membresía

' 1 •

¡ positivo_medio (PM) 0.58 1.04 1.57 1.57

positivo_ chico (PC) 0.12 0.58 0.58 1.04

cero (CE) -0.34 . O O 0.35

[···~~-~~~~~-~~~;¡~:~~- - ··········;;~;·········· ········· ·~·~·:·~·~·· ········1········ ··~·~:-~;·········· ······· ·-~~---~·;····· ·· r·······~;:;~······· ·, i negativo_medio (NM) -1.57 i -1.57 -1.11 1" -0.65 ' : : :

.. -~ ·.·· • · ... ~ ·~ -·~ ·- .. ~ = , . ··= r .. . . ··. : ··. -~ .:·.· ... ;···. ~-·:=.. ==·==:

. , Abrevmemnli Lumte r Pnm l · ·¡ l§co:2 .,,. ¡· Lüfüre ..... .

·. ·. f, : , · . : . ¡ littetht.tt i · · '·::.:..., .:··· .... : ... .J: ···:'· :-:_: ,:.,,.,, / :-,,,.:___· .. :, .. SulW)tj9,Ji.;::?

positivo_medio (PM) 1.10 1.98 3 3

positivo_chico (PC) 0.22 1.10 1.10 1.98

cero (CE) -0.65 o o 0.66

!:::;;::~::: :: :2::~ ' :l:;2 :;:: + ::;::

37


·e.. ': Ab~~Wad.'n \ .Límü~ · ! · PiN(1 ·. h . ·p¡e.~ 2 · .. . 1 . Íl~»;t<,::-:.:. ), ·. · _ ' ! , Inferior ~ . . "1° . . · : . ·. ¡ · · S.u~rló:r "\:;.

: ::- . ;'. ·.. ·: . .. : ..

positivo_medio (PM) 9.21 16.54 25 25 .... ....... ... ·····-·· ······· ·· ······ ··· ·················· ····· ····· ·················:"·········· ·········· ···········

positivo_chico (PC) 1.88 9.21 9.21 16.54

cero (CE) -5.45 o o 5.50

negativo_ chico (NC) -17.67 -10.34 -10.34 -0.54 ..................... ................. ;. ...

negativo_ medio (NM) -25 -25 -17.67 -10.34 ....................... .............................. , .................................... .

Las funciones de membresía iniciales para cualquiera de las variables se muestran en la figura 5-3,

éstas han sido definidas usando el editor difuso. La mayoria de las funciones de membresía usadas

son de fonna t1iangular, que pueden ser vistas como un caso particular de las funciones de fonna

trapezoidal en donde los dos puntos en el dominio de la función de membresía que tienen grado de

membresía igual a uno son iguales.

::,:,:::,;-:,:,:::,:::,:::::::::,:·:-:::::,:-;,;,::·.·.·:·:·:·.·.··:-:-;-;-;,;:;:·.·,·.·:·.··:·::,:-:-:,:-:-;-;,;,;-:,;-:::,:·:·:·:::::,:·:·:·:·:·:·:·:-;-:,;,;-:-;,;-;::::::::::::::-::;:;:;:;:;:;,;:;.;:;:::::::::::::::;:;.;,;,::::;:1::::-::;:;:::::;:::::::;:;:;:;:::::;:::::;:;.;-::::::::;.;::::-:,;,::::;:;,;,;::::::;.

Nega 'vo Med Negativo 'Chico Cero Positivo Chico , Positivo Med \

l\ ¡'\\ / \

-------,

.. / ... \/

./\ / \.

\ ¡' \ .!. \. ! \ /

,, I \ i /

.,/ \... / '\,_' ..._/ ~ / / \ ./\ }( il .\

/ / \ /

! ¡ ! i

i i

1 ! 1 ! \ / \

.:,;,:-;.;.;.;'.;.;.;.;,:,:,:,••,:,:,:,:,:-:-:··-:-:-;-:-:::.;,:-:-:-:-:-:·:·:·:·:·:·:···:-:-:-:-:-:·:·:-:.:,·,•.·.·.·.·.·.·.·. ,•,•,•,•,•,·.·,•,•,•,•,·.•,·, ·:·:·:·:·'·:·:·:·:·:· / \

.,.,.,.,.,.,.,.,.,.!:.:.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,

Fig 5-3 Funciones de membresía del Controlador Difuso

5.2.3 Definicibn de las reglas de control

Teniendo las variables y los conjuntos difusos definidos, el último paso es generar las reglas de

control difuso basadas en ellos, algunos ejemplos de estas reglas son:

si la posición es NM y la velocidad an}{ular es NM entonces Jafúer:a es NM

si la posicirí11 es NC y la l'e.'ocic/ac/ angular es PC entonces la /úer::;a es CE

si la posicirín es CE y la velocidad angular es CE entonces lafúer::;a es CE

si la posicirín es PC y la velocidad angular es NM entonces la/úer:a es NC

si la posición es PM y la velocidad angular es CE entonces la.fúer:a es PM

38


De esta forma definimos 25 reglas difusas que controlan al sistema del péndulo invertido. Las

reglas pueden se:r también representadas por medio de una matriz como lo observamos en la figura

5-4, la primera columna representa los conjuntos difusos de la posición del péndulo y la primera

fila los de la velocidad angular del péndulo.

Velocidad angular

NM NC CE PC PM NM NM NM NM NC CE Fuer za

Posición NC NM NC NC CE ~ CE NM NC CE PC

PC NC CE PC PC PM PM CE PC PM PM PM

.....

IFig 5-4 Reglas del Controlador Difuso

Adentro de la matriz tenemos las funciones de membresía de la fuerza aplicada al carro, así, en

una forma sencilla podemos revisar las reglas de control difuso ya que en este caso la fuerza está

dada por:

fuerza= matriz [posición] [velocidad]

Por ejemplo

CE = matriz [NC] [PC]

Esto se interpreta de la siguiente manera:

si la posición es NC y la velocidad es PC entonces /a fuerza es CE

5.3 Caraclterísticas del Algoritmo Genético

Existe una gran variedad de simuladores o librerías de Algoritmos Genéticos disponibles en

lenguaje C, Pascal, Fortran y Lisp disponibles. Entre éstos podemos destacar el desarrollado en

Pascal por David Goldberg [Goldberg, 1989] SGA (Simple Genetic Algorithm) y que ha sido

convertido recientemente a lenguaje C y Fortran, el desarrollado en LISP por John R. Koza

[Koza, 1992] y GENESIS 5.0 desarrollado por John Grefenstette del "Naval Research

Laboratory" [ Grefonstette, 1990].

39


En este trabajo se utilizó un Algoritmo Genético propio desarrollado en lenguaje C y que se

adapta por completo a los algoritmos de control difuso que se han desarrollado durante los

últimos años en el ITESM-CEM. Esta decisión se tomó en razón de que estos algoritmos

funcionarán en un futuro cercano en sistemas dedicados que no poseen una memoria muy grande y

los simuladores antes descritos tienen características que no son necesarias, tales como reportes,

estadísticas, etc, y sólo se requiere un Algoritmo Genético básico.

Cuando aplicamos Algoritmos Genéticos para optimizar cualquier problema se deben tomar dos

decisiones fundamentales:

• La forma de generar y codificar las posibles soluciones.

• Cómo se va a evaluar el desempeño de cada una de las soluciones.

5.3.1 Generación de los individuos

Las funciones de membresía pueden ser representadas en forma trapezoidal como lo vimos en el

sección 2.2.2, por lo tanto, tenemos cuatro puntos que las definen, en este caso cada función de

membresía se denota de la siguiente forma:

( a 1, a 2

, a 3, a 4

) Para las funciones de membresía de las variables antecedentes

( c1, c 2

, c 3, c 4

) Para las funciones de membresía de las variables consecuentes

Cada punto es codificado en 1 O bits, por lo que se tiene un rango de 1024 unidades

Teniendo la notadón anterior, cada individuo o cromosoma (E) en la población lo podemos

representar como:

donde

i=número de funciones de membresía antecedentes

)=número de funciones de membresía consecuentes

Para generar la población inicial se utiliza como primer individuo el definido en la sección 5 .2.2.

Para generar el resto de los individuos se toma como base este primer individuo y se hace variar

dentro de un rango (±50 unidades) en forma aleatoria ya que se considera que la solución original

es una buena aprmómación.

40


5.3.2 Evaluación de las soluciones

Cada individuo ele la población se evalúa de acuerdo a su desempeño en el problema del sistema

del péndulo inve11ido durante un tiempo t determinado.

Como el objetivo de control es balancear el péndulo en el menor tiempo posible, la función de

evaluación que sie quiere minimizar es la sumatoria del valor de la posición del péndulo muestreada

cada cierto tiempo h (definida en la aproximación de Euler).

Cada individuo se evalúa utilizando cuatro diferentes inicializaciones aleatorias dentro del rango

de ±30 grados 1!n posición y ±2 rad/seg para la velocidad angular. Por lo tanto, el valor de

desempeño o aptitud de cada individuo está dada por:

4 n 2

aptitud= ¿¿x;(J) i=I J=O

donde

tiempo de simulación n =----"-------

h

41

Capítulo 6

6. Resultados de la simulación

En este capítulo se presentan los resultados del Controlador Difuso aplicado al sistema del

péndulo invertido utilizando la aproximación de Euler de las ecuaciones diferenciales que definen

al sistema. En primer lugar se muestran los resultados obtenidos con el controlador original, y a

continuación se muestran los del Controlador Difuso optimizado por el Algoritmo Genético.

6.1. Controlador original

El péndulo invertido fue probado con 4 diferentes inicializaciones en la velocidad angular y el

ángulo del péndulo, los cuales se muestran en la tabla 6-1.

Tabla 6-1 Valores de prueba del péndulo invertido

; lni:dalizaí'ióu Áugulo del ~ndulo ; Velocidad Angular

· Número (gr¡idos) (radinnesfsegundo)

¡--------------------------------------------------+---------------------------------¡--------------------------------------------------: • 1 : :

¡ 2 i 25 1 1.5 : >·····-- ·· ·······---·······-······-························f···························--····························.t .................................................. ........ i 1 1 1 ¡ f 3 i -25 1.5 f

1 ~ l :;; 1 :1 ; 1 Los parámetros del péndulo invertido durante la simulación se muestran en la tabla 6-2.

Resultados de la simulación

Tabla 6-2 Parámetros del péndulo invetido. , ........................................................................................................ .

Aceleración ( g) 9.8 m/s2

¡--················~~~--~~·¡·~-:~··¡··~·;·················· ·······~--~~·······

Masa del péndulo ( m) 0.1 Kg

Mitad de la longitud del péndulo ( 1) 0.5 m

Tiempo de simulación ( t ) 3 s

Los resultados obtenidos usando el controlador original definido en el capítulo anterior los

podemos apreciar en la figura 6-1, se muestra el ángulo del péndulo durante la simulación con

respecto al tiempo.

En ninguno de los cuatro casos el péndulo cae, pero nunca alcanza la posición vertical.

0,4

0,3

ui 0,2 ., e " O, 1 :a " .,:. o o l -0,1 0,5 1,5 2~ e

es: -0,2 ~

-0,3

-0,4

Tiempo (segundos)

Fig 6-1 Respuesta del controlador inicial

6.2. Controlador optimizado

Para obtener el Controlador Difuso optimizado se utilizó un Algoritmo Genético tal como se

definió en la sección 5.3. Los parámetros del Algoritmo Genético se muestran en la tabla 6-2

Los resultados obtenidos con el Controlador Difuso optimizado por el Algoritmo Genético en los

cuatro casos de prueba se muestra en la figura 6-3.

43


Tabla 6-3 Parámetros del Algoritmo ~nético .................................................................................................................................

Tamaño de la población 61 ................................................................................................................................

Número de generaciones l l

Probabilidad de cruzamiento 0.6

Probabilidad de mutación 0.02

Tiempo (segundos)

Fig 6-2 Respuesta del controlador optimizado

Este controlador ya cumple el objetivo de control, que es mantener al péndulo en posición vertical

en cualquiera de las cuatro diferentes inicializaciones con las que fue probado.

En la figura 6-3 se muestra la manipulación sobre el carro por parte del controlador.

15

"iii 10 e o

5 i Q) e o -ca 2 2,5 3 t::! -5 Q) ::::, LL -1 O

-15

Tiempo (segundos)

Fig 6-3 Fuerza aplicada al carro

44

Resultados de la simulación

En la figura 6-4 se muestran las funciones de membresía del Controlador Difuso optimizado,

correspondientes al individuo con mayor aptitud en la última generación del Algoritmo Genético;

se advierte el cambio en la forma en la mayoría de las funciones de membresía de triangular a

trapezoidal. Los valores de las funciones de membresía de las variables, posición, velocidad y

fuerza se muestran en la tabla 6-4.

Tabla 6-4 Valores de las funciones de membresía del controlador optimizado

negativo_ chico (NC) -1.13 -0.53 0.07

! ... ~~~~'.~~~!~~~'.-~ .. ······---~~-~!. .................... ~.-.5..2. ... .... L ....... º. 81 .......... ..l. .. . 1.13 1.57

· · ,', i ·. ',, · •' ,,,: ~- · · .. · · · .. · ·:: · . ¡ _:· . · '} · ·: :. · : · · · · · · ·.:: : ~- ', ,' .. · · ·: ,::. ·: ·. ·.··::<;.::::·\:: ª:t::·:·:1.:::-::::·:·::·::::·:·· .::···:: · :·'::':·} :.:::: .::·::::,·,¡.:: : .. :::/:(tt: : :, mao ¡ Abreflfdóo ~ · lfüfilt~ _¡ · m~· _r· ·¡·J:_ii/Pko.:z.:· ·. T'·: · .. ::~iñtf§i'.:::-::-:·

. . ·:·· ·.·..... 1. ... . . . . .. l. .. 1~f~r~~,·.. l.· . . . ···< ·: .: .. :r··.: :. ·: .:·: .. :-:- .. : ..... :.· : . ..1 .. :·:~~~,qi.f?: ¡ positivo_medio (PM) 1.36 1.86 2.91 2.93 ~-······· ······························ .............. ·············· ·-~····· ······················ ............... ...... .. ........ ··· f.i ............................... ........... ... .. .. ........ ..... :

j positivo_chico (PC) 0.87 1.11 1.11 2.18

i cern (e~) 1 :;~; :~;; ! :~;¡ ;¡; 1

negativo_ chico (NC) -1 .96 -1.28 -1.28 -0.77

! negativo_medio (NM) -3 -2.99 -2.69 -0.53 · ......................... ............................. ............... : ............................................................. : ............................... .................... .. .. ... ... :

j positivo_medio (PM) -3 .05 14.78 20.50 25

i ;;;,;;~;~~;~ i~l >ii : ,;i; >ii< I ;; '2 •

cero (CE) -8.53 ' 2.52 2.61 j 9.51

negativo_ chico (NC) -19.87 -11.07 -9.46 -4.81

¡ negativo_medio (NM) -23.63 -22.85 -18.45 -2.4 7 ··· ···· ················· ···· ······ ·· ·····

45


Fig 6-4 Funciones de membresía del Controlador Difuso después del AG.

El comportamiento del Algoritmo Genético se muestra en la figura 6-5 . En ésta se muestra la

evolución del desempeño del mejor individuo de cada generación.

Se puede observar que el valor de aptitud decrece rápidamente en las primeras generaciones para

luego estabilizarse, esto quiere decir que el Algoritmo Genético encontró rápidamente un

conjunto de funciones de membr1esía que hacen que el Controlador Difuso mantenga al péndulo en

posición vertical.

0, 18 0, 16 0, 14

- 0, 12 o 0, 1 ... ...

º·ºª L w 0,06 0,04 0,02

o 1 2 3 4 s 6 7 8 9 10 11

Generaciones

Fig 6-5 Valor de aptitud del mejor individuo durante el Algoritmo Genético

Podemos observar de la figura 6--2 que el comp0rtamiento del controlador no es simétrico, esto es,

con inicializaciones positivas n::sponde de forma diferente que si lo inicializamos con valores

negativos, este comportamiento es debido a que las funciones de membresía resultantes tampoco

son simétricas.

46

Rcsultaclos ele la simullación

Para solucionar este problema se restringen las soluciones de forma que las funciones de

membresía positivas de las variables sean un espejo de las funciones de membresía negativas. El

resultado de esta restricción lo podemos observar en la figura 6-6, donde la respuesta es

completamente simétrica.

Las funciones de: membresía las podemos ver en la figura 6-7 y también podemos observar la

simetría en ellas.

0,6

0,4

Ío.2' 1 o y>,-__ -_-_ -==~1~=~-1 ..... 5 ___ .,.2 ____ 29',5 ___ '93

~~ -0.2 r/ ex: --0,4

-0,6

Tiempo (segundos)

Fig 6-6 Respuesta del controlador optimizado simétrico

Fig 6-7 Funciones de membresía del controlador optimizado simétrico

47


Si observamos las figuras 6-2 y 6-6, el controlador con funciones de membresía simétricas

controla mejor al péndulo que el controlador con funciones de membresía no simétricas. Esto

puede ser comprobado en la figura 6-8, en ella podemos observar el comportamiento del

Algoritmo Genético, 5 veces con la restricción de simetría y 5 veces sin ella durante l O

generaciones.

Aptitud

0.6

0.5

0.4

0.3

-~~ -~A --~ ~2? ==----~ :Y No,imOlriu,

~ ~~ ................. Q Stmetncas

0.2

0.1

2 3 4 5 6 7 8 9 10 11 12

Generación

Fig 6-8 Comparación entre controlador simétrico y no simétrico

Se puede ver que los controladores simétricos se comportan siempre mejor que los no simétricos

dado que el error al final de la última generación es menor.

6.3. Modelado difuso

Se entiende por modelado difuso a la creación del modelo de un sistema, que contiene una

descripción basada en el lenguaje natural y Lógica Difusa [Sugeno and Yasukawa, 1993]. En el

sección 4.4 se mencionó que los Algoritmos Genéticos están siendo usados para la generación de

modelos difusos de sistemas. En [Mejía, 1994] se creó un modelo difuso por medio de técnicas de

agrupamiento difuso del controlador original del sistema del péndulo invertido con ayuda de

Algoritmos Genéticos.

48

Resultados de la simul:ación

Para crear el mode:lo se usaron los valores de salida que genera el interpolador difuso [Mejía, 1993

], usando el controlador original en base a posibles combinaciones de valores a la entrada. Los

valores utilizados se muestran en la siguiente matriz, también llamada tabla de búsqueda.

Posibles valores de posición angular

o ~ 1023

o 75 75 o 512

Posibles valores de

V o o o 512

velocidad angular o o o 512 ....

1 .... 1 .... 512

.... 936 1023

Fuerza

El modelo difuso creado a partir de estos datos se compone de 7 reglas solamente, cada variable

de entrada y salida consta de 7 funciones de membresía. El comportamiento del modelo difuso

usado como controlador del sistema del péndulo invertido se muestra en la figura 6-9, el péndulo

no cae en ninguno de los cuatro casos al igual que tampoco cae el controlador original, los valores

de prueba se mue:stran en la tabla 6-5.

Tabla 6-5 Valores de prueba para el controlador por agrupamiento

1

2 50 -10 I ¡·························································· ·························································-¡--················ .. ·············· ..... .. ............ ···! · 3 -50 j 10 ¡ L--·------·-·-··- ··-···-·-····--····-··············-···- -·-··-·····--··----···-·······I ' i

4 -50 -10 1

l .. ·-·-·-·····-------------·--·· --·-···------·--·-··--··--··· -··--····-·····················-··················)

49

•


1

0.8 'a

0.6 1'11 .;. o 0.4 '; ,,

0.2 e '!. o 'ii csi ~ (O ce ~ ,, -0.2 o - - - -'; -0.4 e, e -0.6 et

-0.8

-1

Pasos en la sinulación (O. O 6s)

Fig 6-9 Desempeño del controlador obtenido por agrupamiento

El modelo fue optimizado de la misma forma que el controlador de la sección anterior en base a un

Algoritmo Genético con los mismos parámetros, salvo el tiempo de simulación que fueron 1 O

segundos. El comportamiento del elemento más apto en la última generación del Algoritmo

Genético se muestra en la figura 6-10.

Así, independientemente de quien haya creado el Controlador Difuso original, un experto o en

base a un modelo, el Algoritmo Genético es capaz de optimizar sus funciones de membresía para

mejorar su desempeño.

0.8 ~ ~ 0.6 o 0.4 "5 "g 0.2 ·i o +-P~+--~...,.._~-+-~-+-~-+-~-+-~-t-~-t-~--,...~--1

'ii ,, -0.2 o '; -0.4 e,

~ -0.6 -0.8

-1

Pasos en la simulación (0.05s)

Fig 6-10 Controlador por agrupamiento después de ser optimizado

50

Capítulo 7

7. Ampliación del problema

En los capítulos anteriores se trabajó con el sistema del péndulo invertido sin tomar en cuenta el

desplazamiento del carro sobre la superficie, en este capítulo tomaremos en cuenta este detalle con

la condiciones dadas en [Barto et al, 1983] y que se explican a continuación.

7.1 Péndulo invertido con desplazamiento

La figura 7-1 muestra el sistema del péndulo invertido con desplazamiento, la variable x representa

la distancia del centro del camino de prueba al carro. Esta variable se obtiene mediante el siguiente

par de ecuaciones [Miller et al, 1990].

x(t + 1) = x(t)+h* x(t)

. . F(t) + m * l + ( 8(t)2 * sinB(t)- B(t) * cosB(t)) x(t+1)=x(t)+h*-------------

mc+m


e

centro

Fig 7-1 Sistema del péndulo invertido con desplazamiento

Partiendo de las siguientes condiciones iniciales:

. . B(o) = o(o) = x(o) = x(o) = o

El objetivo de control es que el sistema se mantenga dentro de los siguientes límites:

-12°(8(12°

-2.4m(x(2.4m

El sistema es controlado con las reglas y funciones de membresía definidas en la sección 5.2, lo

único que cambia es la función de aptitud con la cual se evalúan los individuos del Algoritmo

Genético, para este caso se define como:

4 n ( 2 ) aptitud=¿¿ (w * B;(t)) + x;(t)2 i=l t=O

donde

ro = constante de peso

Esta constante de peso se determinó como (fuerza máxima/ posicion angular máxima), para que

ambas variables tengan el mismo peso en la función de optimización.

En la figura 7-2 se muestra el ángulo del péndulo y en la figura 7-3 se muestra el desplazamiento

del carro bajo la. acción del controlador original y del optimizado

52

Ampliación del probkma

Se observa que el controlador original aunque cumple con la condición relativa al valor máximo

del ángulo del péndulo, esto es, siempre es menor a 12 grados, no logra mantener al carro dentro

de los límites pre.:::stablecidos del desplazamiento.

12

8

4

Angulo (grad1>s) o

-4

-8

-12

11.6

11) 9.6 o ... .... GI .§. 7.6

s 5.6 e GI ·e

3.6 ca N ca c. 1.6 11) GI o

-0.4 ......

-2.4

2 3 4 5 6 7 8

Tiempo (segundos)

Fig 7-2 Ángulo del péndulo

--- Controlador original

---- Controlador optimizado

'~ N lO

Tiempo (segundos)

~)

Fig 7-3 Desplazamiento del carro

10

(X) o ......

Controlador

Original

Controlador

optimizado

El controlador optimizado cumple ambas condiciones, mantiene durante el tiempo de simulación al

péndulo con un ángulo menor a 12 grados y dentro de los límites establecidos de desplazamiento.

Observando la figura 7-4 , la cual muestra el valor de aptitud del mejor individuo de cada

generación del Algoritmo Genético, se observa que en la primera generación logramos una mejoría

notable, la cual se mantiene casi constante durante las generaciones subsecuentes

53

"C :::,

1000

7501


·E 500 c. <(

250

o¡ _____ \. o 2 3 4 5

Generación

Fig 7-4 Valor de aptitud durante el Algoritmo Genético

El individuo más apto de la última generación tiene las funciones de rnembresía descritas en tabla

7-1, las podemos observar en forma gráfica en la figura 7-5.

Tabla 7-1 Valores de las funciones de membresía, sistema completo

\ positlvo __ medio ¡ (PM) j 0.65 i 1 07 1

1.55 ' 1.56 ¡

1 ~'.i'.i~o~ch,col ~)···· L 008 • .. 0161 055 : .. T2s • ¡ cero j (CE) 1 -0.42 1 -0.15 ¡ 0.12 \ 0.36 : i····································+·····························i·····························,······ ········f······························i·····························<

i negativo_chico \ (NC) 1 -1.00 1 -0.80 j -0.45 : -0.04 :

¡_¿:ga~;~J--~--G~~=-i~~~-=r~_¡.=:~~T=i {vel~idad) Abreviatión Limite ' P.k:o l .· Pico l . 1 Límite .

Nonhü:e ; 1r1re,,lo~ ' ; ! Sumtriot.• ' { ~

: pos1t1vo_med10 1 (PM) [ 4.45 , 6.68 J 9.12 , 9.37 : : ··········-··········-·······--·J·-······- -···-·····-·········-········-----······ :--······················-·· -!·-················-·········-: ······························ '

: positivo_chico 1 (PC) ; 0.50 : 1.09 i 4.00 ! 6.44 ! ~ .................. ··················-~---···························· .............................. \ .............................. { ....... ··-------···------···-~---······· .

: cero 1 (CE) -3.94 : -0.67 j -0.15 : 1.53

r··-~-~;~~-~~~~~;~~-T·······-~~-~;········r·····-~~:;~·-········1·········-~~:·~·;··- ·····r·····--~~--·;·~·-········r········-~~:~·;·

¡~~:~m~,{~~~] __ .:;0 º=-i~=:9 ~~=t=·6i~=-r~~~o l

54

Ampliación del problema

~ ~ : ..:: . . . . . . ;- .

. ·: . (fu~ a} ,._. Abrfvht~ión Límtt~ i . Pi~ 1 .· . . ,.Pi~nl . l&mtt~ :·. :· • 1 o .. ..

. No.m re ; . . ' Inferior ~ ·. . . . ·. , .·· · .. Surmrion : · . . ., . . ~ . . . . . . . . . ..

positivo _medio (PM) 9.80 17.08 23.14 24.32 ······························ ······························t······························

positivo __ chico (PC) -0.66 8.38 9.36 23.04

cero (CE) -0.66 0.90 1.30 10.19

-12.24 : -10.0 i

negativo_ chico (NC) -20.89 7.45

negativo __ medio (NM; -23.92 -23.88 ···r· -17.47 -] 0.34

Fig 7-5 Funciones de membresía del Controlador Difuso después del AG.

7.2 Controlador Diifuso de cuatro v21riables

Aunque el controlador anterior logra mantener dentro de los límites preestablecidos al péndulo

invertido, el péndulo no queda en posición vertical ni el carro centrado, para solucionar esto hay

que tomar en cuenta en el diseño del controlador el desplazamiento y velocidad del carro.

De esta forma se diseña un Controlador Difuso; las variables antecedentes (posición, velocidad

angular, desplazamiento y velocidad de desplazamiento) tienen 3 funciones de membresía mientras

que la va1iable consecuente (fuerza) se definió con 5 funciones de membresía. Estas funciones

pueden ser apreciadas en la figura 7-6.

55

•


. . , 0 /'\\ i /\ //\\ ,//····-··--·--; ••

:i ;:\ \.1 V /\ 1

•• : [, / \ I \ C·

': j \ / \ / I \. ::C ;:, •• • .. •.•.•,·.····· ... ·.v·····'························) ... ·.·.·.·.·.·,·-·~·-·.1· ... ·.·.·,;.~.-..·.·.•:-.-.•.•,•,·-".-•. ,.,,, .•. / .... ·.·.·.·.·.·.:.·.·.·.:.~.·.·,·.-.·.·.·,·-·,·-·,·,·,·,·.·,·,:;

Consecuente Antecedentes

Fig 7-6 Funciones de membresía del Controlador Difuso ampliado

Con estas funciones de membresía podemos definir las reglas que controlarán al sistema, la

estrategia es primero llevar al péndulo a una posición vertical y después cuando la posición y

velocidad angular sean cero llevar al carrito al centro del camino.

Velocidad de desplazamiento

Velocidad angular

CH CE GR

CH PM

PC

Posición angular

NM NC NC

Desplazamiento

CE

CE

NC CE PC

·.·.· ... ·,:·:·:·.·:·.·:·.·:·.·:·:·.·.·:·.· .. -.-:-:-:-:·.·:::::::::::;=:=::::=:::=:::}

GR NC

PC PC PM

NM

Si posición es cero

y velocidad es cero

La figura 7-7 muestra la posición del péndulo con el controlador original y el optimizado.

0.6 Original

0.4 -~~ Optimizado CI) CII e

0.2 .!!! ,, l'CI ... o o ,-· N <O O) o ::::, ...... g> -0.2 e(

-0.4

-0.6 l

Tiempo (segundos)

Fig 7-7 Posición angular con condiciones iniciales iguales a cero

56

Ampliación del probfoma

La figura 7-8 muestra el desplazamiento del carro bajo la a.cción de ambos controladores. En

ambas figuras las condiciones iniciales del sistema son iguales a cero.

"' 6 Optimizado

e 4 .. Original ~

E - 2 o .. e .!!! o E

1 2 3 4 5 6 7 8 9 10 ~ -2 N

~

c. "' -4 ~ e

-6 l

Tiempo (segundos)

l~ig 7-8 Desplazamiento del carro con condiciones iniciales iguales a cero

7 .3 Condiciones iniciales diferentes a cero

Otra prueba a la que fue sometido el Controlador Difuso fut~ que el sistema tuviera condiciones

iniciales diferentí:s a cero, estas condiciones fueron:

• Cinco grados en la posición angular del péndulo.

• Un metro de distancia del centro del camino.

Los resultados ele esta prueba se muestran en las figuras 7--9 y 7-1 O, éstas son la posición del

péndulo y desplazamiento del carro respectivamente.

Podemos observar que el controlador original tiene un error muy pequeño y que el controlador

optimizado lleva al péndulo a la vertical; en cuanto al desplazamiento, podemos observar que el

controlador original no mantiene dentro del camino al carro, mientras que el optimizado lo deja en

el centro.

57


0,8 -original

0,6 ---- Optimizado

en 0,4 G.I e .!!'! 0,2 "CI ~ o -o ..... <O O> o 5, -0,2 ..... e < -0,4

-0,6

-0,8

Tiempo (segundos)

Fig 7-9 Posició111 angular con condiciones iniciales diferentes a cero

6

t --original

en 4 --- Optimizado e -G.I

§. 2 o -e .! o E o 111 ..... N 111 -2 Q. en G.I e -4

-6

Tiempo (segundos)

Fig 7-10 Desplazamiento del carro con condiciones iniciales diferentes a cero

En la figura 7-11 se muestran las funciones de membresía resultantes de la optimización.

58

Ampliación del problema

r, sic1on ~.1,-,., ......... .. 1 r·-·.·.•.•,.•.·.·,,.·.·.·.·.·,.·.•.·,.•.·.·.·.·.·.·.-...·.·. ·.·.·.·.·.·.·-r···-·.·.w.w.w.·.·.·.·.·.·.·.·.·.•.·.·.·.·.·.·.·.·.·.·.·.·,.·.w.·.-.-.·.·.w,,, .......... ,,

r-\, · r,,, ,, / /~ :: ! \1 >~ ,: ¡ \ / ',,, :: ' \ // ........... ·: i \· ', '

•••••• .·.:,,:.·........... •t • • ••• ),.· •... •

1023 .OUOVD\.I

fuerza

·.·.·.·.·.·.·.·.·.•,·.-....... ·,•, .·.·.·.·.·.·.·.·.·•·.·.·.·.·.·.·.· .. ·.·.·.·.·.-.·.·····-·.···········-·.·.·.·········-·-·-·.·.·.···················-·.",·.·····-·.·.·······-·.·.·-

!/'\,.// ">c:/1/ "\/> '\\ : : ! / \ // ,, / \ 1

•/ /, / '{ \ 1 .

,.•.•,•.• .. ;,,[, .. ~•.:.: ...... ,.:.\ \> .-. • .l:. .. ,.,, .. :::~ ...... ,\..w.·.· .. •.·,.·.w.·.~M· . .-,u,...-,.· .. :.

U .UIXPlU•J ; IO~J .OOUOOO

Fig 7-11 Controlador Difuso de 4 variables 01>timizado

59

•

Capitulo 8

8. Prueba del Controlador Difuso en un sistema real

Durante el desan-ollo de este trabajo se planteó la necesidad de probar los algoritmos de control

difuso en un sistc!ma real. Esta prueba se realizó como parte del XXII Programa de Intercambio

México-Japón, junto con el Ing. Carlos Pedraza del Instituto Tecnológico de Celaya, con el

péndulo invertido construido por el Departamento de Robótica de la División de Mecanismos en

el Laboratorio d(: Ingeniería Mecánica (MEL) del MITI, en la ciudad científica de Tsukuba, figura

8-1.

Esta prueba consistió en controlar la posición angular del péndulo a través de una computadora

personal.

8.1 Descripción

La figura 8-2 muestra la estructura del péndulo invertido, un servo motor de corriente directa está

unido al cuerpo del péndulo y su torque es transmitido a las ruedas a través de un engrane

reductor, la velocidad angular es detectada por medio de un giróscopo y el ángulo del cupero es

medido por una varilla de contacto unida a un potenciómetro.

Una fotografia del sistema se muestra en la figura 8-3, el sistema es controlado desde una

computadora personal NEC PC-9801.

Prueba del Controlador Difuso en un sistema real

Fig 8-1 Laboratorio de Ingeniería Mecánica

Giróscopo

Cuerpo

Motor

l

Rueda Potenciómetro contacto

• Fig 8-2 Diagrama esquemático del péndulo invertido real

61


Fig 8-3 Fotografía del péndulo real

8.2 Resultados

Cabe hacer notar que el período de estancia en este Laborat01io fue de una semana, al llegar a las

instalaciones del Laboratorio se vió la necesidad de ajustar los programas para que pudieran

funcionar en las. computadoras de manufactura japonesa que difieren de las que nosotros

conocemos en algunos aspectos, el más importante que nos atañe es la diferencia en el compilador

C que es necesario para ejecutar estos programas.

Por esta razón las pruebas con el péndulo real se llevaron a cabo durante dos días, así, la

presentación de resultados del Controlador Difuso está divido en dos, cada uno con los resultados

obtenidos ese día.

Antes de presentar los resultados del Controlador Difuso se presenta el desempeño del

controlador desarr0llado en el Laboratorio de Ingeniería Mecánica [Matsumoto et al. 1993].

8.2.1 Controlador MEL

El controlador d1:!sarrollado en el Laboratorio de Ingeniería Mecánica está basado en el método de

retroalimentación de estados usando variables de estado estimadas.

62

Prueba del Controlador Difuso en un sislema real

Los resultados d1! este controlador los podemos observar en la figura 8-4, se observa que el

péndulo conserva una cierta oscilacion y no esta por completo en la posición vertical, aunque hay

que mencionar que este controlador mantenía al sistema en el centro con respecto al

desplazamiento horizontal.

3,5

3

- 2,5 CII o

I r t I ,J..

[l ,.., r / ! /

r "C 2 l! e,

1,5 -~ :::::, 1 o, e J e:( 0,5

l

o ' \ e

-0,5 1 ~ 1.44 V 2.88 ~ 32 1 5.76 V

Tiempo (segundos)

Fig 8-4 Desempeño del controlador clásico

8.2.2 Controlador Difuso

El Controlador Difuso usado es el mismo que se diseñó en la sección 5.2.

8.2.2.1 Prin11er día.

Los resultado de esta primera prueba se muestran en la figura 8-5

Durante el tiempo en que se llevó a cabo la prueba (10 segundos), el péndulo no cae, pero al igual

que observamos en los resultados de la simulación del capítulo 6 tiene oscilaciones.

63


3

.2,5

2 -en 1,5 o "C

1 I! e,

0,5 -o '3 o OI

2 3 5 ~ -0,5 6 7 8 9 10

-1

-1,5

-2

Tiempo (segundos)

Fig 8-5 Desempeño del Controlador Difuso en la primera prueba

8.2.2.2 Segundo día.

Durante la realización de las pruebas del primer día se observó que el potenciómetro no estaba fijo

por completo, este problema fue parcialmente solucionado durante el segundo día y los resultados

obtenidos después de fijar el potenciómetro se muestran en la figura 8-6.

Podemos observar que se sigue manteniendo en un cierto rango de respuesta pero ya no son tan

violentas las reacciones como con las del primer día.

3

2

- 1 en o "C t! o e, -.E -1 ::::, e, e -2 e:(

-3

-4

Tiempo (segundos)

Fig 8-6 Desempeño del Controlador Difuso en la segunda prueba

64

Capítulo 9

9. Conclusiones y líneas futuras

En este trabajo se presentó un algoritmo de ajuste de las funciones de membresía de un

Controlador Difuso basado en un Algoritmo Genético. Los resultados obtenidos en varias pruebas

demostraron su efectividad para encontrar una solución adecuada al problema del péndulo

invertido. Los resultados de las simulaciones efectuadas y de las pruebas reales llevadas a cabo en

Tsukuba muestran que las funciones de membresía del controlador original no eran las más

adecuadas. Aún así, el algoritmo de ajuste proporcionó un controlador eficaz a partir de los datos

que se le dieron inicialmente, ya sea proporcionados por un experto o como resultado de un

modelado difuso.

La Lógica Difusa y los Algoritmos Genéticos son dos tecnologías de punta que empiezan a

utilizarse en aplicaciones reales, el presente trabajo es un desarrollo que combina estas dos

tecnologías en el área de controladores. Aunque con tiempo limitado, la experiencia de trabajar

con un sistema real en forma exitosa abre la opción de poder utilizar los algoritmos de control

difuso en alguna aplicación industrial real en México en un futuro cercano. Esto tiene una gran

importancia para que los desarrollos no se queden únicamente a nivel de simulación.

Una extensión natural de este trabajo es permitir que el Algoritmo Genético pueda encontrar una

base de reglas óptimas, este punto es considerado como la prioridad número uno en el trabajo a

desarrollarse en el futuro dada la dificultad inherente que exisw a desarrollar una base de reglas. El

trabajo puede ampliarse en muchos puntos, entre los cuales pueden citarse el uso de diferentes

métodos de inferencia y defuzzificación en el controlador, y la aplicación de diferentes parámetros

en el Algoritmo Genético.


Dado que los algoritmos de control y ajuste están desarrollados en lenguaje C y gracias a su

portabilidad entre plataformas, una de las metas a corto plazo es que estos algoritmos funcionen

en estaciones de trabajo y microcontroladores, equipos con los que cuenta actualmente el

Laboratorio de Electrónica Avanzada del ITESM-CEM.

En los últimos m(;:ses se ha empezado a contar con programas de desarrollo en las estaciones de

trabajo tales como MATLAB (módulos de Lógica Difusa, Redes Neuronales y de Algoritmos

Genéticos), NEFCON y FOOL & FOX con los cuales este trabajo puede ser complementado para

tener herramientas más completas que puedan ayudarnos a resolver problemas en el futuro.

66

Capítulo 10

1 O. Referiencias Bibliográficas

Aceves, A. (1994); Contribución al estudio y desarrollo de una herramienta para control difuso

jerárquico; Tesis de Maestria en Manufactura ITESM-CEM, Diciembre.

Barto, AG. and Sutton, R.S. and Anderson, C.W. (1983); Neuronlike adaptive elements that can

solve difficult learning control problems; IEEE Transactions on Systems, Man and Cybernetics,

Vol 13, pp. (834-846).

Cuahutle, A. y Carbajal, C (1993); Herramienta para Desarrollo de Aplicaciones de Lógica Difusa

en Hardware; XXIII Reunión de Intercambio de Experiencias en Investigación y Desarrollo

Tecnológico del Sistema ITESM, Enero, Vol 2, (pp. 249-253).

Coello, C. A. (1995); Introducción a los Algoritmos Genéticos; Soluciones Avanzadas, Enero, No

17, pp.( 5-11).

Driankov, D. and Hellendoom, H. and Reinfrank, M. (1993):. An Introduction to Fuzzy Control;

Springer Verlag, Berlin.

Goldberg, D.E. (1989); Genetic Algorithms m Search, Optimization & Machine Learning;

Addsion-Wesley Publishing Company Inc.

Goldberg, D.E. (1994); Genetic and Evolutionary Algorithms : Come of Age; Communications of

the ACM, March, Vol 37, No 3.

Grasa, P. and Volberg, O. and Carbajal C. and Cuahutle, A. (1993); The direct adaptive trajectory

control of robot manipulators via fuzzy logic algorithm; Proceedings of the Eight International

Conference on Applications of Artificial lntelligence, Toulouse France, Vol 2, pp. (561-572).

Grefenstette, J.J. (1990); A User's Guide to GENESIS 5.0; Navy Center for Applied Research in

Artificial lntelligence; Washington D.C.


Herrera, F. and Lozano, M. and Verdegay, J. (1993); Genetic Algorithms Applications to Fuzzy

Logic Based Systems; Proc. 9th Polish-Italian and 6th Polish-Finnish Conference on Systems

analysis and Decision support in Economics and Technology, Poland, October.

Herrera, F. and Lozano, M. and Verdegay, J. (1994); Generating Fuzzy Rules from examples

using Genetic Algorithms; Proceedings Fifth International Conference of Information Processing

and Management ofUncertainty in Knowledge-Based Systems, Paris, France, July, pp. (675-680).

Harris, C.J. and Moore, C.G. ancl Brown, M. (1993); Intelligent Control: Aspects of fuzzy Logic

and Neural Nets; World Scientific: Co.Pte, Ltd.

Jang, J.S.R. (1992); Fuzzy Controller Design without Domain Experts; IEEE International

Conference on Fuzzy Systems, pp.(289-296).

Jervis, T.T. and Fallside, F. (1992); Pole Balancing on a Real Rig using a Reinforcement Learning

Controller; Technical Report 115; Cambridge University Engineering Department, December 16.

Karr, C. and Gentry, E. (1993); Fuzzy Control of pH using Genetic Algorithms; IEEE

Transactions on Fuzzy Systems, February, Vol 1, No 1, pp. (46-53).

Kosko, B. (1993); Fuzzy Thinking; Hyperion.

Koza, J.R: ( 1992); Genetic Programming: on the programming of computers by means of natural

selecion; The MIT Press.

Lee, C.C. (1990); Fuzzy Logic in Control systems: Fuzzy Logic Controller-Part I; IEEE

Transactions on Systems Man and Cybernetics, MArch/April, Vol 20, No 2, pp.(404-417).

Leitch, D. and Probert, P. (1994); Context Dependent Coding in Genetic Algorithms for the

Design of Fuzzy Systems; IEEE Nagoya University Workshop on Fuzzy Logic, Neural Networks

and Genetic Algorithms, Nagoya Japan.

LIFE, (1992); Future Prospects of Fuzzy Technology; Laboratory for International Fuzzy

Engineering Research, pp. (2).

Lozano, M., Herrera, F. and Verdegay, J. (1993); Tuning Fuzzy Logic Controllers by Genetic

Algorithms; Reporte Técnico DECSAI-93102, Departamento de Ciencias Computacionales e

Inteligencia Artificial, Universidad de Granada, España ..

Lozano, M. (1993); Controladores PID-Fuzzy; Reporte Interno del Laboratorio de Electrónica

Avanzada, ITESM-CEM.

Matsumoto, O., Kajita, S. and Tani, K. (1993); Estimation ancl control ofthe attitude of a dynamic

mobile robot using interna! sensors; Advanced Robotics, Vol 7, No 2, pp. (159-178).

68

Referencias Bibliográlficas

McNeilland, D. and Freiberger, P. (1993); Fuzzy Logic: The revolutionary computer technology

that is changing our world; Simon & Schuster, NY.

Mejía, A. (1993); LEAR9302 : FAM, Reporte técnico del Laboratorio de Electrónica Avanzada

del ITESM Campus Estado de México, Abril.

Mejía, A. (1994):. Síntesis de Controladores Difusos; XXII Programa de Intercambio México

Japón, Kanazawa Japón, Noviembre.

Miller, W.T. and Sutton, R.S. and Werbos, P.J. (1990); Neural Networks for Control; A

Bradford Book, The MIT Press, Cambridge, Massachusetts, London, England.

Mohammadian, M. and Stonier, R.J. (1994); Generating Fuzzy Rules by Genetic Algorithms;

IEEE lnternational Workshop on Robot and Human Communkation, pp. (362-367).

Munakata, T. ancl Jani, Y. (1994); Fuzzy Systems: An overvi1ew; Communications of the ACM,

March, Vol 37, No 3.

Nauck, D. and Kruse, R. (1994); NEFCON-1: An X-Window based simulator for Neural Fuzzy

Controllers; Proc. IEEE Int. Conf. Neural Networks, Orlando, June.

Probert, P. and Leitch, D. ( 1994); Genetic Algorithms for the Development of Fuzzy Controllers

for Autonomous Guided Vehicles; 2nd European Conference on Intelligent Techniques and Soft

Computing, Aachen.

Stonier, R.J. and Mohammadian, M. (1994); Tuning and Optimization ofMembership functions of

Fuzzy Logic Controllers by Genetic Algorithms, IEEE International Workshop on Robot and

Human Communication, pp. (356-361).

Sugeno, M. and Yasukawa, T (1993); A Fuzzy-Logic-Based Approach to Qualitative Modeling;

IEEE Transactions on Fuzzy Systems; February, Vol 1, No 1, pp. (7-31).

Takagi, H. ( 1990); Fusion Technology of Fuzzy theory and Neural Networks -Survey and future

directions; Proceedings of the First International Conference on Fuzzy Logic and Neural

Networks, Izuka, Japan, July, pp. (13-26).

Terano, T. (1993); Long term view on fuzzy technology and LIFE projects; LIFE Technical

News, November, Vol 4, No 1, (pp. 1-3).

Volberg, O. and Grasa, P. ( 1993 ); A study on the Implementable Adaptive Control of Robot Arm

via Fuzzy Logic Algorithms; 24th Intemational Simposium on Industrial Robots, Tokyo Japan.

White, D.A. Soij~e, D.A. (1992); Handbook of lntelligent Control: Neural Fuzzy, and Adaptive

Approaches; Van Nostrand Reinhold, New York.

69


Yamakawa, T. (1989); Stabilization of an Inverted Pendulum by a High-Speed Fuzzy Logic

Controller Hardware System; Fuzzy Sets and Systems, No 32, pp.( 161-180).

Yamakawa, T. (1993); A Fuzzy Inference Engine in Nonlinear Analog Mode and its Application

to a Fuzzy Logic Control; IEEE Transactions on Neural Networks, May, Vol 4, No 3, pp. (496-

521).

Zadeh, L.A. (1965); Fuzzy Sets; Inform Control, Vol 8, pp. (338-353).

Zadeh, L.A. (1973); Outline of a New Approach to the Analysis of Complex Systems and

Decision Processt:s; IEEE Transactions on Systems Man and Cybemetics, January, Vol SMC-3,

No 1, pp. (28-44).

Zadeh, L.A. (1994); Fuzzy Logic, Neural Networks, and Soft Computing, Communications ofthe

ACM, March, Vol. 37, No 3, pp. (77-83).

70

Apéndice A

A. Listado

En este apéndice se presenta el código fuente del programa, éste está dividido en módulos para

una mayor compn~nsión dependiendo de su función.

Este programa está desarollado en lenguaje C utilizando el compilador Borland C++ 3 .1 ..

La sección llamada operador.h contiene los procedimientos del Algoritmo Genético, estruct.h

contiene todas las estructuras que se utilizaron en el programa, en péndulo.h se encuentran las

rutinas de simulación del péndulo invertido, gráfica.h tiene las utilerías gráficas que se

desarrollaron para. visualizar la simulación, el módulo cld-g.h tiene los algoritmos de control difuso

desarrollados en el ITESM-CEM y genético.e es el programa principal


A.1 Operador.h

void simetrico(struct miembro •elem)

{

int ij;

int cont,dif;

cont=19;

for (i=O;i<8;i++)

elem->inicio[ cont--J = 102 3 ~lem->inicio[ i] ;

cont=39;

for(i=20;i<28;i++)

elem->inicio[ cont--J= 1023~lem->inicio[i);

cont=59;

for(i=40;i<48 ;i++)

elem->inicio[ cont--]= l 023~lem->inicio[ i 1;

cont=8;

for(i=O;i<3;i++)

{

if ( elem->inicio[ cont+ 1 )>512)

{

dif=elem->inicio[cont+ 1 J~lem-

>inicio[cont];

dif;

}

j=elem->inicio( cont+ 1 )-512;

elem->inicio[cont+ 1)=512-j;

elem->inicio[ cont J=elem->inicio[ cont+ 1 ]-

elem->inicio[cont+ 3 )= 1023~1em

>inicio[cont];

72

elem->inicio[ cont+ 2)= 1023-elem

>inicio[ cont+ l];

cont+=20;

}

void creacion(void)

{

int i;

int •ayuda;

FILE •f;

strcpy(nombre2,nombre);

strcat(nombre2,".bin");

f= fopen (nombre2, "rb");

get (f,&a,sizeof(a));

get (f,&c,sizeof(c));

get (f,&ra,sizeof(ra));

get (f,&rc,sizeof(rc));

fclose(f) ;

pob_antigua=(struct miembro•) calloc

( elementos, sizeof( struct miembro)) ;

if (pob _ antigua == NULL)

{

clrscr();

printf("No hay memoria");

getch();

}

pob_nueva=(st:ruct miembro•) calloc

( elemcntos,sizeof(struct miembro));

if (pob _ nueva == NULL)

{

clrscr();


getch();

}

Listado

for(i=O;i<elementos;i++)

{

pob_antigua[i].inicio=(int *)

calloc( 4 *(ra+rc),sizeof(int) );

if(pob_antigua[i].inicio == NULL)

{

}

clrscr();


getch() ;

pob _ nueva[i] .inicio=(int *) calloc

(4*(ra+rc),sizeof(int));

if (pob_nueva[i].inicio == NULL)

{

clrscr();


getch() ;

}

for (i=O;i<4;i++)

param[i] = (struct inicializacion *)calloc

(l ,sizeof(struct inicializacion));

pararn[l]->posicion_inicial =50;

pararn[ l J->velocicfad_inicial =-1 O;

param[O]->posicion_inicial = 50;

param[O]->velocidad_inicial = 10;

param[2]->posicion_inicial =-50;

pararn[2]->velocidad_inicial =10;

param[3]->posicion_inicial = -50;

param[3]->velocidad_inicial = -10;

}

void fijo_fuzzy(void)

{

73

int i;

for (i=O;i<ra;i++)

{

da[i] .lim _ inf=fijo _ ant[i] .lirn _inf;

da[i] .pico l =fijo_ ant[i] .pico l ;

da[i] . pico2=fijo _ ant[ i] . pico2;

da[i] .lim _ sup=fijo _ ant[i] . lim _ sup;

}

for (i=O;i<rc;i++)

{

}

dc[i] .lim _inf=fijo _ con[i] .lim _ inf;

dc[i] .picol =lijo_ con[i) .picol ;

dc[i]. pico2=1ijo _ con[i] . pico2;

dc[i]. lim _ sup=fijo _ con[i]. lirn _ sup;

}

void fuzzy_string(int nurn)

/*convierte de estructuras fuzzy a cadenas*/

{

int cont=O;

int i=O;

while(cont<ra)

{

pob_nueva[num] .inicio[i++]=da[cont].Jim_inf;

pob _ nueva[num] .inicio[i++J=da[cont] .pi col ;

pob_nueva[num].inicio[i++)=da[cont].pico2;

pob_nueva[num].inicio[i++J=da[cont++J.lim_su

p;

}

cont=O;

while(cont<rc)

{

pob _ nueva[ num].inicio[i++ ]=dc[cont] .lim _inf;


pob_nueva[nurn].inicio[i++]=dc[cont].picol;

pob_nueva[nurn].inicio[i++]=dc[cont].pico2;

pob_nueva[nurn].inicio[i++]=dc[cont++].lim_su

p;

}

}

void string_fuzzy(struct miembro *elern)

/"'convierte de una cadena en la pob_antigua

a estructuras fuzzy"'/

{

int cont=O;

int i=O;

while(cont<ra)

{

}

da[cont].lim_inf=elern->inicio[i++];

da[cont] .pico 1 =elern->inicio[i++];

da[ cont]. pico2=elern->inicio[ i++);

da[cont++).lim_sup=elern->inicio[i++];

cont=O;

while(cont<rc)

{

}

}

dc[cont] .lim_inf=elem->inicio[i++];

dc[cont] .pico 1 =elern->inicio[i++ J;

dc[cont) . pico2=elem->inicio[ i++);

dc[cont++] .lim_sup=elem->inicio[i++];

/"'lim_inf <=picoU <= pico2 <= lim_sup*/

void restricciones()

{

int i;

74

for (i=O;i<ra;i++)

{

if(da[i).lim_inf< O)

da[i].lirn_inf= O;

if (da[i).lim_sup >1023)

da[i].lim_sup = 1023;

if(da[i].picol < da[i].lim_inf)

da[i].picol == da[i].lim_inf;

if(da[i].pico2 > da[i).lim_sup)

da[i).pico2 == da[i).lim_sup;

if (da[i) .picol > da[i).pico2)

da[i).picol == da[i) .pico2;

}

for (i=O;i<rc;i++)

{

}

if (dc[i].Jim __ inf < 0)

dc[i).lim_ilú= O;

if(dc[i).lirn_sup >1023)

dc[i).lirn_sup = 1023 ;

if (dc[i).picol < dc[i).lim_inf)

dc[i).picol = dc[i).lirn_inf;

if(dc[i).pico2 > dc[i].lim_sup)

dc[i].pico2 = dc[i).lim_sup;

if(dc[i] .picol > dc[i] .pico2)

dc[i].picol = dc[i] .pico2;

}

unsigned char volado(int probabilidad)

{

unsigned char moneda;

int valor;

valor=random( 1 O 1 );

if (valor < probabilidad)

Listado

moneda=};

else

moneda=O;

return moneda;

}

void crossover (void)

{

int i,x,numero;

numero=4*(ra+rc);

if(volado{pcruce)) /11 Iugar para el cruce11

/

{

}

punto_ cruce=random(numero );

if {punto_ cruce==O)

punto_ cruce = 1;

if (punto_cruce===(4*numero)-l)

punto_ cmce--;

else

punto_ cruce=numero;

for (i=O;i<punto_cruce;i++)

/11cruce de informacion 11

/

hijo 1->inicio[ i ]=padre 1->inicio[ i];

hijo2->inicio[i]=padre2->inicio[i];

}

for (i=punto_cruce;i<4*(ra+rc);i++)

{

}

hijo l ->inicio[i)=paclre2->inicio[i];

hijo2->ini1cio[i]=padre 1->inicio[i];

}

void mascara(int pos,int clase)

75

{

int mascara= 1 :

int viejo,nuevo;

mascara = mascara < < pos;

viejo = *emutacion;

nuevo=viejo I mascara;

/11si el bit es O con el OR lo hacemos 111/

/11si no hubo cambio (estaba ya en 1) hacemos

la mascara11/

if( nuevo==viej o)

/11con el bit en O dependiendo de la posicion 11

/

11para obligarllo a cambiar a O con el AND 11/

{

switch(pos) /

{

case O: mascara= 1022; / 11 111111111011/

break:

case 1: mascara= 1021; /*1111111101 11/

break;

case 2: mascara= 1019; /11 1111111011 11/

break;

case 3: mascara= 1015; /*1111110111*/

break;

case 4: mascara= 1007; / 11 1111101111 */

break;

case 5: mascara = 991 ; /11 1111011111 11

/

break;

case 6: masca:ra = 959; /11 1110111111 11

/

break;

case 7: mascara= 895; /11 1101111111 */

break;

case 8: mascara= 767; /11 1011111111 */

break;

case 9: mascara= 511; /*O 111111111 */


break;

}

nuevo= viejo & mascara;

}

switch( clase)

*checar que no de resultados raros las

mutaciones*/

}

{

case LI: if(nuevo <= *(ernutacion+ 1))

*ernutacion=nuevo;

break;

case PI : if(nuevo >= *(ernutacion-1) &&

nuevo<= *(ernutacion+ 1))

*ernutacion=nuevo;

break;

case P2: if(nuevo >= *(emutacion-1) &&

nuevo<= *(ernutacion+ 1))

*ernutacion=nuevo;

break;

case LS: if (nm:vo >= *(emutacion-1))

•emutacion=nuevo;

break;

}

void mutacion (stmct miembro *mutar)

{

int i,x,y,aux;

for (x=O;x<4*(ra+rc);x++)

/*numero de datos en cada elemento*/

{

ernutacion=&rnutar->inicio( x J; aux=x;

while( aux>=4)

76

/*para saber si es lim_inf o que cosa*/

{

/* O lim_inf 1 picol 2 pico2 3 lim_sup*/

aux-==4;

}

for (i=O;i<IO;i++)

/*numero de bits en cada dato*/

}

}

{

}

if(volado(pmutacion))

mascara(i,aux);

int seleccion(void)

{

float ruleta=O:

float parcial=();

int i=O;

char lim[lO] ;

i=randorn (101);

ruleta=(long clouble) i;

i=O;

ruleta /= 100;

ruleta *= sumfitness;

do

{

parcial+= (long double) pob_nueva[i++].fitness;

}

while(parcial<ruleta );

i--· '

retum(i);

}

Listado

void reproduccion (void)

{

int j,i,e l ,e2,datos;

datos=ra+rc;

datos*=4;

for (i=O;i< datos; i++)

/*asegurarme que el mejor este en la

siguiente generadon"'/

pob_antigua[O].inic:io[i] =

pob_nueva[mejor_miembro].inicio[i] ;

for(i= 1 ;i<elementos;i+=2)

/*porque despues de cada vuelta son en la

poblacion antigua"'/

{

e 1 =selec:cion();

do

{

e2=seleccion();

}

while(e2==el);

hijol=&:pob_antigua[i];

hijo2=&pob_antigua[i+ 1]:.

padrel ==&pob _ nueva[el ];

padre2==&pob _ nueva[ e2] ;

crossover();

/"' se crean los hijos en la nueva poblacion"'/

string_fuzzy(hi jo 1 );

restricciones();

/*para checar integridad en las funciones"'/

fuzzy _string(i) ;

/*los arreglos de restricciones los reflejamos

en la poblacion"'/

mutacion(hijo 1 );

string_ fuzzy(hijo2);

77

/*despues del crossover"'/

restricciones();

fuzzy _ string(i+ 1 );

mut1cion(hijo2);

if(bioskey( 1 )===O)

{

pob_auxiliar=pob_antigua;

pob _ antigua==pob _ nueva;

pob _ nueva=pob _ auxiliar;

*ap_cont=O;

}

else

*ap_cont = bioskey(O);

}

void generacion _genetico()

{

int diferencia,i,y;

fuzzy _string(O);

randornize();

for(i= l ;i<elementos;i++)

{

for(y=O;y<ra;y++)

{

diferencia==random( 100);

da[y ].lim _ inf=

fijo _ant[y] . lim _inf+( diferencia-50);

diferencia,=random( 100);

da[y].picol=

fijo_ ant[y].picol +(diferencia-50);

diferencia =random( 100);

da[y). pico2=

fijo __ ant[y] . pico2+( diferencia-50);


}

diferencia=random( 100);

da[y].lim_sup=

fijo _ant[yJ .lim _ sup+( diferencia-SO);

}

for(y=O;y<rc;y++)

{

diferencia=random(lOO);

dc[y].lim_inf=

fijo_ con[y] .lim _ inf+( diferencia-SO);


dc[y].picol=

fijo _con[y].pico 1 +(diferencia-SO);


dc[y].pico2=

fijo_conly].pico2+(diferencia-SO);

diferencia=randorn( 100);

dc[y]. lim _ sup=

fijo_con[y].lim_sup+(diferencia-SO);

}

restricciones();

fuzzy _string(i);

}

void funcion _ objetivo(void)

{

int i;

sumfitness=O;

for (i=O;i<elementos;i++)

}

{

pob_nueva[i].fitness = 1/pob_nueva[i] .fitness;

sumfitness += pob_nueva[i].fitness;

}

78

void algoritmo __ genetico(void)

{

funcion_ objetivo();

reproduccion();

}

A.2 Péndulo.h

/*Procedimientos de simulacion del pendulo*/

float H (float xl, float x2)

{

}

float resultado= ((g*sin(xl)+cos(xl)*(-fuerza

m*l*pow(x2,2)*sin(xl))/mc+m) /

1*(1.33- (rn*pow(cos(xl),2)) /mc+m) );

return(resultado );

void sirnulaJ,endulo (void)

{

posicion_t = O.S*h*velocidad+posicion;

velociclad_t :, O.S*h*H(posicion,velocidad);

posicion = O.S*h*velociclad_t+posicion_t;

velocidad =

O.S*h*H(posicion_t,velocidad_t)+velocidad_t;

}

float radian_grado(float rad)

{

float grad;

Listado

grad=(rad*lS0)/3.141592;

retum(grad);

}

float grado_radian(float grado)

{

float rad;

rad= (grado* 1.2907)/90;

retum(rad);

}

/"'Procedimientos destinados a cambiar los

dartos que lleguern de magnitudes

fisicas a difusas y visceversa"'/

/"' aqui va de cuando llegue -90 de O y cuando

llegue 90 de 1023

para que el algmitmo de control difuso de el

resultado lo mismo con la

velocidad angular y la fuerza"'/

int escala __posicion(float pos)

{

int resultado;

pos=

((pos+(posicion _ maxima))* 1023)/

(posicion __ maxima*2);

resultado = (int) pos;

79

retum(resultaclo );

}

!"' de -10 a 101'/

int escala_ velocidad(float fuer)

{

int resultado;

fuer+=velociclad _ maxima;

fuer=(fuer* l 023)/(velocidad_ maxima*2);

resultado= (int) fuer;

retum(resulu1do);

float escala_fuerza(int fuer)

{

float resultado;

resultado=fuer;

resultado=(resultado*(fuerza_maxima*2))/l023;

resultado-=fuerza _ maxima;

retum (resultado);

}

void desarrollo(void)

int opcion;

float i;

transcurrido=:0;

do

}

{

ante[l] = escalaJ,osicion(posicion);

/ 11 algoritmos de control difusos11/

ante[O] = escala_velocidad(velocidad);

control_ fuzzy();

fuerza= escala_fuerza(conse[O]);

simula _pendulo(};

error += pow(posicion,2);

transcurrido+= h;

}

while(transcurrido-h<tiempo);

void muestra()

{

int opcion;

float i;

do

{

if(transcurrido-h>tiempo)

{

break;

}

ante[ 1] = escala _J>Osicion(posicion);

ante[O] = escala_velocidad(velocidad);

control_ fuzzy();

fuerza= escala_fuerza(conse[O]);

simula _pendulo();

dibujo _pendulo();

dibuja_resultado();

despliega(O);

if(bioskey(l))

{


80

}

opcion=bioskey(O);

if( opcion/256==RET)

despliega( 1 );

}

}

while(opcion/256!=ESC);

transcurrido=O;

x_ant=O;

/11 aqui tiene que cambiar las estructuras

fuzzy y evaluar un paso del controlador

para cada uno de los elementos de la

poblacion nue,ra para despues

hacer las seleccion de cruzamiento11/

void evaluacion()

{

int ij=O,opcion=O;

float aux;

char lim[30);

FILE *errores;

ap _ cont = &opcion;

cont_gener=O;

transcurrido=O;

errores = fope:n ("error.err", "wt");

do

{

aux=lOOO;

for (i=O;i<elementos;i++)

Listado

/ 11 evaluacion de cada elemento*/

{

comodin=&pob _nueva[i];

string_ fuzzy( comodín);

error=O;

for(j=O;j<4;j++)

{

posicion=

grado _radian(param(j]->posicion _inicial);

velocidad=param(j]->velocidad_inicial;

transcurrido=O;

desarrollo();

}

pob _ nueva[i].fitness = error/(tiempo/h);

transcurrido=O;

x_ant=O;

}

j=O;

for(i=O;i<elementos;i++)

{

if (pob_ nueva[i].fitness < aux)

{

aux = pob_nueva[i].fitness;

j=i;

}

}

mejor_ miembro=j;

if (cont_gener==O)

{

escala error 195/pob _ nueva[O] .fitness;

/*sacar la escala con la cual dibujar los

errores*/

error_y = 195-(pob_nueva[O].fitness *

81

}

escala_error);

error_x = 30;

error_inicial=pob_nueva[O].fitness;

fprintf( errores, "o/of\n" ,pob _ nueva[O] .fitness);

fprintf( errores, "o/of\n" ,pob _ nueva[ mejor_ miembr

O]. fitn1!SS);

error _aux=aux:

comodin=&pob_ nueva[ mejor_ miembro];

/*muestra en 11antalla del mejor*/

string_ fuzzy(comodin);

dibuja_ error(mejor _miembro);

posicion=grado _ radian(param[O]->

posicion _inicial);

velocidad=param[O]->velocidad _ inicial;

muestra();

cont_gener++;

if (cont_gener<generacion)

{

view __port(O);

bar(50, 140,400, 150);

setcolor(LIGHTMAGENT A);

outtextxy(l20,142,"CALCULANDO");

setcolor(WHITE);

algoritmo _genetico();

}

}

for(i=O;i<elementos)

simetrico(&pob_nueva[i]);

while( cont _g,~ner<generacion );

fclose( errores);

}


/,..Guarda los erro.res para cada paso de la

simulacion en un archivo diferente,../

void archivo_datos(int op,int inicial)

{

int opcion;

char archivo[l3] ,archivo2[13];

FILE •a;

if (op==O) strcpy(archivo, "final");

else strcpy(archivo, "orig");

strcpy(archivo2,arc;hivo );

switch (inicial)

{

case O :strcat(archivo2,".cer");

break;

case 1 :strcat(archivo2,".uno");

break;

case 2 :strcat(archivo2," .dos");

break;

case 3 :strcat(archivo2, ". tre");

break;

}

a = fopen(archivo2 , "wt");

do

{

ante[ 1] = escala _ _posicion(posicion);

ante[O] = escala_ velocidad(velocidad);

control_fuzzy();

fuerza= escala __ fuerza(conse[O]);

simula __pendulo();

fprintf(a,"%f% f o/of

82

}

\n" ,posicion, velocidad,fuerza);

transcurrido+=h;

}

while( transcu rrido-h<tiempo);

transcurrido=O;

fclose(a) ;

/,..Muestra la diferencia entre el original y el

mejor generado por elalgoritmo genetico,../

void final(void)

{

int i;

view_port(4); /*borrar toda la pantalla*/

clearviewpo11();

view _port(2);

for(i=O ;i<4;i++)

{

posicion=grado _radian(param[ i ]->

posicíon _inicial) ;

velocidad=param [ i ]->velocidad_ inicial;

archivo_datos(O,i) ;

posicion=grado _ radian(param[i]->

posicion _inicial);

velocidad=1>aram [ i ]->velocidad _inicial;

muestra();

getch();

}

fijo_fuzzy(};

for(i=O;i<4 ;í++)

{

Listado

}

posicion=grado __ radian(pararn[i ]->

posicion _inicial);

velocidad=param[ i ]->velocidad_ inicial;

archivo_datos(l ,i);

posicion=grado __ radian(param[ i ]->

posicion _inicial);

velocidad=param [ i ]->velocidad_ inicial;

muestra();

getch();

}

void reporte()

{

FILE *f;

int i;


strcat(nombre2, ". par");

f= fopen (nombre2, "wt");

fprintf(f, "Reporte de las funciones de

membresia parametros de o/oS \n \n",&nombre);

for(i=O;i<ra;i++)

{

fprintf(f, "Antec(:dente %d , Numero %d

\n" ,da[i].var,i);

fprintf(f,"Limite inferior %d\n"

,da[i].lim_inf);

fprintf(f, "Picol %d\n" ,da[i] .pico 1);

fprintf(f,"Pico2 %d\n",da[i].pico2);

fprintf(f, "Limitf: superior

%d\n\n",da[i].lim_sup);

}

83

for(i=O;i<rc;i++)

{

fprintf(f, "Consecuente %d , Numero %d

\n",dc[i].var,i);

fprintf(f, "Limite inferior %d\n"

,dc[i].lim_inf);

fprintf(f,"Picol %d\n",dc[i].picol);

fprintf(f,"Pico2 %d\n",dc[i].pico2);

fprintf(f, "Limite superior

%d\n\n",dc[i].lim_sup);

}

fprintf(f, "Numero de generaciones

%d\n" ,generacion);

fprintf(f,"Tiempo de simulacion %f\n",tiempo);

fprintf(f,"Prob. de crossover %d % \n",pcruce);

fprintf(f,"Prob. de mutacion o/od %

\n" ,pmutacion);

fprintf(f,"Masa del pendulo %.4f\n",m);

fprintf(f,"Longitud del pendulo %.4f\n",l);

fclose(f);

}

/* Aqui salva el mejor conjunto de funciones

que haya res111ltado delalgoritmo genetico*/

void generacion_binario(void)

{

int i=O;

FILE *fl;

comoclin=&pob _ nueva[ mejor _miembro];

string_fuzzy(comoclin);


view _port( 4 );

clearviewport();

gotoxy(l5, 15);

printf("Dame el nombre del archivo a crear: ");

scanf("o/os" ,&nombre);

reporte();

/"'Reporte del mejor miembro de todos"'/


strcat( nombre2,". b:in ");

fl= fopen (nombre2,"wb");

fwrite(&a,sizeof(char), l,fl);

fwrite(&c,sizeof(char), l ,fl);

fwrite(&ra,sizeof(int), l ,fl );

fwrite(&rc,sizeof(int), I ,fl);

for(i=O;i<a+c;i++)

{

fwrite( &basura[O] .fonna,sizeof( char), 1,fl );

fwrite(&basura[O].maximo,sizeof(float),1,fl);

fwrite( &basura[O]. minimo,sizeof(float), 1,fl );

}

for(i=O;i<ra;i++)

{

fwrite(&da[i].var,sizeof(char), l ,fl);

fwrite( &da[i]. lim_ inf,sizeof(int), 1,fl );

fwrite(&da[i] .pic:o l ,sizeof(int), 1,fl );

fwrite(&da[i].pic:o2,sizeof(int), 1,fl );

fwrite(&da[i].lim_sup,sizeof(int), l ,fl);

}

for(i=O;i<rc;i++)

{

84

fwrite(&dc[i] .var,sizeof(char), l ,fl);

fwrite(&dc[i].lim _inf,sizeof(int), l ,fl);

fwrite(&dc[i].pico 1,sizeof(int), 1,fl );

fwrite(&dc[i].pico2,sizeof(int), l,fl);

fwrite( &dc[i] .lim _ sup,sizeof(int), 1,fl );

}

fwrite(&m,siz,~of(int), 1,fl );

for(i=O;i<m;i++)

fwrite(&r[i] .instr,sizeof(char), l ,fl );

fwrite(&r[i].id,sizeof(int), l ,fl);

}

fclose( f1);

}

void fijo (void)

{

int i;

fijo_fuzzy();

}

for(i=O;i<4;i++)

{

posicion=grado_radian(param[i]->

posicion _inicial);

velocidad=param[i]->velocidad_inicial;

archivo_ datos( 1,i);

posicion=grado _ radian(param[ i]->

posicion _ inicial);

velocidad=param[ i ]->velocidad_ inicial;

muestra();

getch();

}

Listado

A.3 Estruct.h

char nombre[l3],nombre2[13];

#define MAX 25

#define MIN 125

#define ESCALA 2.273

#define RET 28 /* 13*/

#define BAR 32

#define ESC 1 /*27*/

#define BS 8

#define INS 82

#define DEL 83

#define AR 77

#define AL 75

#define AU 72

#define AD 80

#define PGUP 73

#define PGDN 81

#define LI O

#define PI 1

#define P2 2

#define LS 3

/**"'*** Algoritmo genetico *******/

struct miembro

{

int *inicio;

float fitness;

};

struct miembro * pob _antigua,* pob _ nueva;

85

/*al comienzo de las poblaciones*/

struct miembro* pob_auxiliar;

struct miembro* padrel, * padre2;

/*miembros elegidos para cruzarse*/

struct miembro* hijol, * hijo2;

/*hijos en la poblacion nueva*/

struct miembro * comodin;

int * emutacion;

/*valor que esta mutando*/

int elementos=77;

/*numero de •!lementos en la poblacion*/

int pmutacion=,2;

/*probabilida.d de mutacion*/

int pcruce=60;

/*probabilidad de cruzamiento*/

int punto_ cruce;

/*punto donde se hara el cruzamiento*/

float sumfitness;

/*sumatoria del fitness de los miembros de

la poblacion*/

float error;

/*error para :¡acar el fitness de cada funcion*/

float error_aux;

int mejor_ miembro;

/*indice del mejor en cada generacion*/

int generacion=IOO;

/*numero de generaciones permisibles*/

int cont_gener; /*generacion en la que va*/

/*** Variabl1!s para el controlador difuso***/

enum instr {si=I,y,entonces,fin,ret,novalida};

struct data {


charvar;

int

lim _ inf,pico l ,pico2,lim _ sup,membresia;

};

struct var {

char forma;

int minimo,maximo;

};

struct rule {

};

char instr;

intid;

struct data *da, *de, *fijo_ant, *fijo_con;

struct data *auxiliar, *fijo _aux;

struct rule *r;

struct var *basura;

int *ante, *conse;

long int *momento;

unsigned char a,c,real;

int ra,rc,m ;

/*mitad de la longitud del pendulo* I

float h = 0.05;

/*paso de tiempo en la aproximacion*/

float tiempo=lO;

/*tiempo de simulacion*/

float transcurrido=O;

/*tiempo transcurrido de simulacion"'/

struct inicializacion

{

float posicion __ inicial;

float velocidad_ inicial;

} ;

struct inicializacion *param[4);

/*** variables de graficacion ***/

int longitud = 50;

/*longitud dd p,ndulo en forma gráfica*/

float thetha; /*angulo del pendulo*/

float grados;

struct ventana

/* Estructura para el manejo de ventanas*/

/******* Simulacion del pendulo *********/ {

float fuerza ;

/*fuerza aplicada al pendulo*/

float posicion _ t, vclocidad _ t,posicion,velocidad;

float g = 9.8; /*fuerza de la gravedad*/

float me= l ;

float m = . l;

float 1 = 0.5;

/*masa del car rito*/

/*masa del pendulo*/

86

int xini,yini,:din,yfin;

/*Coordenadas de la ventana*/

};

struct ventana ven[5] ;

int pos_x,pos_y,vel_x,vel_y,fue_x,fue_y;

/*punto ant,erior de las graficas*/

Listado

int error_ x,error _y;

int x _ ant=O;

float escala _pos,escala _ vel,escala _ fuer,

escala_ x,escala _ error;

float error_inicial;

float velocidad_rnaxirna=IO;

float fuerza_rnaxima=25;

float posicion_rnaxirna=l.5707;

int *ap_cont;

A.4 Cld-g.h

/**********************/

/* algoritmos fuzzy * /

void fuzzyfica (void)

{

register int i;

for (i=O; i<ra; i++)

{

if (ante[da[i].var] < da[i].lim_inf)

da[i].membresia= O;

else

if (ante[da[i].var] > da[i].lim_sup)

da[i].membresia= O;

else

if (ante[da[i].var] < da[i].picol)

da[i].membresia= (long int)

1023*(ante[da[i].var]

-da[i].lim_inf)

87

d

}

}

/(da[i].picol-da[i].lim_inf);

else

if (ante[da[i] .var] > da[i].pico2)

da[i].membresia= (long int)

1023*(ante[da[i] .var]

a[i].lim _sup)

/(da[i].pico2-da[i].lim_sup);

else

da[i] .membresia= 1023;

for (i=O; i<rc . i++)

dc[i].membresia= O;

void evalua (void)

{

register int t,x,i;

for (i=O; i<m; i++)

{

switch (r[i].instr)

}

}

case si:

case y:

x= da[r[i].id].membresia;

break;

if (x)

x=

min(da[r[i].id] .membresia,x);

break;

case entonces: if (x)

}

if (x>dc[r[i].id].membresia)

dc[r[i].id].membresia= x;

void defuzzyfica (void)

{

}

}

register char i;

register int fza;

for (i=O; i<c; i++)

{

conse[i]= O;

momento[i]= O;

}

for (i=O; i<rc; i++)

{

if (dc[i].membresia)

{

fza= dc[i].membresia;

conse[dc[i].var]+= fza;

momento[dc[i].var]+= (long int) fza *

(dc[i].pico 1 +dc[i].pico2)/2;

}

for (i=O; i<c; i++)

{

if (conse[i])

conse[i]= (int) (momento[i]/conse[i]);

}

void control_fuzzy (void)

{

}

fuzzyfica ();

evalua ();

defuzzyfica ();


88

/"'"'"'"'"'"'"'"'"'"'"'''"'"'/ /"' archivos "'/

/"'"'"'"'"'"'"'"'"'"'"'''"'"'/

void get (FILE *f, void *ptr, int size)

{

fread (ptr,size, l,f);

}

/"'"'"'"'"'"'"'"'"'"'"'~"'"'"'"'"'"'"'"'"'"'"'/

/"' controlado1: fuzzy "'/

void read_ruleset (void)

{

int i;

FILE •f;


strcat(nombre2," .bin");

f= fopen (nombre2, "rb");

get (f,&a,sizeof(a));

get (f,&c,sizeof(c));

get (f,&ra,sizeof(ra));

get (f,&rc,sizeof(rc));

ante= (int *) calloc (a,sizeof(int));

conse'= (int *) calloc (c,sizeof(int));

momento= (long int *) calloc

(c,sizcof(long int));

basura= (struct var *) calloc

(a+c,sizeof(struct var));

for (i=O; i<a+c; i++)

{

Listado

get (f,&basura[i].fonna, l);

get (f,&basura[i].minimo,4);

get (f,&basura[i].maximo,4);

}

da= (struct data *) calloc

(ra,sizeof(struct data));

fijo_ant= (struct data *) calloc


for (i=O; i<ra; i++)

{

get (f,&da[i].var, l);

fijo_ ant[i] .var=da[i]. var;

get {f,&da[i] .lim_inf,2);

fijo_ant[i].lim_inf=da[i].lim __ inf;

get (f,&da[i).picol,2);

fijo _ant[i] .picol =da[i].picol;

get (f,&da[i].pico2,2);

fijo_ ant[ i]. pico2=da[ i]. pico2;

get (f,&da[i].lim_sup,2);

fijo_ ant[i] .lim_ sup=da(i]. lim __ sup;

}

de= (struct data *) calloc

(rc,sizeof(struct data));

fijo_con= (struct data*) calloc

(rc,sizeof(struct data));

for (i=O; i<rc; i++)

{

get (f,&dc[i].var,l);

fijo_ con[i]. var=dc[i] . var;

get (f,&dc[i].lim_inf,2);

fijo_con[i)Jim_inf=dc[i].lim __ inf;

get (f,&dcli] .picol,2);

89

}

fijo_ con[i] . pico 1 =dc[i] .picol;

get (f,&.dc[i].pico2,2);

fijo_ con[i]. pico2=dc[ i]. pico2;

get (f,&.dc[i] .lim_sup,2);

fijo_con[i] .lim_sup=dc[i].lim_sup;

}

auxiliar-da;

fijo _aux=fijo_ant;

gel (f,&rn,sizeof(rn));

r= (struct rule *) calloc


for (i=O; i<rn; i++)

{

get {f,&r[i].instr, l);

get (f,&r[i].id,2);

}

fclose (f);

A.5 Gr:ifica.h

float radian _gr.ado(float rad);

void view_port(int n)

setviewport(ven[ n]. xini, ven[ n] .yini, ven[ n] . xfin,

ven[n] .yfin, l) ;

}

!" Procedimiento de las ventanas de trabajo

del programa''/

void ejes(void)

Ajuste de Controladores Difusns mediante Algoritmos Genéticos

{

view_port(2);

clearviewport();

setcolor(RED);

line(30,5,30, 195);

line(O, 100,450, 100);

setcolor(WHITE);

}

void ejes_errores(void)

{

view _port(3 );

clearviewport();

setcolor(RED);

/*eje y*/

/*eje x*/

line(30,5,30,200); /*eje y*/

line(O, 195,(639-451), 195); /*eje x*/

setcolor(WHITE);

}

void define_ventana(int n,int izq, int arr, int

der, int aba)

{

ven[n].xini=izq;

ven[n].yini=arr;

ven[n].xfin=der;

ven[n].yfin=aba;

setviewport(izq,arr,der,aba, 1 );

}

void escalas()

{

escala_pos=200/posicion_ maxima;

escala_ vel=200/(velocidad_ maxima*2);

90

escala_ fuer-200/(fuerza _ maxima *2 );

escala_x=420/(tiempo/h);

/*distancia minima de graficacion en x 1 */

if(escala_x>420)

escala_ x=4 20;

}

void informacion()

{

view _port( 4);

clearviewport();

settextjustify (LEFf _ TEXT, TOP_ TEXT);

settextstyle(DEF AUL T _FONT,HORIZ _ DIR,O);

setcolor(LIGHfGREEN);

outtextxy(50, 15, "Optimizacion de las

Funciones de Membresia de un

Controlador Difuso");

outtextxy(200,3 5, "mediante Algoritmos

Geneticos");

outtextxy(l5,275, "Funciones de Membresia");

outtextxy(550,275,"Informacitn");

outtextxy (500.40, "Errores");

setcolor(WHl1E);

}

/*Procedimiento de definicion global de la

pantalla*/

void definicion_pantalla(void)

{

define_ ventana(0,0,300,450,450);

define_ ventana( l,500,300,639,450);

define_ ventana(2,0,50,450,250);

define_ ventana(3.45 l .50,639 ,250);

Listado

define_ ventana( 4,0,0,639,4 79);

}

void inicializa_graficas (void)

{

}

int d,m,error;

detectgraph (&d,&m);

initgraph (&d,&m," ");

/*inicializa a 639x479*/

error=graphresult();

if (error !=O)

printf("Codigo de error en graficas

: %d ",error);

definicion _pantalla();

escalas();

sprintf (lim, "1%6f' ,error _inicial);

outtextxy( 40,5, "In: ");

outtextxy(80,5, lim);

sprintf (lim, "%,.6f',

pob _ nueva[ miembro ].fitness) ;

outtextxy(40, 15, "Ac: ");

outtextxy(80, 15,lim);

setcolor(YELLOW);

x=error_x;

error x++· - ,

y= (float) pob __ nueva[rniembro].fitness * escala __ error;

y= 195-y;

line(x,error _y,trror _ x,y) ;

error_y=y;

setcolor(WHITE);

/*Procedimiento para seleccionar una parte }

de la pantalla"'/

void dibuja_error(int miembro)

{

int x,y;

char lim[l5];

if( error_ x==30)

{

view _J)Ort(3 );

clearviewport();

ejes_ errores();

}

view ..J)Ort(3);

setfillstyle(SOLID _FILL,BLACK);

bar( 40,5, 150,20);

91

/"'Despliegue de la funcion a la que apunta

auxiliar*/

void desp _ funciones(void)

{

char identificador;

char lim[IO] ;

view ..J)Ort(O);

clearviewport() ;

line(O, 125,450, 125);

if(auxiliar>=da && auxiliar<= da+(ra-1))

outtextxy(O, 130, "Antecedente ");

else

outtextxy(O, 130, "Consecuencia");

sprintf (lim, "o/od" ,auxiliar->var);

outtextxy(l00,130,lim);

identificador = auxi.liar->var;

while(auxiliar->var == identificador)

{

setcolor(WHITE);

line(fijo_aux->

lim _ inf/ESCALA,MIN,fijo _ aux->

picol/ESCALA,MAX);

line(fijo_aux->

pico 1/ESCALA,MAX,fijo _ aux->

pico2/ESCALA,MAX);

line(fijo_aux->

pico2/ESCALA,MAX,fijo _ aux->

lim _ sup/ESCALA,MIN);

if(auxiliar->membresia != O)

setcolor(LI GHTBLUE);

else

setcolor(YELLOW);

line(auxiliar->

lim _ inf/ESCALA,MIN ,auxiliar->

pico 1/ESCALA,MAX);

line(auxiliar->

pico 1/ESCALA,MAX,auxiliar->

pico2/ESCALA,MAX);

line(auxiliar->

pico2/ESCALA,MAX,auxiliar->

lim _ sup/ESCALA,MIN);

setcolor(WHITE);

setcolor(RED);


92

if (auxiliar>=da && auxiliar <=da+(ra-

l) )

}

}

line(a111te[auxiliar->var]

/ESCALA,MIN,ante[auxiliar->

var]/ESCALA,MAX);

else

line(conse[auxiliar->var]

/ESCALA,MIN ,conse[ auxiliar->var]

/ESCALA,MAX);

setcolor(WHITE);

if( auxiliar! =da+( ra-1) &&

auxiliar!=dc+(rc-1))

{

}

else

auxiliar++;

fijo_aux++;

break;

void despliega(int sin_opciones)

{

int opcion;

if(sin _ opciones'==O)

{

auxiliar-de;

fijo_aux=fijo_,;on;

setfillstyle(SOLID _FILL,LIGHTGREEN);

}

desp _ funciones();

Listado

bar(50, 140,400, 150);


outtextxy( 100, 142, "<ENTER>

Revisar Funciones");

setcolor(WHITE);

if (sin_ opciones== l )

{

auxiliar=dc;

fijo_aux=fijo_con;

do

{

desp _ funciones();

setfillstyle(SOLID _ FILL,LIGHTGREEN);

bar(50, 140,400, 150);


outtextxy(52,142,"<ESC> Regresar <AR>

Recorrer Funciones");

setcolor(WHITE);

opcion=bioskey(O );

if( opcion/256== AR)

{

if( auxiliar==da+( ra-1))

{

}

auxiliar-de;

fijo_aux0=fijo_con;

else

{

if( auxiliar==dc+( rc-1))

{

auxiliar=da;

fijo_aux=fijo_ant;

}

93

}

}

}

while( opcion/256 ! =ESC);

}

}

void dibuja_resultado(void)

{

int x,y;

char lirn [20];

if( transcurrido==O)

{

view _port(2);

clearviewport();

ejes();

}

view _port(2);

setcolor(YELLOW);

x = x_ant+30;

y=

(posicion+(posicion _ rnaxirna/2) )*

escala _ _pos;

y= 200-y;

if (y< O) y--0;

if (y > 200) y=0200;

if (transcurrido==O)

{

pos_x=x;

pos_y=y;

}

line(pos _ x,pos_y ,x,y);

pos x=x· - ,


pos_y=y;

setcolor(C:'Y'Al'J);

x = x_ant+30;

y=

( velocidad+( velocidad_ maxima)) *

escala_ vel ;

y= 200-y;

if (transcurrido==())

{

vel x=x· - ,

vel_y=y;

}

line(vel_x,vel_y,x,y);

vel_x=x;

vel_y=y;

setcolor(MAGENTA);

x = x_ant+30;

y= (fuerza+(fuerza_maxima))*escala_ fuer;

y= 200-y;

if (transcurrido-=<>)

{

fue x=x· - ,

fue_y=y;

}

line(fue_x,fue_y,x,y);

fue_x=x;

fue_y=y;

transcurrido+=h;

x _ ant+=escala _ x;

setfillstyle(SOLID __ Fll.L,BLAC:K);

bar( 190, 190,250, 199);

94

}

setcolor(WIIlTE);

sprintf (lim, "%.2f' ,tiempo);

outtextxy(50, 190,"Sim: ");

outtextxy (90, 190,lim);

sprintf (lim, "%.2f' ,transcurrido);

outtextxy(l50J90,"Tra: ");

outtextxy (190,190,lim);

sprintf (lim, "%d" ,cont_gener);

outtextxy(300, 190, "C:ont: ");


void dibujo_pendulo (void)

{

int x,y.z;

char lim[IO];

view _port( 1 );

clearviewport();

setfillstyle(SOLID _ FILL,LIGHTRED);

bar(79, 140, 100, 150);

setcolor(LIGHTC:'Y' AN);

setlinestyle(0,0,3 );

x=90+longitud*sin(posicion);

y= 140-·longitud*cos(posicion);

line(x,y, 90, 139);

setlinestyle( 1,0, l );

setcolor(LIGHTGRA 'Y');

line(90, 100,90, 140);

setlinestyle(O,O, 1 );

setcolor('Y'ELLOW);

sprintf (lim, "%. 2f %.2f',

posicion, radian _grado(posicion)) ;

outtext>,')'(0, l O," Ang: ");


Listado

}

setcolor(CY AN);

sprintf (lim, "%.2f', velocidad);

outtextxy(0,20, "Vel: ");

outtextxy ( 40,20,lim);

setcolor(MAGENT A);

sprintf (lim,"%.4f' ,fuerza);

outtextxy(0,30,"fue: ");


setcolor(WfilTE);

sprintf (lim, "o/od o/od" ,ante[O],ante[ 1 ]);

outtextxy(0,40, "a: ");


sprintf (lim, "o/od" ,conse[O]);

outtextxy(0,50,"con ");

outlex1xy (40,50,lim);

void despliega_ en _grafica()

{

int i,opcion;

char lim[40];

opcion=O;

view _port(2);

clearviewport();

for(i=O;i<m;i+=3)

{

sprintf (lim,"o/od ~;,(! %d o/od o/od %id"

,r[i J. id,da[ r[i J .id]. membresia,

r[i+ 1 J.id,da[r[i+ l].id].membresia,

r[i+ 2 J .id,dc[ r[ i+ 2]. id]. membresia);

outtextxy (0,opcion,lim);

opcion+=8;

95

}

}

void despliega_ dos()

int i;

for(i=O;i<m;i=i+ 3)

printf("o/od o/cd o/od\n"

,r[i].id,r[i+ 1 ].id,r[i+ 2). id);

}

getch();

}

A.6 Genetico.c

#include <stdio.h>

#include <stdlib.h>

#include <math. h>

#include <conio.h>

#include <graphics.h>

#include <time.h>

#include <bios.h>

#include "estruct.h"

void despliega(int sin_opciones);

#include "cld-g.h"

#include "grafica.h"

#include "operaclor.h"

char *intextxy (int x, int y);

#include "pendulo.h"

char *intextxy (int ,:, int y)

{

}

static char buffer[80), *cp;

cp= buffer;

do

{

do

}

{

*cp= getch ();

}

while (!isascii(*cp));

if (*cp==BS)

{

}

else

if (buffer!=cp)

{

setcolor (BLACK);

cp--;

outtextxy(x+S*(cp-buffer),y,cp);

}

if (*cp!='\r')

{

*(cp+l)= O;

setcolor (\\'HITE);

outtextxy(x+S*(cp-buffer),y,cp);

cp++;

}

while (*cp!='\r');

*cp= O;

return (buffer);


96

void nombres(void)

{

}

char lim [12);

int i;

char *aux;

view _port( 4 );

clearviewport();

setcolor(YELLOW);

outtextxy(200,50,"Nombre del Archivo de

Trabajo");

setcolor(WH11E);

outtextxy(l50, 150,"Nombre: ");

aux = intextxy(250, 150);

i=O;

do

{

}

nombre[i++] ,= *aux;

aux++;

while(*aux!=O);

void parametros()

{

int op;

char lim [12);

do

view _port( 4);

clearviewport() ;

setcolor(YELLOW);

Listado

outtextxy(200,50, "P ARAMETROS (No acepta

negativos)");

setcolor(WIIlTE);

outtextxy(200,100,"l) Longitud del

pendulo");

sprintf (lim, "%.2f' ,l);

outtextxy( 400, l 00,lim);

outtextxy(200, 120, "2) Masa del pendulo");

sprintf (lim,"%.2f",m);

outtextxy( 400, 120,lim);

outtextxy(200, 140, "3) Tiempo de

simulacion");

sprintf (lim, "%.2f',tiempo );


outtextxy(200,160,"4) #degeneraciones");

sprintf (lim, "o/od" ,generacion);


outtextxy(200, 180,"5) Prob. de crossover");

sprintf (lim, "o/od" ,pcruce );


outtextxy(200,200, 116) Prob. de mutacion");

sprintf (lim, "%d" ,pmutacion);

outtextxy( 400,200, lim);

outtextxy(200,280, "O) Salir");

outtextxy(l50,330,"Escoja el paramctro a

cambiar");

op=getch();

outtextxy(l50,400,"De el nuevo valor: ");

switch(op)

{

case 'l': l = atof(intextxy(350,400));

break;

case '2' : m = atof(intextxy(350,400));

97

break;

case '3' : tiempo= atof(intextxy(350,400));

break;

case '4' : generacion = (int)

atof(intextxy(350,400));

break;

case '5' : pernee = (int)

atof( intextxy(3 50, 400));

break;

case '6' : pmutacion = (int)

atof(intextxy(350,400));

break;

}

}

while(op!='O');

}

void main (voicl)

{

int op;

inicializa _graficas();

settextjustify (LEFT _ TEXT, TOP_ TEXT);

settextstyle(DEFAill.. T _FONT,HORIZ_DIR, l);

do

{

view_port(4);

clearviewport();

setcolor(YELLOW);

outtextxy(50, 15,"0ptimizacion de las

Funciones de Membresia de un


Controlador Difuso");

outtextxy(200 ,3 5, 11 mediante Algoritmos

Geneticos");

setcolor(WHITE);

outtextxy(lO,l00, 11 Archivo de trabajo:");

outtextxy(l 80, 100 ,nombre);

outtextxy(200, 150," l) Archivo");

outtextx-y(200, 190, "2) Pararnetros"):.

outtextxy(200, 230, "3) Simulacion ");

outtcxtxy(200,270, "4) Salvar");

outtextxy(200,350, "O) Salir");

op=getch();

switch(op)

{

case 'l' : nombres();

break;

case '2' : parametros();

break;

case '3' : if (strcmp(nombre, "")!=O)

{

informacion();

creacion();

read_ruleset();

fijo();

generacion _genetico();

evaluacion();

bar(50, 140,400, 150);


outtextxy(l30,142,"F IN");

setcolor(WHITE);

getch();

break;

}

98

el:;e

{

}

setcolor(LIGHTRED );

outtextxy(l70,400, 11NO SE HA

DEFINIDO UN NOMBRE

DE TRABAJO");

outtextxy(200, 4 20, 11 Apriete

una tecla para contnuar");

setcolor(WHITE);

getch() ;

break;

case '4' : gencracion_binario();

final();

}

}

break;

while( op!='O');

closegraph();

exit(O);

}

Apéndice_B

B. Optimización de Reglas mediante Algoritmos Genéticos

En este apéndice se describe la continuación natural del trabajo presentado hasta el momento, la

optimización de las reglas de un Controlador Difuso mediante Algoritmos Genéticos; se presenta

como caso de prueba el péndulo invertido simple y se le compara con el controlador optimizado

obtenido en el Capítulo 6.

B.1 Diseño del Algoritmo Genético

Para resolver este problema solamente se necesita cambiar la forma en que son representadas los

elementos o individuos del Algoritmo Genético, la forma de evaluar a dichos elementos sigue

siendo la misma que se presentó en el Capítulo 5.

En este caso, el primer individuo consiste en la concatenación de las 25 funciones de membresía

consecuentes correspondientes a las reglas del Controlador Difuso original; esta codificación la

podemos observar en forma gráfica en la figura B-1. Cada función de membresia de la variable

consecuente es representada por un número, que para los demás miembros de la población se

genera en forma alt::atoria.


Elemento

si velocidad es NM y Posición es PC fuerza es

si velocidad es CE y Posición es NC fuerza es

si velocidad es PC y Posición es CE fuerza es

si velocidad es PM y Posición es NM fuerza es

Fig B-1 Elemento de la población

B.2 Resultados

En la figura B-2 se presenta el desempeño del controlador oriiginal, que como se observó en el

capítulo 6 no controla al péndulo en ninguno de los casos de prueba. 0,4

0,3

0,2

0,1

Angulo (radianes) o

-0, 1 0,5

-0,2

-0,3

-0,4

Tiempo (segundos¡

Fig B-2 Desempeño del controlador original

Después de que el Algoritmo Genético actúa, la base de reglas final con la que se tiene el mejor

desempeño del controlador se muestra en la figura B-3.

100

Optimización de reglas mediante Algoritmos Genéticos

Velocidad Angular

r NG NC CE PC

NG PG NG NG NC

PG' ---------------------------tj}

CE

NC NG NC NG NC Posición

CE CE PG CE CE NG tt

PC PG CE PG PG

PG PG PC NG PG '-

Fig B-3 Reglas optimizadas

Con esta base de reglas optimizadas el desempeño del controlador en los casos de prueba se

muestra en la figura B-4.

0.6

0.4

·¡-CII 0.2 e 1'11 :a

1'11 o .:. o 1.5 2 2.5 3 ':i g> -0.2 •:(

-0.4

-0.6

Tiempo (segundos)

Fig B-4 Desempeño del controlador con reglas optimizadas

Ahora, teniendo esta nueva base de reglas se optimizan la.s funciones de membresía. Los

resultados obtenidos se muestran en la figura B-5 y las funciones de membresía correspondientes

se muestran en la figura B-6.

101


0.6

0.4

'" :~ 0.2 I~ ;; 1; o +--=-§,;;-=--,------,.------------¡----() /o.i; ]~ -0.2 / e: / /

1.5 2 2.5 3

c:i: -0.4

-0.6

Tiempo (segundos)

Fig 11-5 Desempeño del controlador con funciones de membresía optimizadas

Fig B-6 Funciones de membresía del controlador con reglas 01>timizadas

Como podemos observar en la figura B-5, la respuesta del controlador no es simétrico aunque las

funciones de membresía sí lo son, esto puede ser corregido restringiendo al Algoritmo Genético a

generar soluciones con reglas simétricas. Con este objetivo en mente, el desempeño del

Controlador Difuso con las funciones de membresía originales y una base de reglas optimizadas y

simétricas se muestra en la figura B-7.

102

Optimización de reglas mediante Algoritmos Genéticos

0.6

0.4

¡¡¡ ! 0.2

i o.1---\,.~~~~~-~º/~:~v_º_\~~~r=====+====:::::: ~ .5 1 1.5 2v 2.5 g' -0.2 ce

-0.4

-0.6

Tiempo (segundos)

Fig B-7 Controlador con reglas simétricas optimizadas

Las reglas simétricas las podemos observar en la figura B-8.

Velocidad Angular

NG NC CE PC

NG NC PG NG CE

NC PC NG NG CE Posición

CE NC PG CE NG

PC PC CE PG PG

PG PC CE PG NG

Fig B-8 Reglas simétricas optimizadas

3

El desempeño del Algoritmo Genético se muestra en la figura B-9, el primer punto de la figura es

el valor de aptitud del controlador original, así vemos que el error disminuye hasta estabilizarse.

103


o.6 T 1

0.5

0.4

g 0.3 w

0.2

0.1 ¡ 1

o J +---------·- --- --¡- - - - -·-··- - --+-

1 11 21 31

Generaciones

Fig B-9 Desempeño del Algoritmo Genético al opt1imizar las reglas

Teniendo este nuevo Controlador Difuso con reglas optimizadas simétricas, la optimización de las

fimciones de membresía nos da un Controlador con un desempefio simétrico que se muestra en la

figura B-1 O, las funciones de membresía correspondientes se mue,stran en la figura B-11.

0.4,

0.3 ·1l\ \ \ \ \

0.2 r \'\ ] ' \ \

; 0.1 ·1 \ \

~ o - ---·-~*\.c¡;;J,--~-=-=-1',==~

~ -0.1 t ;·· /).5 1.5 2

g, 1 / /

<t -0.2 1 /

1 / /

I j • -o.3 r I -o.4 V

Tiempo (segundos)

2.5 3

Fig B-10 Desempeño del controlador con reglas y funciones simétricas

Si observamos esta figura y el desempeño del controlador simétrico obtenido en el Capítulo 6

podemos damos cuenta que el controlador con las reglas y fimciones optimizadas tiene un mejor

desempeño, este es aproximadamente un segundo más rapido que el controlador con fimciones

simétricas.

104

Optimización de regl3S mediante Algoritmos Genéticos

Fig H-11 Funciones de membresía simétricas

105

Ajuste de controladores difusos mediante algoritmos genéticos

Documents

Transcript of Ajuste de controladores difusos mediante algoritmos genéticos