“OPTIMIZACIÓN DE CONTROLADORES DIFUSOS POR MEDIO DE ...148.206.53.84/tesiuami/UAMI10730.pdf ·...

UNIVERSIDAD AUTÓNOMA METROPOLITANA UNIDAD IZTAPALAPA

CIENCIAS BÁSICAS E INGENIERÍA

“OPTIMIZACIÓN DE CONTROLADORES DIFUSOS

POR MEDIO DE ALGORITMOS GENÉTICOS”

LICENCIATURA EN COMPUTACIÓN

Por

Noé Palmerin Ceja

José Guillermo Vázquez Juárez

Asesor

Dr. John Goddard Close

Firma del asesor México DF a 16 de noviembre de 2003

UNIVERSIDAD AUTÓNOMA METROPOLITANA

2

La mayoría de las ideas fundamentales de la ciencia son esencialmente

sencillas y, por regla general pueden ser expresadas en un lenguaje

comprensible para todos...

Einstein, Albert

La ciencia se compone de errores, que a su vez

son los pasos hacia la verdad.

Verne, Julio


3

ÍNDICE

INTRODUCCIÓN:...........................................................................................5

CAPITULO I. CONTROLADORES DIFUSOS..................................................7

1.1 BREVE HISTORIA.......................................................................................7

1.2 LÓGICA CLÁSICA........................................................................................9

1.3 DEFINICIÓN DE LA LÓGICA DIFUSA..............................................................10

1.4 FUNCIONAMIENTO....................................................................................11

1.5 EJEMPLO DEL VENTILADOR. ......................................................................12

1.5.1 Reglas lingüísticas. .........................................................................12

1.5.2 Fusificación. ...................................................................................16

1.5.2 Defusificación. ................................................................................17

CAPÍTULO II. APLICACIONES DE CONTROLADORES DIFUSOS..............19

2.1 PÉNDULO INVERTIDO. ..............................................................................19

2.1.1 Descripción del Problema. ...............................................................19

2.1.2 Controlador difuso. .........................................................................20

2.1.3 Programa........................................................................................21

2.2 ESTACIONAR UN CAMIÓN ...........................................................................22

2.2.1 Descripción del problema. ...............................................................22


2.2.3 Programa........................................................................................24

2.3 ATERRIZAR UN AVIÓN (AIRCRAFT ) ...............................................................26



2.1.3 Programa........................................................................................30

CAPÍTULO III. ALGORITMOS GENÉTICOS............................................... 33


4

3.1 BREVE HISTORIA.....................................................................................33

3.2 DEFINICIÓN . ...........................................................................................33

3.3 TERMINOLOGÍA. ......................................................................................35

3.4 PARTES QUE COMPONEN UN ALGORITMO GENÉTICO.......................................36

3.5 ALGORITMOS GENÉTICOS TIPO MESSY. ........................................................38

3.4 EJEMPLOS SOBRE FUNCIONES MATEMÁTICAS. ..............................................39

3.4.1 Función sobre 2 dimensiones. .........................................................39



CAPÍTULO IV. APLICACIONES DE ALGORITMOS GENÉTICOS SOBRE

CONTROLADORES DIFUSOS..................................................................... 43

4.1 ESTACIONAR UN CAMIÓN ...........................................................................43



4.1.3 Algoritmo Genético ..........................................................................45

4.1.4 Funcionamiento del programa.........................................................48

4.1.5 Resultados de la simulación. ..........................................................58

CONCLUSIONES......................................................................................... 67

APÉNDICE A. DIAGRAMA DE CLASES...................................................... 69

ESTACIONAR UN CAMIÓN.................................................................................69

APÉNDICE B. CÓDIGO FUENTE ................................................................ 73

ESTACIONAR UN CAMIÓN.................................................................................73

BIBLIOGRAFÍA:........................................................................................ 124


5

INTRODUCCIÓN:

La inteligencia artificial es sin duda una de las ramas más prometedoras de

las ciencias computacionales, sus metas y logros no sólo alcanzan, sino que

en muchas ocasiones, rebasan a la ciencia ficción; al tiempo que se escribe el

presente trabajo, el desarrollo de computadoras más poderosas

(supercomputadoras, microcomputadoras, computadoras de bolsillo, etc.) y

los logros sorprendentes en materia de inteligencia artificial parecen no tener

límites. Estos avances que a su vez se aplican cada día más en tecnologías

complejas tales como tecnología aeroespacial, robótica, genética, etc. motivan

el estudio que llevaremos a lo largo del presente trabajo.

El mundo que comprende el estudio y desarrollo de la inteligencia artificial

es, como es de esperarse, un universo tan amplio que puede justificar

investigaciones de maestría y doctorado. Nosotros a continuación solo

trabajaremos con dos estrategias, e intentaremos mezclar ambas esperando

obtener lo mejor de cada una, en una tercera.

Las estrategias con las que trabajaremos son “Controladores difusos” y

“Algoritmos genéticos”, una vez cubiertas estas técnicas y comprobada su

efectividad, intentaremos realizar una mezcla de ambas y comprobar su

eficacia para la resolución de problemas.

La lógica difusa ha demostrado ser una herramienta no sólo poderosa sino

además “sencilla”; sencilla comparada con la complejidad de los problemas

que puede resolver. Aunque más adelante explicaremos a detalle el

funcionamiento de esta técnica, nos gustaría resumir su comportamiento con

la siguiente idea: “su objetivo es dar soluciones como funciones continuas a


6

problemas que en un principio, no lo son”, en especial por la naturaleza de

estos problemas que son mas que nada basados en reglas lingüísticas bien

conocidas, es decir, el problema en su forma original puede expresarse en

lenguaje coloquial usado por nosotros los humanos. Por ejemplo, la

descripción de nuestro problema puede ser redactado de manera tan natural

como sigue: “Deseo controlar un ventilador que cuando el ambiente esté

caliente gire muy rápido, cuando esté templado gire de manera normal y

cuando el clima sea frío gire de manera muy lenta”.

En la lógica difusa, a partir de esta sencilla oración podemos construir un

modelo matemático; este modelo nos define el comportamiento del ventilador

como función de la temperatura, podemos complicar las instrucciones tanto

como deseemos agregando más variables como humedad, presión

atmosférica, etc.

Los algoritmos genéticos se utilizan para lograr la optimización de funciones

complejas, el ejemplo más sencillo que nos muestra esto, es encontrar el

máximo de una función en un intervalo dado.

Los algoritmos genéticos se basan en la selección natural que se lleva a cabo

en los seres vivos, de ahí surge su nombre. Como su explicación no es tan

sencilla como la de los controladores difusos, dejaremos la misma para mas

adelante en su capítulo correspondiente.

Nuestro objetivo es modelar un controlador difuso de manera que pueda ser

optimizado por un algoritmo genético. Es así como le damos nombre a

nuestro proyecto de investigación: “Optimización de Controladores Difusos

por medio de Algoritmos Genéticos”


7

CAPITULO I. CONTROLADORES DIFUSOS.

1.1 Breve Historia.

Cuando en 1965 el Dr. Lotfi A. Zadeh, publicó su artículo "Conjuntos

difusos" en la revista científica “Information and Control” estaba naciendo a

los ojos del mundo la Lógica Difusa. En dicho artículo describía a través de la

teoría matemática de conjuntos, cómo poder trabajar matemáticamente con

expresiones imprecisas, tal como lo hace el ser humano.

Todo comenzó con una broma. Un día el Dr. Zadeh se enzarzó con un amigo

en una larga discusión, cada uno consideraba que su mujer era más bonita

que la del otro; por supuesto no existe forma objetiva de medir la belleza.

Esta discusión despertó el deseo de Zadeh de lograr expresar numéricamente

conceptos difusos como "más bonita y menos bonita".

Las primeras aplicaciones de la teoría difusa fueron principalmente

industriales, tales como el control de procesos en fábricas de cemento. Más

tarde en 1987, se puso en servicio en Sendai, al Norte del Japón, el primer

metro controlado mediante Lógica Difusa. Los controladores basados en esta

lógica, hicieron mucho más confortables los viajes en Metro, gracias a las

suaves frenadas y aceleraciones.

A partir de 1990 se la comienza a aplicar en los controles de inyección

electrónica de carburante y en los sistemas de control de guiado automático

de coches, haciendo los controles complejos más eficientes y fáciles de

utilizar.


8

En estos momentos las grandes multinacionales de la industria automotriz,

de los electrodomésticos y la óptica están aprovechando en sus desarrollos

los espectaculares beneficios de esta técnica.

Se ha aplicado en acondicionadores de aire, pues ahorra energía dado que

comienza a enfriar con mayor potencia solo cuando un sensor detecta la

presencia de personas en la habitación, permaneciendo hasta entonces en

una situación prácticamente de "stand-by".

En las actividades domésticas cotidianas se inventó un sistema de

ventilación. Utiliza control difuso para conmutar un ventilador según los

conocimientos de cantidad de polvo, olores, temperatura y humedad

ambiente. Las lavadoras "Difusas" o "Fuzzy" tienen más de 400 ciclos

preprogramados; a pesar de su complejidad tecnológica resultan más fáciles

de operar que las lavadoras tradicionales. El usuario solo pone en marcha la

lavadora, el resto queda en manos del control difuso. Él evalúa

automáticamente el material, el volumen, la suciedad de la ropa, elige el ciclo

óptimo de lavado, así como el caudal de agua que ha de emplear.

Se ha empleado en los controles de cámaras de foto y vídeo, e incluso en

sistema de gestión financiera, en tratamientos de depuración de agua, en

control de robots, en detección y control de averías, y en un interminable

etcétera.

Con Lógica Difusa es posible elevar las funciones y capacidades de las

máquinas a niveles comparables al del ser humano. En cierto sentido se la

puede considerar "inteligencia artificial". El hemisferio izquierdo del cerebro

humano se utiliza para procesos lógicos, tales como leer y hablar, mientras el


9

hemisferio derecho es para mecanismos intuitivos y emocionales así como

procesamiento inconsciente de información. Los ordenadores convencionales

imitan la parte izquierda, mientras que la Lógica Difusa representa el papel

de la derecha.

En ajedrez por ejemplo, los jugadores realizan conclusiones instantáneas,

que a un ordenador convencional le llevaría horas calcular. Este

razonamiento tan avanzado es producto de la conjunción de esfuerzos de

ambas partes del cerebro.

Con estos pocos ejemplos, se pone de manifiesto que la Lógica Difusa abarca

un conjunto asombroso de aplicaciones. La Lógica Difusa puede aparecer

casi en cualquier lugar donde ordenadores y moderna teoría de control sean

necesariamente imprescindibles, así como en trabajos que requieran de la

delicada precisión humana y de su experiencia.

La Lógica Difusa es una herramienta imprescindible para el desarrollo de los

"hogares inteligentes" que veremos dar a luz en los próximos años.

1.2 Lógica clásica.

Un conjunto clásico es normalmente definido como una colección de

elementos u objetos x∈ X tal que puede ser finito, contable o no. Cada

elemento pertenece o no a un conjunto A, talque A ⊆ X. Es decir la sentencia

“x pertenece a A” es verdadera o falsa.

Un conjunto clásico puede ser descrito de distintos modos:


10

1. Se pueden listar los elementos de cada conjunto.

2. Se puede describir el conjunto analíticamente, estableciendo condiciones

de membresía ( A = { x | x < s }), o definir los elementos miembro usando la

función característica en la cuál 1 indica pertenencia y 0 no pertenencia.

En cambio para un conjunto difuso, la función característica, tiene varios

grados de pertenencia para los elementos de un conjunto dado.

1.3 Definición de la lógica difusa.

Si X es una colección de objetos denotados genéricamente por x, entonces un

conjunto difuso Â en X es un conjunto de pares ordenados:

Â = { (x, MÂ (x)) | x ∈ X }

MÂ(x) es llamada la función de o grado de membresía de x en Â, el cuál

mapea el espacio de membresía M. Cuando M contiene sólo 2 puntos, 0 y 1,

Â es no difuso y MÂ es idéntica a la función característica de conjunto no

difuso.

El rango de una función de membresía es un subconjunto de reales no

negativos cuyo máximo es infinito. Los elementos con un grado de

membresía normalmente no son listados.


11

1.4 Funcionamiento.

El diagrama que se presenta a continuación nos muestra las partes que

componen a un controlador difuso:

La base de reglas. Es un conjunto de reglas lingüísticas de forma IF-THEN

que definen el comportamiento que presenta el controlador difuso.

Mecanismo de inferencia. Toma las decisiones sobre que dato de entrada

debe enviarse al proceso que se desea controlar. La decisión se toma sobre la

base de reglas establecidas y el dato de entrada de referencia. El resultado

obtenido debe ser óptimo.

Fusificación. Convierte los datos de entrada para facilitar su uso y aplicación

de las reglas por el mecanismo de inferencia.


12

Defusificación. Convierte los resultados obtenidos por el mecanismo de

inferencia en valores apropiados para el proceso.

1.5 Ejemplo del ventilador.

Para facilitar la explicación de lo explicado anteriormente utilizaremos un

ejemplo sencillo, en el cual, se notan claramente cada una de las partes.

Dicho ejemplo es referente al control sobre un ventilador, basándose

únicamente en la temperatura ambiente.

1.5.1 Reglas lingüísticas.

La temperatura ambiente se encuentra en grados Fahrenheit y se ha dividido

en tres valores lingüísticos. COLD, WARM y HOT, para los cuales se han

definido funciones de fusificación como siguen (las funciones de fusificación

nos ayudan a cuantificar los valores lingüísticos y toman valores entre 0 y 1)

COLD

Consideramos la temperatura COLD en el intervalo que va de los 0 a los 25

grados, a partir de entonces nuestra certeza disminuye hasta convertirse en

0 a los 50 grados.


13

WARM

El intervalo en cual empezamos a considerar este valor de temperatura

comienza en los 40 grados, hasta alcanzar su punto máximo en 60 grados (es

decir la certeza de WARM es total, la función llega a uno), comenzando

inmediatamente a descender hasta llegar a cero en 80 grados.


14

HOT

Comienza su intervalo de crecimiento en 70, llegando a su certeza total en 85

grados y permaneciendo así hasta el rango máximo establecido para la

temperatura (100 grados Fahrenheit).

Para terminar esta sección hablaremos ahora de los valores lingüísticos de

salida. La velocidad del ventilador en nuestro caso; valor que llamaremos

FAN_SPEED. Los valores que se utilizan para las base de reglas son: SLOW

con un valor numérico de 15, MEDIUM con valor 50 y FAST con 75.


15

Una vez establecidos los valores lingüísticos y sus respectivas funciones de

fusificación procederemos a implementar las reglas que gobiernan nuestro

proceso (velocidad del ventilador). Considerando la temperatura como única

variable de entrada, contamos con las siguientes reglas:

if TEMPERATURE is COLD then FAN_SPEED is SLOW

if TEMPERATURE is WARM then FAN_SPEED is MEDIUM

if TEMPERATURE is HOT then FAN_SPEED is FAST

Al aplicar la simulación para el modelo descrito se presenta la siguiente

gráfica:


16

1.5.2 Fusificación.

Ahora realizaremos de forma manual algunos cálculos que se utilizan para el

controlador difuso, comenzaremos con la fusificación.

Nuestra variable de entrada en nuestro caso es la temperatura, suponemos

que entra una temperatura de 45 grados fahrenheit. Primero tenemos que

observar que reglas entran en acción. Para esto observamos la siguiente

figura:

40 50

COLD WARM HOT

0.25


17

Observamos que las reglas que entran en acción son:

if TEMPERATURE is COLD then FAN_SPEED is SLOW con valor de 0.25

if TEMPERATURE is WARM then FAN_SPEED is MEDIUM con valor de 0.25

1.5.2 Defusificación.

Ya que sabemos las reglas que están activas y el valor de cada una de ellas

procedemos a calcular el valor de salida correspondiente para esta entrada.

Utilizando el método del centro de gravedad de las áreas sombreadas

tenemos lo siguiente:

FAN_SPEED = (0.25*15+0.25*50)/(0.25+0.25) = 32.5

El software que se utilizó para la simulación cuenta con la opción para

generar las funciones en C del controlador difuso diseñado. Con las

0 10 20 30 40 50 60 70 80 90 100 0

1.0

0.25


18

funciones ya generadas se construyo en VISUAL C++ un programa que emula

el comportamiento del ventilador. El prototipo da las funciones que se

muestran a continuación.

int fld_fuzzy_inputs( int temperature)

int fld_fuzzy_outputs( int *fan_speed)


19

CAPÍTULO II. Aplicaciones de controladores difusos.

2.1 Péndulo Invertido.

El problema del péndulo invertido es un buen ejemplo de problemas que

pueden ser resueltos utilizando controladores difusos. A continuación

realizaremos una muy breve solución del problema. Primero comenzaremos

explicando el problema en si; y posteriormente su solución.

2.1.1 Descripción del Problema.

Consiste en mantener en equilibrio un péndulo colocado de manera inversa

sobre una plataforma.

Para lograrlo se considera la fuerza de gravedad, la longitud del péndulo y su

velocidad angular. Las ecuaciones que describen el movimiento del péndulo

son las siguientes:

dx1/dt = x2

dx2/dt = (g/l)sin(x1)-(l/ml2)u(t)

θ


20

Donde x1 es el ángulo (θ) x2 es la velocidad angular (dθ/dt) y u(t) es el torque

a aplicar para mantener el péndulo en equilibrio.

Como para ángulos en radianes muy pequeños sin(θ)=θ. Eligiendo l=g y

m=180/((·g2). Reemplazando esto en las ecuaciones originales tenemos.

x1(k+1)=x1(k)+x2(k)

x2(k+1)=x1(k)+x2(k)-u(k)

Nuestro universo de discurso para este problema será de –2( a 2( para el

ángulo y de –5gps a 5gps para la velocidad angular (gps = grados por

segundo).

2.1.2 Controlador difuso.

Para resolver el problema por medio de controladores difusos se construyen 3

funciones miembro para el ángulo: positivo (P), cero (Z) y negativo (N).

Similarmente utilizaremos 3 funciones miembro para la velocidad: positivo

(P), cero (Z) y negativo (N). La salida la dividimos en cinco funciones miembro

con un universo de discurso de –24 a 24. Todo esto se ilustra mejor en la

siguiente figura (figura2).

-24 –16 –8 0 8 16 24

NB N Z P PB

Torque -5 0 5

N Z P

Velocidad

-2 -1 0 1 2

N Z P

Angulo


21

2.1.3 Programa.

Para la simulación al problema del péndulo invertido se utilizó de nuevo el

software presentado anteriormente, al generar el código de C se corrigieron

algunos detalles, tales como cambiar las entradas y salidas de las funciones

de enteros a “doubles”, también se corrigieron codificó en Visual C++.

Las funciones que operan el controlador difuso se generaron con el software

FUZZY LOGIC DESIGNER corrigiendo las funciones de salida de rectángulos

a triángulos como en el diseño original. Otro cambio se realizó en las

funciones de evaluación de las reglas y en la función de salida, se cambiaron

los tipos enteros por flotantes.


22

2.2 Estacionar un camión.

Un problema más complejo dentro de la gama de los controladores difusos es

el estacionar un camión en reversa (back-upper).

2.2.1 Descripción del problema.

Para la solución del problema se cuenta con una posición y un ángulo inicial

y se debe obtener una trayectoria que nos lleve a una posición final con un

ángulo determinado.

Usamos las siguientes aproximaciones cinéticas ( ver Wang y Mendel ) :

x(t+1) = x(t) + cos[((t) + ((t)] + sen[((t)]*sen[((t)]

y(t+1) = y(t) + sen[((t) + ((t)] - sen[((t)]*cos[((t)]

(t+1) = ((t) - sen-1[(2*sen(((t))) / b]

Donde b es la longitud del camión ( es el ángulo del camión con respecto de

la horizontal y ( el giro del camión.

θ

φ


23


Asumimos b=4 en la simulación. Las ecuaciones anteriores se utilizan para

obtener el siguiente estado partiendo del presente, al realizar esto dentro de

un ciclo obtenemos la trayectoria que se debe seguir para lograr el objetivo

deseado. Para lograr la fusificación del problema no tomamos en cuenta la

variable y si no exclusivamente la posición x y el ángulo del camión.

Las funciones miembro de la posición x se muestran a continuación:

Las funciones miembro para el ángulo son las siguientes:

1.5 4 7 9 10 11 13 16 18.5 20

S2 S1 CE B1 B2

µ (x)

x

-90 –45 0 45 90 135 180 225 270

S3 S2 S1 CE B1 B2 B3

µ(φ)

φ


24

Por último las funciones miembro del ángulo de salida se definen:

Una vez definidas las funciones miembro para la fusificación y defusificación

tenemos las reglas lingüísticas dentro de una tabla, dichas reglas van a

definir el comportamiento del controlador difuso como sigue.

2.2.3 Programa

El conjunto proporciona todos los elementos necesarios para la generación

del controlador difuso. El cuál se utilizó para la creación de la simulación.

Primero mostramos la parte central del código que nos proporciona las

trayectorias que debe seguir el camión para lograr su objetivo.

Inmediatamente después se muestra una corrida del programa.

S3 S2 S1 CE B1 B2 B3

-40 –33 –20 –14 –7 –4 0 4 7 14 20 33 40

S2 S1 CE B1 B2S3 S2 S3S2 S2 S3 S3 S3S1 B1 S1 S2 S3 S2CE B2 B2 CE S2 S2B1 B2 B3 B2 B1 S1B2 B3 B3 B3 B2B3 B3 B2

x

Φ


25

void CTruckView::OnSimulacinComenzar()

{

// TODO: Add your command handler code here

double x,y,phi,Teta;

RPunto p;

while(Lista.GetCount()>0) Lista.RemoveTail();

Lista.AddTail(PuntoInicial);

Invalidate();

x=PuntoInicial.x;

y=PuntoInicial.y;

phi=PuntoInicial.teta;

wang_fuzzy_inputs(phi,x);

wang_fuzzy_outputs(&Teta);

while((x<PuntoFinal.x-1||x>PuntoFinal.x+1||

phi<PuntoFinal.teta||phi>PuntoFinal.teta+1)&& (y<PuntoFinal.y))

{

x=x+cos(phi*rad+Teta*rad)+sin(Teta*rad)*sin(phi*rad);

y=y+sin(phi*rad+Teta*rad)-sin(Teta*rad)*cos(phi*rad);

phi=phi*rad - asin((2*sin(Teta*rad))/b);

phi=phi*grad;

if (phi>270 && phi<= 360)

phi=phi-360;

if (phi>360)

phi=phi-360;

wang_fuzzy_inputs(phi,x);

wang_fuzzy_outputs(&Teta);

p.x=x;

p.y=y;

p.teta=phi;

Lista.AddTail(p);

}

Invalidate();

}


26

El resultado de la simulación es el siguiente:

2.3 Aterrizar un avión (Aircraft)

Otro problema que ilustra perfectamente la gama de usos de los

controladores difusos es el problema de aterrizar un avión (Aircraft). El

problema consiste en como lo indica su nombre, lograr un aterrizaje de

manera suave de una aeronave. Para analizar de manera fácil el problema

procederemos primeramente a explicar la teoría y ecuaciones del mismo.

Posteriormente, evaluaremos una primera solución con controladores difusos


27

con ciertas funciones miembro establecidas y por último una mejora del

mismo modificando las funciones miembro impuestas.


El problema se basa en conducir un aeroplano de una altura inicial hasta su

aterrizaje final. Conforme la altura disminuye acercándose al suelo, la

velocidad de descenso debe disminuir también hasta casi desaparecer por

completo (0 m/s) para lograr un aterrizaje suave sin ocasionar daño alguno.

Para la simulación debemos considerar las variables físicas que intervienen,

es decir, la altura del avión respecto del suelo y la velocidad vertical. La

salida del controlador es la fuerza que se debe aplicar al avión y que influye

directamente en las dos variables de entrada: altura y velocidad.

Las ecuaciones diferenciales de control se definen como siguen. Una masa

que se mueve con una velocidad v tiene un momento p = mv. Si a la masa no

se le aplica ninguna otra fuerza esta continuara su movimiento con la misma

velocidad y dirección. Si una fuerza f es aplicada en un intervalo de tiempo

∆t, se obtiene un cambio en la velocidad ∆v=f∆t/m. Si consideramos

h

v


28

∆t=1.0(seg) y m=1.0(lb-seg2/ft), obtenemos ∆v=f(lb), es decir, la fuerza

aplicada es directamente proporcional al cambio en la velocidad.

Cambiando la notación tenemos:

vi+1=vi+fi

hi+1=hi+vi

Donde vi+1 es nueva velocidad, vi es la antigua velocidad, hi+1 es la nueva

altura y hi es la veja altura.

Estas dos ecuaciones de control definen los nuevos valores de las variables

de estado que a su vez nos servirán para obtener del controlador el siguiente

valor de fuerza y así sucesivamente.


Una vez establecidas las ecuaciones, lo que necesitamos para resolver el

problema planteado utilizando los controladores difusos, es, generar las

funciones miembro para cada una de nuestras variables de entrada y de

nuestra variable de salida (h, v y f respectivamente).


29

Para la altura utilizaremos 4 funciones miembros distintas (NZ, S, M, y L)

representadas como sigue:

La velocidad cuenta con las funciones miembro (DL, DS, Z, US, y UL)

siguientes:

Y por último nuestra salida de control (la fuerza, DL, DS, Z, US, UL) consta

como sigue:

0 300 500 800 1000

NZ S M L

DL DS Z US UL

-20 –10 0 10 20

DL DS Z US UL

-20 –10 0 10 20


30

En base a esto construimos la siguiente tabla de reglas lingüísticas que

definen el comportamiento de nuestro controlador.

Al igual que en los ejemplos anteriores generamos el controlador difuso para

crear la simulación del problema. De todas maneras al final del presente

trabajo (en el apéndice) se encuentra el código completo de un controlador

difuso para mejor referencia.

2.1.3 Programa.

La simulación nos muestra una inexactitud en el diseño del controlador. A

una altura de aproximadamente 260 ft el avión no desciende, si no más bien

oscila realizando pequeños ascensos y descensos. Al observar el

comportamiento de las reglas que entran en acción en la simulación se

observa lo siguiente: al aproximarse el avión al suelo, con una velocidad de

descenso muy pequeña entra en acción la regla if VELOCITY is DS and

HEIGHT is NZ then FORCE is UL lo cuál no nos permite que el avión

descienda más.

Al detectar este problema, se decidió corregir el diseño del controlador, y más

aún, cambiar el problema por uno que nos permita estabilizar el avión en

DL DS Zero US ULL Z DS DL DL DLM US Z DS DL DLS UL US Z DS DL

NZ UL UL Z DS DS

Altu

ra

Velocidad


31

una altitud dada. Para esto la variable lingüística de HEIGHT (altura) se

toma como la diferencia que existe entre la posición actual del avión y la

altitud a la que se desea llegar. He aquí el nuevo diseño del controlador

difuso y su simulación:

-600 –400 –200 0 200 400 600

1.0

NL NS Z PS PL

HEIGHT

-30 –20 –10 0 10 20 30

1.0

DL DS Z US UL

VELOCITY

-30 –20 –10 0 10 20 30

1.0

DL DS Z US UL

FORCE


32

Y por último la simulación queda como se muestra a continuación.


33

CAPÍTULO III. ALGORITMOS GENÉTICOS

3.1 Breve Historia.

Los algoritmos genéticos (GA por sus siglas en inglés) fueron especificados

por John Holland a principios de los setentas. Actualmente se están

convirtiendo en una herramienta importante en las máquinas de aprendizaje

y las funciones de optimización. La base de los GA’s es la selección natural.

Para resolver una tarea de aprendizaje, diseño u optimización, un algoritmo

genético mantiene una población de “organismos” (bit strings) y

probabilísticamente modifica la población, tendiendo a una solución cercana

a lo óptimo para el problema dado. Tal vez aquí el único problema consiste

en adaptar las soluciones del problema a una cadena de bits.

GA’s es el principal método de búsqueda heurística para clasificar sistemas,

una especie de sistema de producción estocástico, se utiliza sobre problemas

combinatorios NP-DUROS, tales como optimización en enlace de redes y el

problema del agente viajero.

3.2 Definición.

Cuando son usados para funciones de optimización, un GA manipula una

población de cadenas usando operadores probabilísticos tipo genéticos, tales

como hacer parejas recombinadas de cadenas, a esta función se le conoce

“crossover” (cruzamiento); otra función similar pero que opera sobre una sola

cadena se llama “mutation” (mutación). Estas funciones producen una nueva

población que converge hacía la solución buscada. Los miembros de la

población actúan como una memoria primitiva para el GA y los operadores


34

genéticos actúan sobre ella para acercarse cada vez más a la solución

deseada. A diferencia de otros algoritmos de búsqueda, GA’s son bastante

rápidos sobre el hardware actual.

La estructura de estos programas es la siguiente:

Procedure evolution program

begin

t<-0

initialize P(t)

evaluate P(t)

while (not permutation_condition) do

begin

t<-t+1

select P(t) from P(t-1)

alter P(t)

evaluate P(t)

end

end

El GA es un algoritmo probabilístico que mantiene una población de

individuos P(t)={x1t,…,xnt} para la iteración t. Cada individuo representa una

solución potencia del problema a manejar, y en cualquier programa evolutivo

es implementado como alguna (posiblemente compleja) estructura de datos

S. Cada solución X; es evaluada para dar una medida de “fitness”. Entonces

una nueva población (iteración t+1) es creada seleccionando los individuos

más aptos (select step).Algunos miembros de la nueva población

experimentan transformaciones (alter step) por medio de “operadores

genéticos” para formar nuevas soluciones. Entre estos operadores se

encuentran las transformaciones unarias m; (mutation type), el cual crea un

nuevo individuo con un pequeño cambio en un sólo individuo (m: S -> S); en


35

un orden más alto en las transformaciones se encuentran los apareamientos

C; (crossover type), esta crea nuevos individuos combinando partes de varios

(2 o más) individuos (ej: Sx..xS -> S). Después de cierto número de

generaciones el programa converge, esto se espera puesto que un mejor

individuo representa una solución muy cercana a lo óptimo.

3.3 Terminología.

Para facilitar la lectura de los algoritmos presentamos la terminología que

usaremos y su significado:

Gene.- Bloques funcionales de DNA

Cromosoma.- Posible solución al problema y que se compone uno o varios

genes.

Trait.- Rasgos definidos por el gen.

Alleles.- Posibles valores que puede tomar un gen para definir sus

características.

Locus.- Posición del gene en el cromosoma

Genome.- Todos los genes juntos

Genotype.- Un particular conjunto de genes contenidos en un genome

Phenotype.- Son las características físicas ya dadas al individuo

Diploid.- Cromosomas en parejas

Haploid.- Cromosomas sin parejas

Recombination o Crossover.- Reproducción sexual

Gameto.- Surge del intercambio de una pareja de cromosomas entre dos

genes.

Mutation.- Reproduccion de cadenas de cromosomas haploides


36

Fitness.- (Adaptabilidad, Habilidad) La probabilidad de que el organismo

(viability) para reproducirse.

3.4 Partes que componen un algoritmo genético.

Ahora explicaremos las partes que componen un algoritmo genético.

Evaluate

Es, como su nombre lo indica, evaluar cada uno de los individuos de la

población en base a la función de habilidad (fitnesss), al realizar esta

evaluación se puede identificar el mejor elemento de toda la población.

Select

En base a su valor de fitness de cada individuo se genera, por decirlo así,

una ruleta que al girarla nos proporciona la nueva generación, obviamente

individuos que tienen un valor de fitness mayor tenderán más posibilidades

de ser seleccionados.

Elemento con más posibilidades


37

Crossover

O cruzamiento. Se toman parejas de elementos de la población y se

intercambian sus cromosomas, dando esto como resultado nuevos

elementos. Para decidir si una pareja se cruza o no, es en base a una

probabilidad, llamada probabilidad de cruzamiento.

Mutation

Cada individuo sufre una mutación en sus cromosomas, es decir, sus

cromosomas cambián tomando valores distinto resultando de esto un nuevo

individuo con nuevas habilidades. También la decisión de mutar o no un

individuo es por medio de una probabilidad denominada, probabilidad de

mutación.

Elitist

Toma los mejores elementos de la población y los sustituye por los peores

elementos (de ahí su nombre).

Estos pasos al ser repetidos constantemente nos van dando poblaciones

distintas, las cuales en general van mejorando su habilidad, por lo que el

mejor individuo de cada población es el que nos puede dar el resultado que

se busca.


38

3.5 Algoritmos genéticos tipo messy.

Recordemos brevemente el cruzamiento de cromosomas en los algoritmos

genéticos normales. Contamos con un par de cromosomas que contienen una

cantidad igual de genes; en este caso el cruzamiento de genes no nos

representa mayor problema. El cruzamiento se puede resumir como una

función que va de Rn->Rn con un número aleatorio de intercambios. Cuando

tenemos cromosomas que no contienen el mismo número de genes i.e. Rn ->

Rm con n<>m es donde encontramos que la definición anterior de

cruzamiento no nos es útil ya, y es donde necesitamos de los algoritmos

genéticos tipo messy. La pregunta obligada es ¿Dónde se utiliza este tipo de

cromosomas?

Hasta ahora hemos trabajado con la optimización sobre las funciones

miembro. Si intentáramos realizar lo mismo sobre las reglas, nos

encontraríamos el problema de que las reglas no representan un conjunto de

tamaño fijo; es decir, una regla puede tener involucrados cantidades

distintas de variables de entrada y de salida (genes); es precisamente el tipo

de problemas que resuelven los algoritmos genéticos tipo messy.

Los algoritmos genéticos (GA’s por sus siglas en inglés) fueron especificados

por John Holland a principios de los setentas. Se están convirtiendo en una

herramienta importante en las máquinas de aprendizaje y las funciones de

optimización. La base de los GA’s es la selección natural. Para resolver una

tarea de aprendizaje, diseño u optimización, un algoritmo genético mantiene

una población de “organismos” (bit strings) y probabilísticamente modifica la

población tendiendo a una solución cercana a lo óptimo el problema dado.


39

Tal vez aquí el único problema consiste en adaptar las soluciones del

problema a una cadena de bits.

3.4 Ejemplos sobre funciones matemáticas.

A continuación presentamos tres distintas corridas de un programa típico

basado en algoritmos genéticos que resuelve el punto máximo en un intervalo

cerrado y bien definido, junto con la solución a distintas ecuaciones, de una,

dos y tres variables respectivamente:

3.4.1 Función sobre 2 dimensiones.

La función de la cuál deseamos obtener un punto máximo es:

y(x)=x2*Sin(x)

Número de

generación Mejor valor Fitness Promedio

Desviación

estándar

1 6.492 2.816 0.920

2 6.492 35.579 27.096

3 6.492 56.302 11.378

. . . .

. . . .

. . . .

996 63.634 62.261 4.922

997 63.634 63.259 0.427


40

998 63.634 63.103 0.747

999 63.634 62.821 1.590

1000 63.634 61.768 0.863

simulation completed

best member:

var(0) = 8.100

63.634best fitness = 63.634

x*x*Sin(x)

-80

-60

-40

-20

0

20

40

60

80

0 2 4 6 8 10 12y(x)

Punto máximo


41



z(x,y) = x * Sin(y)

Número de


Desviación

estándar

1 9.775 6.520 2.326

2 9.949 7.268 1.933

3 9.949 7.637 2.191

. . . .

. . . .

. . . .

998 9.986 8.411 1.939

999 9.986 8.492 1.584

1000 9.986 8.503 1.475


best member:

var(0) = 9.990

var(1) = 1.600

best fitness=9.986

Área analizada

x

y


42



3) f(x,y,z) = x2 – x*y + z

Número de


Desviación

estándar

1 87.718 33.370 21.606

2 90.288 46.609 26.576

3 90.288 58.002 25.347

. . . .

. . . .

. . . .

998 109.281 77.607 16.570

999 109.281 76.972 17.463

1000 109.281 78.516 18.435


best member:

var(0)=9.980

var(1)=0.020

var(2)=9.880

best fitness=109.281


43

CAPÍTULO IV. APLICACIONES DE ALGORITMOS GENÉTICOS

SOBRE CONTROLADORES DIFUSOS.

4.1 Estacionar un camión.

Hemos trabajado hasta el momento con controladores difusos y algoritmos

genéticos por separado, en este capítulo realizaremos una optimización del

controlador difuso usando algoritmos genéticos. Para la optimización de las

funciones miembro utilizaremos algoritmos genéticos normales, pero para la

optimización de las reglas emplearemos algoritmos genéticos tipo messy


Trabajaremos con el problema de estacionar un camión en una posición X

dada (10 en este caso, aunque por medio de traslaciones podemos suponer

un punto cualquiera) y ángulo PHI de 90° respecto a la horizontal partiendo

con un ángulo y una posición iniciales.


El controlador difuso que nos resuelve el problema se encuentra

definido con las siguientes funciones miembro:

X

0

0.2

0.4

0.6

0.8

1

1.2

0 5 10 15 20 25


44

La tabla de reglas es la siguiente

PHI

0

0.2

0.4

0.6

0.8

1

1.2

-200 -100 0 100 200 300 400

TETA

0

0.2

0.4

0.6

0.8

1

1.2

-80 -60 -40 -20 0 20 40 60 80


45

y por último las ecuaciones que nos definen la posición del camión son las

siguientes:

( ) ( ) ( )θφθφ sinsinxx *cos +++=

( ) ( ) ( )φθθφ cos*sinsinyy −++=

4.1.3 Algoritmo Genético

La aplicación de los algoritmos genéticos sobre las funciones miembro se

utilizan de igual forma que con el ejemplo anterior. Hasta esta parte del

problema es sólo repetir lo hecho con anterioridad y no se encuentra

problema alguno en esta parte.

Ahora necesitamos aplicar la optimización por medio de los algoritmos

genéticos pero sobre las reglas; es aquí donde nos surgen varios problemas,

comenzando con la decisión sobre como representar las reglas y lograr que el

controlador difuso pueda evaluarlas.

Para resolver esto utilizaremos una matriz de 2 dimensiones donde el renglón

nos indique la variable y la columna el valor que toma el mismo, para dejar

más claro esto veamos el caso practico de nuestro problema PHI será nuestra

primera variable, los posibles valores de PHI son S3, S2, S1, CE, B1. B2. B3

correspondiéndole a S3 el valor de 1 a S2 el valor de 2 y así respectivamente;

para X tenemos S2, S1, CE, B1, B2 con los valores de S2=1, S1=2, CE=3,


46

B1=4, B2=5; y lo mismo para la variable de salida TETA. Hecha esta

codificación podemos entonces codificar las reglas como sigue:

(1,2) (2,4) (3,7)

Se traduce como

If PHI=S2 and X=B1 then TETA=B3

Es así como nos es posible expresar una base de reglas por completo

utilizando pares de números.

Podemos ahora trabajar con esta base y tratarla como un cromosoma

específico que defina el comportamiento de un individuo (el controlador

difuso), es decir, ahora para nuestro controlador difuso es posible definir en

forma variable no solo las funciones miembro si no también las reglas.

Nos enfrentamos ahora con otro problema; una regla no siempre tiene bien

definido el número de variables que intervienen en ella. Esto implica que dos

reglas (genes) pueden tener un tamaño distinto entre ellos. A continuación

damos un ejemplo de 2 posibles cromosomas válidos que se pueden

presentar en cualquier tipo de problema:

(1,2) (2,5) (3,7) (4,2) Cromosoma 1

(1,1) (3,3) Cromosoma 2


47

El cruzamiento normal en este caso obviamente no nos es útil; es ahí donde

tenemos la necesidad de recurrir a los algoritmos genéticos de tipo messy. En

este tipo de algoritmos la longitud de los cromosomas no necesita ser la

misma. El cruzamiento se efectúa por medio de 2 funciones llamadas cut y

slice.

Estas funciones están definidas como sigue:

CUT

Se refiere a elegir un número al azar sobre el cuál se va a cortar la cadena

que conforma el cromosoma

(1,2) (2,5) / (3,7) (4,2)

(1,1) / (3,3)

SLICE

Esta función se encarga de intercambiar las partes que se cortaron con la

función CUT, dando como resultado 2 individuos nuevos con la forma

siguiente:

(1,2) (2,5) (3,3)

(1,1) (3,7) (4,2)


48

Tenemos que considerar ahora la probabilidad de que en uno de los

cromosomas generados (o en ambos) se de la situación de elementos que con

valores distintos se refieren a una misma variable.

(1,2) (2,5) (3,3) (1,7)

Claramente existe aquí un conflicto con la definición de la primer variable

que debe (o puede) tomar los dos posibles valores, 2 o 7. En estos casos se

utiliza la sobreespecificación y se toma el primer elemento ignorando el

segundo valor; es decir, los cromosomas que se muestran a continuación son

equivalentes:

(1,2) (2,5) (3,3) (1,7)

(1,2) (3,3) (2,5)

Utilizando esta variación en los cromosomas y el método de cruzamiento

recién descrito es como se obtienen los resultados que se muestran en el

programa.

4.1.4 Funcionamiento del programa

Para explicar mejor el funcionamiento del programa lo presentamos a

continuación explicando cada opción del menú y el orden en que pueden

ejecutarse las cosas.


49

General

Opciones

Nos sirve para definir el comportamiento del algoritmo genético tanto para

las funciones de membresía como para las reglas.

Número de generaciones para funciones

Es la cantidad de generaciones hasta la cuál se detendrá el algoritmo

genético para obtener el mejor individuo en la optimización de las funciones

de membresía.


50

Número de individuos para las funciones

Se refiere al número de individuos que contendrá cada generación en la

optimización de las funciones de membresía.

Probabilidad de cruzamiento

Al realizar el cruzamiento de dos cromosomas puede especificarse que tan

probable sea que un par de cromosomas se crucen o no; esa probabilidad es

definida por esta variable. Sirve tanto para las funciones de membresía como

para las reglas.

Probabilidad de mutación

Un cromosoma es susceptible a intercambiar genes consigo mismo

(mutación), la probabilidad de que esto le ocurra a cada individuo es indicado

aquí.

Solo sirve para las funciones de membresía.

Tiempo máximo para lograr el objetivo.

Si el objetivo (estacionar el camón en este caso) no es alcanzado en una

cantidad menor al tiempo establecido, el individuo se la califica con la

puntuación más baja (fitness=0) para que tenga menores probabilidades de

subsistir a la siguiente generación. Sirve tanto para las funciones de

membresía como para las reglas.


51

Número de puntos iniciales.

El algoritmo genético trabaja, simulando el problema, obteniendo los

resultados y evaluando los mismos. Para esto la simulación necesita trabajar

con una posición X y un ángulo PHI iniciales. Si se simula solo sobre un

punto, el aprendizaje se efectuará sobre dicho punto, y no garantiza

resultados sobre otros. En cambio si se trabaja sobre varios puntos el

aprendizaje será más general y nos puede generar resultados no tan

específicos. Claramente podemos observar que entre mayor cantidad de

puntos se utilicen la obtención del mejor cromosoma es más lenta. Sirve

tanto para las funciones de membresía como para las reglas.

Número de generaciones para reglas


genético para obtener el mejor individuo en la optimización de las reglas.

Número de generaciones para las reglas


genético para obtener el mejor individuo en la optimización de las reglas.


52

Ver

Gráfica

Controlador original

Aquí podemos visualizar los valores de las funciones miembro del controlador

original.

Controlador generado

Aquí podemos visualizar los valores de las funciones miembro del controlador

generado. Si no se ha generado ningún cromosoma para las funciones

miembro no se permitirá esta operación.


53

Puntos iniciales

Los puntos iniciales que se emplearán para la simulación son desplegados

aquí. Se pueden modificar los datos que aparecen si desea optimizar sobre

algún punto específico.

Reglas

Muestra las reglas, original, generadas, o alguna en especial de la población

de reglas.

Simulación


54

Original

Muestra el comportamiento del camión con las funciones miembro y las

reglas originales.

Comenzar/Parar

Comienza o termina la simulación.

Reset

Devuelve el camión a su punto inicial para comenzar de nuevo con la

simulación.

Close

Cierra la ventana de simulación.

Intervalo

Especifica la velocidad con la que se efectúa la simulación, a valores más

grandes la simulación es más lenta. Por default tiene un valor de 100ms.


55

x

Establece la posición inicial del camión.

phi

Establece el ángulo inicial del camión.

Generada

Se utiliza de igual forma que la simulación original con la diferencia de que

las funciones miembro y las reglas que utiliza son las que se generaron con

los algoritmos genéticos.

Inicialmente los cromosomas “generados” se llenan con los cromosomas

originales, así es que si se inicia la simulación sin haber generado ni las

reglas ni las funciones de membresía obtenemos una simulación idéntica a la

original. Con esto lo que logramos es que se puede generar ya sea las reglas o

las funciones miembro en el orden que se desee para poder ir jugando con

los resultados. Es decir, podemos generar nuestros cromosomas en el orden

que deseemos y realizar las combinaciones que se nos ocurran.


56

Genéticos

Funciones miembro

Generar población

Es aquí donde se genera la población inicial sobre la cuál trabajará nuestro

algoritmo genético. La forma de generación es la siguiente: se toman

números aleatorios que pueden variar en un rango especificado, es decir se

establece el valor mínimo, el valor máximo, y los números que se generan se

encuentran en este intervalo.

Generar

Una vez establecido los rangos este botón genera la población que nos servirá

para crear el cromosoma.


57

Generar cromosoma

Establecida la población, calcula por medio de algortimos genéticos el mejor

individuo. Una vez creado este podemos observar su comportamiento en la

simulación y ver los valores que tiene en el menú Ver|Gráfica|Controlador

original.

Reglas

Generar población

Es aquí donde se genera la población inicial sobre la cuál trabajará nuestro

algoritmo genético. No necesitamos especificar nada, únicamente oprimimos

el botón Generar y listo.


58

Generar regla

Establecida la población, calcula por medio de algortimos genéticos el mejor

individuo. Una vez creado este, podemos observar su comportamiento en la

simulación y ver los valores que tiene en el menú Ver|Reglas.

Inicializa reglas y funciones

Se vacían los cromosomas generados y se llenan con los valores originales,

esto nos ayuda para poder seguir jugando con el orden de generación de los

individuos.

4.1.5 Resultados de la simulación.

A continuación se presentan dos ejecuciones de la simulación del camión; en

la primera se aplica el controlador difuso original, y en la segunda el

controlador difuso afectado por el algoritmo genético.


59

Cómo podemos observar, el controlador difuso por sí solo, es decir, sin tener

ninguna optimización de por medio, resuelve perfectamente el problema de

estacionar el camión a partir de un punto y un ángulo inicial.

Al aplicar la optimización a las funciones miembro y a las reglas se pueden

lograr mucho mejores resultados (como se puede apreciar en el dibujo

anterior) pero esto no sucede siempre, a continuación se muestran las

distintas combinaciones y resultados que obtuvimos al combinar

optimización de reglas y funciones miembro.

Todas las simulaciones se realizaron con un punto inicial x=0.0 phi=0.0, pero

en el programa (incluido en el CD) se pueden probar distintos punto iniciales.


60

4.1.5.1 Sin optimización alguna (Original).

Valores obtenidos

phi = 90.260

x = 9.974

y = 25.960

4.1.5.2 Optimizando sólo funciones miembro.

Valores obtenidos

phi = 89.870

x = 10.262

y = 10.146


61

Funciones miembro obtenidas de la optimización:


62

4.1.5.3 Optimizando sólo las reglas lingüísticas.

Valores obtenidos

phi = 89.671

x = 10.327

y = 22.268


63

Reglas lingüísticas obtenidas de la optimización:

4.1.5.4 Optimizando primero funciones miembro y luego reglas

lingüísticas.

Valores obtenidos

phi = 89.869

x = 10.146

y = 23.682

Funciones miembro y reglas lingüísticas obtenidas de la optimización:


64


65

4.1.5.5 Optimizando primero reglas lingüísticas y luego funciones

miembro.

Valores obtenidos

phi = 89.931

x = 9.968

y = 5.577

Reglas y funciones miembro obtenidas de la optimización:


66


67

CONCLUSIONES

Como observamos a lo largo del presente trabajo, las técnicas aquí

empleadas para desarrollar inteligencia artificial mostraron un

comportamiento más que optimo.

Los controladores difusos son una herramienta poderosa además de sencilla.

Las aplicaciones que desarrollamos se construyeron de manera rápida y

eficiente sin embargo, durante el desarrollo de la simulación del avión se

encontró que las reglas presentaban un pequeño error al momento de estar

el avión muy cerca de la tierra. Este error que corregimos nos demuestra que

los controladores difusos aunque son una herramienta excelente para la

automatización, son “perfectibles”.

Para algoritmos genéticos nuestras aplicaciones se limitaron a encontrar el

punto máximo de una función en un intervalo dado, la simpleza de este

problema (pero no por eso menos útil) nos permitió entender y dominar esta

técnica con el fin de alcanzar nuestro verdadero objetivo; aplicar esta

optimización a los controladores difusos, tanto a sus funciones miembro

como a sus reglas.

Encontramos que modelar un controlador difuso como un cromosoma no es

una tarea sencilla pero, si se realiza adecuadamente los resultados que se

pueden obtener son verdaderamente sorprendentes.

Para el problema en específico que decidimos atacar (estacionar un camión)

los resultados que obtuvimos en las diferentes pruebas y combinatorias que

hicimos nos permite asegurar que el controlador difuso alterado


68

“genéticamente” presenta un comportamiento más eficiente que el

controlador original.

El utilizar los algoritmos genéticos como “generadores” de “conocimiento”

para los controladores difusos, no solo es viable, sino que arroja resultados

eficientes.

De las distintas combinaciones de optimización que intentamos, tales cómo:

“solo las funciones miembro”, “primero las funciones miembro y luego las

reglas”, etcétera. La que arrojó mejores resultados es optimizar primero las

reglas lingüísticas y después las funciones miembro. Esta técnica logró

estacionar el camón 4.65 veces más rápido que el controlador original (25.96

vs 5.577). Gracias a esto podemos afirmar que el objetivo de optimización se

logró completamente y amplia el rango de posibilidades aún más allá de lo

que imaginamos.


69

APÉNDICE A. Diagrama de clases

El programa desarrollado donde se centra el esfuerzo del presente trabajo es

el de estacionar un camión, a continuación presentamos un diagrama de

clases de las partes principales que componen esta aplicación, tales como el

algoritmo genético y el controlador difuso. El programa se desarrolló por

completo en DELPHI. Para no complicar la documentación presentada se

muestran solo las clases principales que conforman el programa, el código

completo se encuentra en el CD anexo a este trabajo.

Estacionar un camión


70


71


72


73

APÉNDICE B. CÓDIGO FUENTE

A continuación se presenta el código fuente de las clases principales del

sistema del camión, estas clases corresponden al controlador difuso y al

algoritmo genético. Recordamos que en el CD anexo se encuentran todos los

códigos fuente de todos los programas que se elaboraron durante el presente

trabajo, algunos de ellos se encuentran en Visual C++ y algunos otros como

el del camión en DELPHI.

Estacionar un camión

TControladorDifuso

unit UControladorDifuso;

interface

Uses

UCromosoma,Classes,Ugeneral,Windows;

const

MIN_PHI = 0;

MAX_PHI = 1000;

MIN_X = -30;

MAX_X = 30;

OUT_S3 = -40;

OUT_S2 = -20;

OUT_S1 = -7;

OUT_CE = 0;

OUT_B1 = 7;


74

OUT_B2 = 20;

OUT_B3 = 40;

type

TControladorDifuso = class

public

//Resultados : array[1..5,1..7] of double;

constructor Create(iIndividuo:RCromosoma;iCromoRegla:TList);

procedure fld_fuzzy_inputs(phi,x:double);

procedure fld_fuzzy_outputs(var pout:double);

private

MatRes : array[1..3,1..7] of double;

Individuo : RCromosoma ;

Reglas : TList ;

result_PHI_S3 : double ;



result_PHI_CE : double ;

result_PHI_B1 : double ;



result_X_S2 : double ;

result_X_S1 : double ;

result_X_CE : double ;

result_X_B1 : double ;

result_X_B2 : double ;

result_OUT : double ;

sum_OUT : double ;


75

procedure eval_PHI_S3(phi:double);



procedure eval_PHI_CE(phi:double);

procedure eval_PHI_B1(phi:double);



procedure eval_X_S2(x:double);

procedure eval_X_S1(x:double);

procedure eval_X_CE(x:double);

procedure eval_X_B1(x:double);

procedure eval_X_B2(x:double);

procedure initialize_outputs;

procedure evaluate_rules;

procedure determine_outputs;

function FunctionAnd(fl1,fl2:double):double;

function Evaluate(a,b,c,d,v:double):double;

end;

implementation

constructor

TControladorDifuso.Create(iIndividuo:RCromosoma;iCromoRegla:TList);

begin

Reglas:=iCromoRegla;

Individuo:=iIndividuo;


76

//FillChar(Resultados,sizeof(Resultados),0);

FillChar(MatRes,sizeof(MatRes),0);

MatRes[3,1]:=OUT_S3;



MatRes[3,4]:=OUT_CE;

MatRes[3,5]:=OUT_B1;



end;

procedure TControladorDifuso.eval_PHI_S3(phi:double);

begin

result_PHI_S3:=Evaluate(Individuo.PS3a,Individuo.PS3b,Individuo.PS3c,Indiv

iduo.PS3d,phi);

MatRes[1,1]:=result_PHI_S3;

end;

procedure TControladorDifuso.initialize_outputs;

begin

result_OUT:=0;

sum_OUT :=0;

end;


77

procedure TControladorDifuso.evaluate_rules;

var

result : double ;

i : integer;

j : integer;

begin

for i:=0 to Reglas.Count-1 do

begin

result:=FunctionAnd(MatRes[PPoint(TList(Reglas[i])[0]).x,PPoint(TList(Reglas[i]

)[0]).y],1.0);

for j:=1 to TList(Reglas[i]).Count-2 do

begin

result:=FunctionAnd(MatRes[PPoint(TList(Reglas[i])[j]).x,PPoint(TList(Reglas[i])

[j]).y],result);

//Resultados[PPoint(TList(Reglas[i])[j]).x,PPoint(TList(Reglas[i])[j]).y]:=result;

end;

result_OUT:=result_OUT+result*MatRes[PPoint(TList(Reglas[i])[TList(Reglas[i])

.Count-1]).x,PPoint(TList(Reglas[i])[TList(Reglas[i]).Count-1]).y];

sum_OUT:=sum_OUT+result;

end; {}

(*

{/*------------------------------------------------------------------------

Rule 1

if PHI is S3 and


78

X is S2 then

OUT is S2

-------------------------------------------------------------------------*/}

result:=FunctionAnd(result_PHI_S3, 1.0);

result:=FunctionAnd(result_X_S2, result);

result_OUT:=result_OUT+result*OUT_S2;


{/*------------------------------------------------------------------------

Rule 2

if PHI is S3 and

X is S1 then

OUT is S3

-------------------------------------------------------------------------*/}

result:=FunctionAnd( result_PHI_S3, 1.0);

result:=FunctionAnd( result_X_S1, result);

result_OUT:=result_OUT+(result*OUT_S3);


{ /*------------------------------------------------------------------------

Rule 3

if PHI is S2 and

X is S2 then

OUT is S2

-------------------------------------------------------------------------*/}





79


{ /*------------------------------------------------------------------------

Rule 4

if PHI is S2 and

X is S1 then

OUT is S3

-------------------------------------------------------------------------*/}





{ /*------------------------------------------------------------------------

Rule 5

if PHI is S2 and

X is CE then

OUT is S3

-------------------------------------------------------------------------*/}


result:=FunctionAnd( result_X_CE, result);



{ /*------------------------------------------------------------------------

Rule 6

if PHI is S2 and

X is B1 then


80

OUT is S3

-------------------------------------------------------------------------*/}


result:=FunctionAnd( result_X_B1, result);



{ /*------------------------------------------------------------------------

Rule 7

if PHI is S1 and

X is S2 then

OUT is B1

-------------------------------------------------------------------------*/}



result_OUT:=result_OUT+(result*OUT_B1);


{ /*------------------------------------------------------------------------

Rule 8

if PHI is S1 and

X is S1 then

OUT is S1

-------------------------------------------------------------------------*/}






81

{ /*------------------------------------------------------------------------

Rule 9

if PHI is S1 and

X is CE then

OUT is S2

-------------------------------------------------------------------------*/}





{ /*------------------------------------------------------------------------

Rule 10

if PHI is S1 and

X is B1 then

OUT is S3

-------------------------------------------------------------------------*/}





{ /*------------------------------------------------------------------------

Rule 11

if PHI is S1 and

X is B2 then

OUT is S2


82

-------------------------------------------------------------------------*/}





{ /*------------------------------------------------------------------------

Rule 12

if PHI is CE and

X is S2 then

OUT is B2

-------------------------------------------------------------------------*/}

result:=FunctionAnd( result_PHI_CE, 1.0);




{ /*------------------------------------------------------------------------

Rule 13

if PHI is CE and

X is S1 then

OUT is B2

-------------------------------------------------------------------------*/}






83

{ /*------------------------------------------------------------------------

Rule 14

if PHI is CE and

X is CE then

OUT is CE

-------------------------------------------------------------------------*/}



result_OUT:=result_OUT+(result*OUT_CE);


{ /*------------------------------------------------------------------------

Rule 15

if PHI is CE and

X is B1 then

OUT is S2

-------------------------------------------------------------------------*/}





{ /*------------------------------------------------------------------------

Rule 16

if PHI is CE and

X is B2 then

OUT is S2

-------------------------------------------------------------------------*/}


84





{/*------------------------------------------------------------------------

Rule 17

if PHI is B1 and

X is S2 then

OUT is B2

-------------------------------------------------------------------------*/}

result:=FunctionAnd( result_PHI_B1, 1.0);




{ /*------------------------------------------------------------------------

Rule 18

if PHI is B1 and

X is S1 then

OUT is B3

-------------------------------------------------------------------------*/}





{ /*------------------------------------------------------------------------


85

Rule 19

if PHI is B1 and

X is CE then

OUT is B2

-------------------------------------------------------------------------*/}





{ /*------------------------------------------------------------------------

Rule 20

if PHI is B1 and

X is B1 then

OUT is B1

-------------------------------------------------------------------------*/}





{ /*------------------------------------------------------------------------

Rule 21

if PHI is B1 and

X is B2 then

OUT is S1

-------------------------------------------------------------------------*/}



86




{ /*------------------------------------------------------------------------

Rule 22

if PHI is B2 and

X is S1 then

OUT is B3

-------------------------------------------------------------------------*/}





{ /*------------------------------------------------------------------------

Rule 23

if PHI is B2 and

X is CE then

OUT is B3

-------------------------------------------------------------------------*/}





{ /*------------------------------------------------------------------------

Rule 24


87

if PHI is B2 and

X is B1 then

OUT is B3

-------------------------------------------------------------------------*/}





{ /*------------------------------------------------------------------------

Rule 25

if PHI is B2 and

X is B2 then

OUT is B2

-------------------------------------------------------------------------*/}





{ /*------------------------------------------------------------------------

Rule 26

if PHI is B3 and

X is B1 then

OUT is B3

-------------------------------------------------------------------------*/}




88



{ /*------------------------------------------------------------------------

Rule 27

if PHI is B3 and

X is B2 then

OUT is B2

-------------------------------------------------------------------------*/}





{ /*------------------------------------------------------------------------

Rule 28

if PHI is S3 and

X is CE then

OUT is CE

-------------------------------------------------------------------------*/}





{ /*------------------------------------------------------------------------

Rule 29

if PHI is S3 and


89

X is B1 then

OUT is S3

-------------------------------------------------------------------------*/}





{ /*------------------------------------------------------------------------

Rule 30

if PHI is S3 and

X is B2 then

OUT is S3

-------------------------------------------------------------------------*/}





{ /*------------------------------------------------------------------------

Rule 31

if PHI is S2 and

X is B2 then

OUT is S2

-------------------------------------------------------------------------*/}





90


{ /*------------------------------------------------------------------------

Rule 32

if PHI is B2 FunctionAnd

X is S2 then

OUT is CE

-------------------------------------------------------------------------*/}





{ /*------------------------------------------------------------------------

Rule 33

if PHI is B3 and

X is S2 then

OUT is S3

-------------------------------------------------------------------------*/}





{ /*------------------------------------------------------------------------

Rule 34

if PHI is B3 and

X is S1 then


91

OUT is S3

-------------------------------------------------------------------------*/}





{ /*------------------------------------------------------------------------

Rule 35

if PHI is B3 and

X is CE then

OUT is S2

-------------------------------------------------------------------------*/}




sum_OUT:=sum_OUT+result; (**)

end;

procedure TControladorDifuso.determine_outputs;

begin

if sum_OUT>0 then

result_OUT:=result_OUT/sum_OUT

else

result_OUT:=0;

end;

procedure TControladorDifuso.fld_fuzzy_inputs(phi,x:double);

begin


92

if( phi < MIN_PHI ) then

phi:= MIN_PHI

else

if( phi > MAX_PHI ) then

phi:= MAX_PHI;

if( x < MIN_X)then

x:= MIN_X

else

if( x > MAX_X) then

x:= MAX_X;

eval_PHI_S3(phi);

eval_PHI_S2(phi);

eval_PHI_S1(phi);

eval_PHI_CE(phi);

eval_PHI_B1(phi);

eval_PHI_B2(phi);

eval_PHI_B3(phi);

eval_X_S2(x);

eval_X_S1(x);

eval_X_CE(x);

eval_X_B1(x);

eval_X_B2(x);

initialize_outputs( );

evaluate_rules( );

determine_outputs( );

end;


93

procedure TControladorDifuso.fld_fuzzy_outputs(var pout:double);

begin

pout:=result_OUT;

end;

function TControladorDifuso.FunctionAnd(fl1,fl2:double):double;

begin

if( fl1 <= fl2 )then

FunctionAnd:=fl1

else

FunctionAnd:=fl2;

end;

procedure TControladorDifuso.eval_PHI_B1(phi: double);

begin

result_PHI_B1:=Evaluate(Individuo.PB1a,Individuo.PB1b,Individuo.PB1c,Indi

viduo.PB1d,phi);

MatRes[1,5]:=result_PHI_B1;

end;


begin


viduo.PB2d,phi);


end;


94


begin


viduo.PB3d,phi);


end;

procedure TControladorDifuso.eval_PHI_CE(phi: double);

begin

result_PHI_CE:=Evaluate(Individuo.PCEa,Individuo.PCEb,Individuo.PCEc,Ind

ividuo.PCEd,phi);

MatRes[1,4]:=result_PHI_CE;

end;

procedure TControladorDifuso.eval_PHI_S1(phi: double);

begin


iduo.PS1d,phi);


end;

procedure TControladorDifuso.eval_PHI_S2(phi: double);

begin


95


iduo.PS2d,phi);


end;

procedure TControladorDifuso.eval_X_B1(x: double);

begin

result_X_B1:=Evaluate(Individuo.XB1a,Individuo.XB1b,Individuo.XB1c,Indivi

duo.XB1d,X);

MatRes[2,4]:=result_X_B1;

end;

procedure TControladorDifuso.eval_X_B2(x: double);

begin

result_X_B2:=Evaluate(Individuo.XB2a,Individuo.XB2b,Individuo.XB2c,Indivi

duo.XB2d,X);

MatRes[2,5]:=result_X_B2;

end;

procedure TControladorDifuso.eval_X_CE(x: double);

begin

result_X_CE:=Evaluate(Individuo.XCEa,Individuo.XCEb,Individuo.XCEc,Indiv

iduo.XCEd,X);

MatRes[2,3]:=result_X_CE;


96

end;

procedure TControladorDifuso.eval_X_S1(x: double);

begin

result_X_S1:=Evaluate(Individuo.XS1a,Individuo.XS1b,Individuo.XS1c,Indivi

duo.XS1d,X);

MatRes[2,2]:=result_X_S1;

end;

procedure TControladorDifuso.eval_X_S2(x: double);

begin

result_X_S2:=Evaluate(Individuo.XS2a,Individuo.XS2b,Individuo.XS2c,Indivi

duo.XS2d,X);

MatRes[2,1]:=result_X_S2;

end;

function TControladorDifuso.Evaluate(a, b, c, d, v: double): double;

begin

Result:=0;

if (v<a) then

result:=0;

if (v>=a)and(v<b) then

result:=(1/(b-a))*(v-a);

if (v>=b)and(v<=c) then

result:=1;

if (v>c)and(v<=d) then


97

result:=(1/(c-d))*(v-d);

if (v>d) then

result:=0;

end;

end.

TFGenetico

unit UGenetico;

interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,

UCromosoma, UControladorDifuso, Math, ComCtrls, StdCtrls,

UGeneraPoblacion, Buttons, ExtCtrls;

type

TFGenetico = class(TForm)

GroupBox1: TGroupBox;

GroupBox2: TGroupBox;

ProgressBar1: TProgressBar;

ProgressBar2: TProgressBar;

BitBtn1: TBitBtn;

BitBtn2: TBitBtn;

Panel1: TPanel;


98

RadioButton1: TRadioButton;

RadioButton2: TRadioButton;

procedure FormCreate(Sender: TObject);

procedure FormShow(Sender: TObject);

procedure BitBtn1Click(Sender: TObject);

procedure BitBtn2Click(Sender: TObject);

private

rad : double;

grad : double;

generation : integer;

procedure crossover;

procedure elitist;

procedure EvaluaIndividuo(Individuo: PCromosoma);

procedure evaluate;

procedure keep_the_best;

procedure mutate;

procedure report(generation: integer);

procedure select;

procedure SwapGenes(var Gene1, Gene2: double);

procedure XOver(one, two: integer);

{ Private declarations }

public

{ Public declarations }

Generado : boolean;

procedure GeneraControlador;

end;

var


99

FGenetico: TFGenetico;

implementation

uses UGeneral, UGeneRegla;

{$R *.DFM}

procedure TFGenetico.FormCreate(Sender: TObject);

begin

rad:=pi/180.00;

grad:=180.00/pi;

Generado:=false;

end;

procedure TFGenetico.GeneraControlador;

begin

if FGeneral.Generacion.count=0 then

begin

Application.MessageBox('No se ha generado ninguna población

inicial.','Error',MB_ICONHAND or MB_OK);

exit;

end;

ProgressBar1.Max:=MAXGENS;

ProgressBar1.Position:=0;

generation:=0;

Generado:=false;

evaluate;


100

keep_the_best;

while (generation<MAXGENS) do

begin

inc(generation);

select;

crossover;

mutate;

report(generation);

evaluate;

elitist;

ProgressBar1.StepIt;

Application.ProcessMessages;

end;

Generado:=true;

MessageBox(handle,'El cromosoma ha sido

generado.','Genéticos',MB_ICONINFORMATION);

Close;

end;

procedure TFGenetico.evaluate;

var

Individuo : PCromosoma;

i : integer;

begin

ProgressBar2.Max:=FGeneral.Generacion.Count;


for i:=0 to FGeneral.Generacion.Count-1 do

begin


101

Individuo:=FGeneral.Generacion.Items[i];

EvaluaIndividuo(Individuo);

ProgressBar2.StepIt;

end;

end;

procedure TFGenetico.keep_the_best;

var

mem : integer;

cur_best : integer;


begin

cur_best:=0;

FillChar(FGeneral.BestIndividuo,SizeOf(FGeneral.BestIndividuo),0);

for mem:=0 to FGeneral.Generacion.Count-1 do

begin

Individuo:=FGeneral.Generacion[mem];

if (Individuo.fitness>FGeneral.BestIndividuo.fitness) then

begin

cur_best:=mem;

FGeneral.BestIndividuo.fitness:=Individuo.fitness;

end;

end;

Individuo:=FGeneral.Generacion[cur_best];

with FGeneral.BestIndividuo do

begin

PS3a:=Individuo.PS3a;

PS3b:=Individuo.PS3b;


102

PS3c:=Individuo.PS3c;

PS3d:=Individuo.PS3d;









PCEa:=Individuo.PCEa;

PCEb:=Individuo.PCEb;

PCEc:=Individuo.PCEc;

PCEd:=Individuo.PCEd;

PB1a:=Individuo.PB1a;

PB1b:=Individuo.PB1b;

PB1c:=Individuo.PB1c;

PB1d:=Individuo.PB1d;









XS2a:=Individuo.XS2a;

XS2b:=Individuo.XS2b;


103

XS2c:=Individuo.XS2c;

XS2d:=Individuo.XS2d;

XS1a:=Individuo.XS1a;

XS1b:=Individuo.XS1b;

XS1c:=Individuo.XS1c;

XS1d:=Individuo.XS1d;

XCEa:=Individuo.XCEa;

XCEb:=Individuo.XCEb;

XCEc:=Individuo.XCEc;

XCEd:=Individuo.XCEd;

XB1a:=Individuo.XB1a;

XB1b:=Individuo.XB1b;

XB1c:=Individuo.XB1c;

XB1d:=Individuo.XB1d;

XB2a:=Individuo.XB2a;

XB2b:=Individuo.XB2b;

XB2c:=Individuo.XB2c;

XB2d:=Individuo.XB2d;

end;

end;

procedure TFGenetico.select;

var

sum : double;

p : double;

mem : integer;


104

i : integer;

j : integer;


Individuo_1 : PCromosoma;

NewIndividuo : PCromosoma;

NewGeneracion : TList;

begin

NewGeneracion:=TList.Create;

sum:=0;


begin


sum:=sum+Individuo.fitness;

end;


begin


Individuo.rfitness:=Individuo.fitness/sum;

end;

Individuo:=FGeneral.Generacion[0];

Individuo.cfitness:=Individuo.rfitness;


begin


Individuo_1:=FGeneral.Generacion[mem-1];

Individuo.cfitness:=Individuo_1.cfitness+Individuo.rfitness;

end;


105


begin

new(NewIndividuo);

fillchar(NewIndividuo^,sizeof(NewIndividuo^),0);

NewGeneracion.Add(NewIndividuo);

end;


begin

p:=random(1000)/1000.0;

Individuo:=FGeneral.Generacion[0];

if (p<Individuo.cfitness) then

begin

NewIndividuo:=NewGeneracion[i];

NewIndividuo^:=Individuo^;

end

else

begin

for j:=0 to FGeneral.Generacion.Count-2 do

begin

Individuo_1:=FGeneral.Generacion[j];

Individuo:=FGeneral.Generacion[j+1];

if (p>=Individuo_1.cfitness)and(p<Individuo.cfitness) then

begin

NewIndividuo:=NewGeneracion[i];

NewIndividuo^:=Individuo^;

end;

end;

end;


106

end;


begin

Individuo :=FGeneral.Generacion[i];

Individuo_1:=NewGeneracion[i];

Individuo^:=Individuo_1^;

end;

while NewGeneracion.Count>0 do

begin

Individuo:=NewGeneracion[0];

NewGeneracion.Delete(0);

Dispose(Individuo);

end;

NewGeneracion.free;

end;

procedure TFGenetico.crossover;

var

mem : integer;

one : integer;

first : integer;

x : double;

begin

first:=0;

one:=0;



107

begin

x:=random(1000)/1000.0;

if (x<PXOVER) then

begin

Inc(first);

if (first mod 2=0) then

Xover(one,mem)

else

one:=mem;

end;

end;

end;

procedure TFGenetico.mutate;

var

i : integer;

x : double;


begin


begin

x:=random(1000)/1000.0;

if (x<PMUTATION) then

begin

Individuo:=FGeneral.Generacion[i];

with Individuo^ do

begin


108

PS3a:=FGeneral.IndividuoLow.PS3a+Random*(FGeneral.IndividuoUp.PS3a-

FGeneral.IndividuoLow.PS3a);

PS3b:=FGeneral.IndividuoLow.PS3b+Random*(FGeneral.IndividuoUp.PS3b-

FGeneral.IndividuoLow.PS3b);

PS3c:=FGeneral.IndividuoLow.PS3c+Random*(FGeneral.IndividuoUp.PS3c-

FGeneral.IndividuoLow.PS3c);

PS3d:=FGeneral.IndividuoLow.PS3d+Random*(FGeneral.IndividuoUp.PS3d-

FGeneral.IndividuoLow.PS3d);












109







PCEa:=FGeneral.IndividuoLow.PCEa+Random*(FGeneral.IndividuoUp.PCEa-

FGeneral.IndividuoLow.PCEa);

PCEb:=FGeneral.IndividuoLow.PCEb+Random*(FGeneral.IndividuoUp.PCEb-

FGeneral.IndividuoLow.PCEb);

PCEc:=FGeneral.IndividuoLow.PCEc+Random*(FGeneral.IndividuoUp.PCEc-

FGeneral.IndividuoLow.PCEc);

PCEd:=FGeneral.IndividuoLow.PCEd+Random*(FGeneral.IndividuoUp.PCEd-

FGeneral.IndividuoLow.PCEd);

PB1a:=FGeneral.IndividuoLow.PB1a+Random*(FGeneral.IndividuoUp.PB1a-

FGeneral.IndividuoLow.PB1a);

PB1b:=FGeneral.IndividuoLow.PB1b+Random*(FGeneral.IndividuoUp.PB1b-

FGeneral.IndividuoLow.PB1b);


110

PB1c:=FGeneral.IndividuoLow.PB1c+Random*(FGeneral.IndividuoUp.PB1c-

FGeneral.IndividuoLow.PB1c);

PB1d:=FGeneral.IndividuoLow.PB1d+Random*(FGeneral.IndividuoUp.PB1d-

FGeneral.IndividuoLow.PB1d);
















111



XS2a:=FGeneral.IndividuoLow.XS2a+Random*(FGeneral.IndividuoUp.XS2a-

FGeneral.IndividuoLow.XS2a);

XS2b:=FGeneral.IndividuoLow.XS2b+Random*(FGeneral.IndividuoUp.XS2b-

FGeneral.IndividuoLow.XS2b);

XS2c:=FGeneral.IndividuoLow.XS2c+Random*(FGeneral.IndividuoUp.XS2c-

FGeneral.IndividuoLow.XS2c);

XS2d:=FGeneral.IndividuoLow.XS2d+Random*(FGeneral.IndividuoUp.XS2d-

FGeneral.IndividuoLow.XS2d);

XS1a:=FGeneral.IndividuoLow.XS1a+Random*(FGeneral.IndividuoUp.XS1a-

FGeneral.IndividuoLow.XS1a);

XS1b:=FGeneral.IndividuoLow.XS1b+Random*(FGeneral.IndividuoUp.XS1b-

FGeneral.IndividuoLow.XS1b);

XS1c:=FGeneral.IndividuoLow.XS1c+Random*(FGeneral.IndividuoUp.XS1c-

FGeneral.IndividuoLow.XS1c);

XS1d:=FGeneral.IndividuoLow.XS1d+Random*(FGeneral.IndividuoUp.XS1d-

FGeneral.IndividuoLow.XS1d);


112

XCEa:=FGeneral.IndividuoLow.XCEa+Random*(FGeneral.IndividuoUp.XCEa-

FGeneral.IndividuoLow.XCEa);

XCEb:=FGeneral.IndividuoLow.XCEb+Random*(FGeneral.IndividuoUp.XCEb-

FGeneral.IndividuoLow.XCEb);

XCEc:=FGeneral.IndividuoLow.XCEc+Random*(FGeneral.IndividuoUp.XCEc-

FGeneral.IndividuoLow.XCEc);

XCEd:=FGeneral.IndividuoLow.XCEd+Random*(FGeneral.IndividuoUp.XCEd-

FGeneral.IndividuoLow.XCEd);

XB1a:=FGeneral.IndividuoLow.XB1a+Random*(FGeneral.IndividuoUp.XB1a-

FGeneral.IndividuoLow.XB1a);

XB1b:=FGeneral.IndividuoLow.XB1b+Random*(FGeneral.IndividuoUp.XB1b-

FGeneral.IndividuoLow.XB1b);

XB1c:=FGeneral.IndividuoLow.XB1c+Random*(FGeneral.IndividuoUp.XB1c-

FGeneral.IndividuoLow.XB1c);

XB1d:=FGeneral.IndividuoLow.XB1d+Random*(FGeneral.IndividuoUp.XB1d-

FGeneral.IndividuoLow.XB1d);

XB2a:=FGeneral.IndividuoLow.XB2a+Random*(FGeneral.IndividuoUp.XB2a-

FGeneral.IndividuoLow.XB2a);


113

XB2b:=FGeneral.IndividuoLow.XB2b+Random*(FGeneral.IndividuoUp.XB2b-

FGeneral.IndividuoLow.XB2b);

XB2c:=FGeneral.IndividuoLow.XB2c+Random*(FGeneral.IndividuoUp.XB2c-

FGeneral.IndividuoLow.XB2c);

XB2d:=FGeneral.IndividuoLow.XB2d+Random*(FGeneral.IndividuoUp.XB2d-

FGeneral.IndividuoLow.XB2d);

FGeneral.CorrigeFuncionMiembro(PS3a,PS3b,PS3c,PS3d);



FGeneral.CorrigeFuncionMiembro(PCEa,PCEb,PCEc,PCEd);

FGeneral.CorrigeFuncionMiembro(PB1a,PB1b,PB1c,PB1d);



end;

end;

end;

end;

procedure TFGenetico.report(generation:integer);

{var

i : integer;

best_val : double;

avg : double;

stddev : double;

sum_square : double;


114

square_sum : double;

sum : double;

Individuo : PCromosoma;}

begin

{ sum:=0;

sum_square:=0;


begin

Individuo:=FGeneral.Generacion[i];

sum:=sum+Individuo.fitness;

sum_square:=sum_square+Individuo.fitness*Individuo.fitness;

end;

avg:=sum/FGeneral.Generacion.Count;

square_sum:=avg*avg*FGeneral.Generacion.Count;

stddev:=sqrt((sum_square-square_sum)/(FGeneral.Generacion.Count-

1));

best_val:=FGeneral.BestIndividuo.fitness;

Writeln(galog,generation:10,best_val:10,avg:10,stddev:10);}

end;

procedure TFGenetico.elitist;

var

i : integer;

best : double;

worst : double;

best_mem : integer;

worst_mem : integer;

Individuo1 : PCromosoma;


115


begin

Individuo1:=FGeneral.Generacion[0];

worst:=Individuo1.fitness;

best:=Individuo1.fitness;

best_mem:=0;

worst_mem:=0;


begin

Individuo1:=FGeneral.Generacion[i];

Individuo2:=FGeneral.Generacion[i+1];

if (Individuo1.fitness>Individuo2.fitness) then

begin

if (Individuo1.fitness>=best) then

begin


best_mem:=i;

end;

if (Individuo2.fitness<=worst) then

begin


worst_mem:=i+1;

end;

end

else

begin

if (Individuo1.fitness<=worst) then

begin


116


worst_mem:=i;

end;

if (Individuo2.fitness>=best) then

begin


best_mem:=i+1;

end;

end;

end;

if (best>=FGeneral.BestIndividuo.fitness) then

begin

Individuo2:=FGeneral.Generacion[best_mem];

FGeneral.BestIndividuo:=Individuo2^;

end

else

begin

Individuo2:=FGeneral.Generacion[worst_mem];

Individuo2^:=FGeneral.BestIndividuo;

end;

end;

procedure TFGenetico.EvaluaIndividuo(Individuo:PCromosoma);

var

Difuso : TControladorDifuso;

Distancia : double;

i : integer;


117

itotal : integer;

x : double;

y : double;

phi : double;

teta : double;

iini : integer;

begin

if RadioButton1.Checked then

Difuso:=TControladorDifuso.Create(Individuo^,FGeneral.CromoReglaOriginal.

Reglas)

else

Difuso:=TControladorDifuso.Create(Individuo^,FGeneral.CromoBestRegla.Reg

las);

itotal:=0;

Distancia:=0;

for iini:=0 to FGeneral.PuntosIniciales.Count-1 do

begin

phi:=PPunto(FGeneral.PuntosIniciales[iini]).phi;

x:=PPunto(FGeneral.PuntosIniciales[iini]).x;

i:=0;

y:=0;

repeat

Difuso.fld_fuzzy_inputs(phi,x);

Difuso.fld_fuzzy_outputs(teta);

x:=x+cos(phi*rad+Teta*rad)+sin(Teta*rad)*sin(phi*rad);


118

y:=y+sin(phi*rad+Teta*rad)-sin(Teta*rad)*cos(phi*rad);

phi:=phi*rad - arcsin((2*sin(Teta*rad))/4);

phi:=phi*grad;

if (phi>270)and(phi<= 360) then

phi:=phi-360;

if (phi>360) then

phi:=phi-360;

Distancia:=Distancia+10-x;

inc(i);

until

((x>9.5)and(x<10.5)and(phi>89.5)and(phi<90.5))or(i>TiempoMaximo);

itotal:=itotal+i;

end;

Individuo.i:=itotal;

Individuo.Distancia:=Distancia;

if itotal=0 then

Individuo.fitness:=1E100

else

Individuo.fitness:=1/itotal;

Difuso.destroy;

end;

procedure TFGenetico.XOver(one,two:integer);

var



begin

Individuo1:=FGeneral.Generacion[one];


119

Individuo2:=FGeneral.Generacion[two];

SwapGenes(Individuo1.PS3a,Individuo2.PS3a);

SwapGenes(Individuo1.PS3b,Individuo2.PS3b);

SwapGenes(Individuo1.PS3c,Individuo2.PS3c);

SwapGenes(Individuo1.PS3d,Individuo2.PS3d);









SwapGenes(Individuo1.PCEa,Individuo2.PCEa);

SwapGenes(Individuo1.PCEb,Individuo2.PCEb);

SwapGenes(Individuo1.PCEc,Individuo2.PCEc);

SwapGenes(Individuo1.PCEd,Individuo2.PCEd);

SwapGenes(Individuo1.PB1a,Individuo2.PB1a);

SwapGenes(Individuo1.PB1b,Individuo2.PB1b);

SwapGenes(Individuo1.PB1c,Individuo2.PB1c);

SwapGenes(Individuo1.PB1d,Individuo2.PB1d);









120


SwapGenes(Individuo1.XS2a,Individuo2.XS2a);

SwapGenes(Individuo1.XS2b,Individuo2.XS2b);

SwapGenes(Individuo1.XS2c,Individuo2.XS2c);

SwapGenes(Individuo1.XS2d,Individuo2.XS2d);

SwapGenes(Individuo1.XS1a,Individuo2.XS1a);

SwapGenes(Individuo1.XS1b,Individuo2.XS1b);

SwapGenes(Individuo1.XS1c,Individuo2.XS1c);

SwapGenes(Individuo1.XS1d,Individuo2.XS1d);

SwapGenes(Individuo1.XCEa,Individuo2.XCEa);

SwapGenes(Individuo1.XCEb,Individuo2.XCEb);

SwapGenes(Individuo1.XCEc,Individuo2.XCEc);

SwapGenes(Individuo1.XCEd,Individuo2.XCEd);

SwapGenes(Individuo1.XB1a,Individuo2.XB1a);

SwapGenes(Individuo1.XB1b,Individuo2.XB1b);

SwapGenes(Individuo1.XB1c,Individuo2.XB1c);

SwapGenes(Individuo1.XB1d,Individuo2.XB1d);

SwapGenes(Individuo1.XB2a,Individuo2.XB2a);

SwapGenes(Individuo1.XB2b,Individuo2.XB2b);

SwapGenes(Individuo1.XB2c,Individuo2.XB2c);

SwapGenes(Individuo1.XB2d,Individuo2.XB2d);

With Individuo1^ do

begin







121



FGeneral.CorrigeFuncionMiembro(XS2a,XS2b,XS2c,XS2d);


FGeneral.CorrigeFuncionMiembro(XCEa,XCEb,XCEc,XCEd);

FGeneral.CorrigeFuncionMiembro(XB1a,XB1b,XB1c,XB1d);


end;

With Individuo2^ do

begin










FGeneral.CorrigeFuncionMiembro(XCEa,XCEb,XCEc,XCEd);



end;

end;

procedure TFGenetico.SwapGenes(var Gene1,Gene2 : double);

var

x : double;


122

begin

x:=Gene1;

Gene1:=Gene2;

Gene2:=x;

end;

procedure TFGenetico.FormShow(Sender: TObject);

begin

BitBtn1.Enabled:=true;

ProgressBar1.Max:=MAXGENS;


ProgressBar2.Max:=MAXGENERACION;


end;

procedure TFGenetico.BitBtn1Click(Sender: TObject);

begin

if (RadioButton2.Checked)and(not FGeneRegla.Generado) then

begin

MessageBox(handle,'No se han generado las

reglas.','Error',MB_ICONSTOP);

exit;

end;

BitBtn1.Enabled:=false;

GeneraControlador;

end;


123

procedure TFGenetico.BitBtn2Click(Sender: TObject);

begin

generation:=MAXGENS;

BitBtn1.Enabled:=true;

Close;

end;

end.


124

BIBLIOGRAFÍA:

• Fuzzy Logic, a practical approach

F. Martin McNeil, Ellen Thro

AP Professional 1994

• Fuzzy Logic and Control software and hardware applications

Mohammad Jamshidi, Nader Vadiee, Tymothy J. Ross

Prentice Hall 1993

• Fuzzy sets, neural networks and soft computing

R.R yager and L.A. Zadeh

Can Nostrand Reinhold

1994

• Genetic Programming

John R. Koza

The MIT Press 1992

• Genetic Algorithms in Engineering and Computer Science

G. Winter, J, Périaux, M. Galán, P. Cuesta

John Wiley and Sons 1995

• Genetic Algorithms for machine learning

John J. Grefenstette

Kluwer Academic Publishers

1993


125

• Foundations of Genetics Algorithms

Edited by Gregory J.E. Rawlins

Morgan Kaufmann Publishers

San Mateo, California 1991

• Fuzzy logic jump-start publications

http://www.fuzzy- logic.com

• Fuzzy logic tutorial

http://www.seattlerobotics.org/encoder/mar98/fuz/flindex.html

• Genetic algorithms

http://cs.felk.cvut.cz/~xobitko/ga/


http://www.doc.ic.ac.uk/~nd/surprise_96/journal/vol4/tcw2/report.html


http://www.doc.ic.ac.uk/~nd/surprise_96/journal/vol4/tcw2/report.html

“OPTIMIZACIÓN DE CONTROLADORES DIFUSOS POR MEDIO DE ...148.206.53.84/tesiuami/UAMI10730.pdf ·...

Documents

Transcript of “OPTIMIZACIÓN DE CONTROLADORES DIFUSOS POR MEDIO DE ...148.206.53.84/tesiuami/UAMI10730.pdf ·...