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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.2 Controlador difuso. .........................................................................23
2.2.3 Programa........................................................................................24
2.3 ATERRIZAR UN AVIÓN (AIRCRAFT ) ...............................................................26
2.3.1 Descripción del Problema. ...............................................................27
2.3.2 Controlador difuso. .........................................................................28
2.1.3 Programa........................................................................................30
CAPÍTULO III. ALGORITMOS GENÉTICOS............................................... 33
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
3.4.2 Función sobre 3 dimensiones. .........................................................41
3.4.3 Función sobre 4 dimensiones. .........................................................42
CAPÍTULO IV. APLICACIONES DE ALGORITMOS GENÉTICOS SOBRE
CONTROLADORES DIFUSOS..................................................................... 43
4.1 ESTACIONAR UN CAMIÓN ...........................................................................43
4.1.1 Descripción del Problema. ...............................................................43
4.1.2 Controlador difuso. .........................................................................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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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”
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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:
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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:
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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)
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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)
θ
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.
θ
φ
UNIVERSIDAD AUTÓNOMA METROPOLITANA
23
2.2.2 Controlador difuso.
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
µ(φ)
φ
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
Φ
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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();
}
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
27
con ciertas funciones miembro establecidas y por último una mejora del
mismo modificando las funciones miembro impuestas.
2.3.1 Descripción del Problema.
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.
2.3.2 Controlador difuso.
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).
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
32
Y por último la simulación queda como se muestra a continuación.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
41
3.4.2 Función sobre 3 dimensiones.
La función de la cuál deseamos obtener un punto máximo es:
z(x,y) = x * Sin(y)
Número de
generación Mejor valor Fitness Promedio
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
simulation completed
best member:
var(0) = 9.990
var(1) = 1.600
best fitness=9.986
Área analizada
x
y
UNIVERSIDAD AUTÓNOMA METROPOLITANA
42
3.4.3 Función sobre 4 dimensiones.
La función de la cuál deseamos obtener un punto máximo es:
3) f(x,y,z) = x2 – x*y + z
Número de
generación Mejor valor Fitness Promedio
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
simulation completed
best member:
var(0)=9.980
var(1)=0.020
var(2)=9.880
best fitness=109.281
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
4.1.1 Descripción del Problema.
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.
4.1.2 Controlador difuso.
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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,
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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)
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
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 reglas.
Número de generaciones para las reglas
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 reglas.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
62
4.1.5.3 Optimizando sólo las reglas lingüísticas.
Valores obtenidos
phi = 89.671
x = 10.327
y = 22.268
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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:
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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:
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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;
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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_S2 : double ;
result_PHI_S1 : double ;
result_PHI_CE : double ;
result_PHI_B1 : double ;
result_PHI_B2 : double ;
result_PHI_B3 : 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 ;
UNIVERSIDAD AUTÓNOMA METROPOLITANA
75
procedure eval_PHI_S3(phi:double);
procedure eval_PHI_S2(phi:double);
procedure eval_PHI_S1(phi:double);
procedure eval_PHI_CE(phi:double);
procedure eval_PHI_B1(phi:double);
procedure eval_PHI_B2(phi:double);
procedure eval_PHI_B3(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;
UNIVERSIDAD AUTÓNOMA METROPOLITANA
76
//FillChar(Resultados,sizeof(Resultados),0);
FillChar(MatRes,sizeof(MatRes),0);
MatRes[3,1]:=OUT_S3;
MatRes[3,2]:=OUT_S2;
MatRes[3,3]:=OUT_S1;
MatRes[3,4]:=OUT_CE;
MatRes[3,5]:=OUT_B1;
MatRes[3,6]:=OUT_B2;
MatRes[3,7]:=OUT_B3;
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;
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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;
sum_OUT:=sum_OUT+result;
{/*------------------------------------------------------------------------
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);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 3
if PHI is S2 and
X is S2 then
OUT is S2
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_S2, 1.0);
result:=FunctionAnd( result_X_S2, result);
result_OUT:=result_OUT+(result*OUT_S2);
UNIVERSIDAD AUTÓNOMA METROPOLITANA
79
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 4
if PHI is S2 and
X is S1 then
OUT is S3
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_S2, 1.0);
result:=FunctionAnd( result_X_S1, result);
result_OUT:=result_OUT+(result*OUT_S3);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 5
if PHI is S2 and
X is CE then
OUT is S3
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_S2, 1.0);
result:=FunctionAnd( result_X_CE, result);
result_OUT:=result_OUT+(result*OUT_S3);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 6
if PHI is S2 and
X is B1 then
UNIVERSIDAD AUTÓNOMA METROPOLITANA
80
OUT is S3
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_S2, 1.0);
result:=FunctionAnd( result_X_B1, result);
result_OUT:=result_OUT+(result*OUT_S3);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 7
if PHI is S1 and
X is S2 then
OUT is B1
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_S1, 1.0);
result:=FunctionAnd( result_X_S2, result);
result_OUT:=result_OUT+(result*OUT_B1);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 8
if PHI is S1 and
X is S1 then
OUT is S1
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_S1, 1.0);
result:=FunctionAnd( result_X_S1, result);
result_OUT:=result_OUT+(result*OUT_S1);
sum_OUT:=sum_OUT+result;
UNIVERSIDAD AUTÓNOMA METROPOLITANA
81
{ /*------------------------------------------------------------------------
Rule 9
if PHI is S1 and
X is CE then
OUT is S2
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_S1, 1.0);
result:=FunctionAnd( result_X_CE, result);
result_OUT:=result_OUT+(result*OUT_S2);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 10
if PHI is S1 and
X is B1 then
OUT is S3
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_S1, 1.0);
result:=FunctionAnd( result_X_B1, result);
result_OUT:=result_OUT+(result*OUT_S3);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 11
if PHI is S1 and
X is B2 then
OUT is S2
UNIVERSIDAD AUTÓNOMA METROPOLITANA
82
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_S1, 1.0);
result:=FunctionAnd( result_X_B2, result);
result_OUT:=result_OUT+(result*OUT_S2);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 12
if PHI is CE and
X is S2 then
OUT is B2
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_CE, 1.0);
result:=FunctionAnd( result_X_S2, result);
result_OUT:=result_OUT+(result*OUT_B2);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 13
if PHI is CE and
X is S1 then
OUT is B2
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_CE, 1.0);
result:=FunctionAnd( result_X_S1, result);
result_OUT:=result_OUT+(result*OUT_B2);
sum_OUT:=sum_OUT+result;
UNIVERSIDAD AUTÓNOMA METROPOLITANA
83
{ /*------------------------------------------------------------------------
Rule 14
if PHI is CE and
X is CE then
OUT is CE
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_CE, 1.0);
result:=FunctionAnd( result_X_CE, result);
result_OUT:=result_OUT+(result*OUT_CE);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 15
if PHI is CE and
X is B1 then
OUT is S2
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_CE, 1.0);
result:=FunctionAnd( result_X_B1, result);
result_OUT:=result_OUT+(result*OUT_S2);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 16
if PHI is CE and
X is B2 then
OUT is S2
-------------------------------------------------------------------------*/}
UNIVERSIDAD AUTÓNOMA METROPOLITANA
84
result:=FunctionAnd( result_PHI_CE, 1.0);
result:=FunctionAnd( result_X_B2, result);
result_OUT:=result_OUT+(result*OUT_S2);
sum_OUT:=sum_OUT+result;
{/*------------------------------------------------------------------------
Rule 17
if PHI is B1 and
X is S2 then
OUT is B2
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_B1, 1.0);
result:=FunctionAnd( result_X_S2, result);
result_OUT:=result_OUT+(result*OUT_B2);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 18
if PHI is B1 and
X is S1 then
OUT is B3
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_B1, 1.0);
result:=FunctionAnd( result_X_S1, result);
result_OUT:=result_OUT+(result*OUT_B3);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
UNIVERSIDAD AUTÓNOMA METROPOLITANA
85
Rule 19
if PHI is B1 and
X is CE then
OUT is B2
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_B1, 1.0);
result:=FunctionAnd( result_X_CE, result);
result_OUT:=result_OUT+(result*OUT_B2);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 20
if PHI is B1 and
X is B1 then
OUT is B1
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_B1, 1.0);
result:=FunctionAnd( result_X_B1, result);
result_OUT:=result_OUT+(result*OUT_B1);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 21
if PHI is B1 and
X is B2 then
OUT is S1
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_B1, 1.0);
UNIVERSIDAD AUTÓNOMA METROPOLITANA
86
result:=FunctionAnd( result_X_B2, result);
result_OUT:=result_OUT+(result*OUT_S1);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 22
if PHI is B2 and
X is S1 then
OUT is B3
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_B2, 1.0);
result:=FunctionAnd( result_X_S1, result);
result_OUT:=result_OUT+(result*OUT_B3);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 23
if PHI is B2 and
X is CE then
OUT is B3
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_B2, 1.0);
result:=FunctionAnd( result_X_CE, result);
result_OUT:=result_OUT+(result*OUT_B3);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 24
UNIVERSIDAD AUTÓNOMA METROPOLITANA
87
if PHI is B2 and
X is B1 then
OUT is B3
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_B2, 1.0);
result:=FunctionAnd( result_X_B1, result);
result_OUT:=result_OUT+(result*OUT_B3);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 25
if PHI is B2 and
X is B2 then
OUT is B2
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_B2, 1.0);
result:=FunctionAnd( result_X_B2, result);
result_OUT:=result_OUT+(result*OUT_B2);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 26
if PHI is B3 and
X is B1 then
OUT is B3
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_B3, 1.0);
result:=FunctionAnd( result_X_B1, result);
UNIVERSIDAD AUTÓNOMA METROPOLITANA
88
result_OUT:=result_OUT+(result*OUT_B3);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 27
if PHI is B3 and
X is B2 then
OUT is B2
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_B3, 1.0);
result:=FunctionAnd( result_X_B2, result);
result_OUT:=result_OUT+(result*OUT_B2);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 28
if PHI is S3 and
X is CE then
OUT is CE
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_S3, 1.0);
result:=FunctionAnd( result_X_CE, result);
result_OUT:=result_OUT+(result*OUT_CE);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 29
if PHI is S3 and
UNIVERSIDAD AUTÓNOMA METROPOLITANA
89
X is B1 then
OUT is S3
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_S3, 1.0);
result:=FunctionAnd( result_X_B1, result);
result_OUT:=result_OUT+(result*OUT_S3);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 30
if PHI is S3 and
X is B2 then
OUT is S3
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_S3, 1.0);
result:=FunctionAnd( result_X_B2, result);
result_OUT:=result_OUT+(result*OUT_S3);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 31
if PHI is S2 and
X is B2 then
OUT is S2
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_S2, 1.0);
result:=FunctionAnd( result_X_B2, result);
result_OUT:=result_OUT+(result*OUT_S2);
UNIVERSIDAD AUTÓNOMA METROPOLITANA
90
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 32
if PHI is B2 FunctionAnd
X is S2 then
OUT is CE
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_B2, 1.0);
result:=FunctionAnd( result_X_S2, result);
result_OUT:=result_OUT+(result*OUT_CE);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 33
if PHI is B3 and
X is S2 then
OUT is S3
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_B3, 1.0);
result:=FunctionAnd( result_X_S2, result);
result_OUT:=result_OUT+(result*OUT_S3);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 34
if PHI is B3 and
X is S1 then
UNIVERSIDAD AUTÓNOMA METROPOLITANA
91
OUT is S3
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_B3, 1.0);
result:=FunctionAnd( result_X_S1, result);
result_OUT:=result_OUT+(result*OUT_S3);
sum_OUT:=sum_OUT+result;
{ /*------------------------------------------------------------------------
Rule 35
if PHI is B3 and
X is CE then
OUT is S2
-------------------------------------------------------------------------*/}
result:=FunctionAnd( result_PHI_B3, 1.0);
result:=FunctionAnd( result_X_CE, result);
result_OUT:=result_OUT+(result*OUT_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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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;
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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;
procedure TControladorDifuso.eval_PHI_B2(phi: double);
begin
result_PHI_B2:=Evaluate(Individuo.PB2a,Individuo.PB2b,Individuo.PB2c,Indi
viduo.PB2d,phi);
MatRes[1,6]:=result_PHI_B2;
end;
UNIVERSIDAD AUTÓNOMA METROPOLITANA
94
procedure TControladorDifuso.eval_PHI_B3(phi: double);
begin
result_PHI_B3:=Evaluate(Individuo.PB3a,Individuo.PB3b,Individuo.PB3c,Indi
viduo.PB3d,phi);
MatRes[1,7]:=result_PHI_B3;
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
result_PHI_S1:=Evaluate(Individuo.PS1a,Individuo.PS1b,Individuo.PS1c,Indiv
iduo.PS1d,phi);
MatRes[1,3]:=result_PHI_S1;
end;
procedure TControladorDifuso.eval_PHI_S2(phi: double);
begin
UNIVERSIDAD AUTÓNOMA METROPOLITANA
95
result_PHI_S2:=Evaluate(Individuo.PS2a,Individuo.PS2b,Individuo.PS2c,Indiv
iduo.PS2d,phi);
MatRes[1,2]:=result_PHI_S2;
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;
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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;
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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;
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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;
ProgressBar2.Position:=0;
for i:=0 to FGeneral.Generacion.Count-1 do
begin
UNIVERSIDAD AUTÓNOMA METROPOLITANA
101
Individuo:=FGeneral.Generacion.Items[i];
EvaluaIndividuo(Individuo);
ProgressBar2.StepIt;
end;
end;
procedure TFGenetico.keep_the_best;
var
mem : integer;
cur_best : integer;
Individuo : PCromosoma;
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;
UNIVERSIDAD AUTÓNOMA METROPOLITANA
102
PS3c:=Individuo.PS3c;
PS3d:=Individuo.PS3d;
PS2a:=Individuo.PS2a;
PS2b:=Individuo.PS2b;
PS2c:=Individuo.PS2c;
PS2d:=Individuo.PS2d;
PS1a:=Individuo.PS1a;
PS1b:=Individuo.PS1b;
PS1c:=Individuo.PS1c;
PS1d:=Individuo.PS1d;
PCEa:=Individuo.PCEa;
PCEb:=Individuo.PCEb;
PCEc:=Individuo.PCEc;
PCEd:=Individuo.PCEd;
PB1a:=Individuo.PB1a;
PB1b:=Individuo.PB1b;
PB1c:=Individuo.PB1c;
PB1d:=Individuo.PB1d;
PB2a:=Individuo.PB2a;
PB2b:=Individuo.PB2b;
PB2c:=Individuo.PB2c;
PB2d:=Individuo.PB2d;
PB3a:=Individuo.PB3a;
PB3b:=Individuo.PB3b;
PB3c:=Individuo.PB3c;
PB3d:=Individuo.PB3d;
XS2a:=Individuo.XS2a;
XS2b:=Individuo.XS2b;
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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;
UNIVERSIDAD AUTÓNOMA METROPOLITANA
104
i : integer;
j : integer;
Individuo : PCromosoma;
Individuo_1 : PCromosoma;
NewIndividuo : PCromosoma;
NewGeneracion : TList;
begin
NewGeneracion:=TList.Create;
sum:=0;
for mem:=0 to FGeneral.Generacion.Count-1 do
begin
Individuo:=FGeneral.Generacion[mem];
sum:=sum+Individuo.fitness;
end;
for mem:=0 to FGeneral.Generacion.Count-1 do
begin
Individuo:=FGeneral.Generacion[mem];
Individuo.rfitness:=Individuo.fitness/sum;
end;
Individuo:=FGeneral.Generacion[0];
Individuo.cfitness:=Individuo.rfitness;
for mem:=1 to FGeneral.Generacion.Count-1 do
begin
Individuo:=FGeneral.Generacion[mem];
Individuo_1:=FGeneral.Generacion[mem-1];
Individuo.cfitness:=Individuo_1.cfitness+Individuo.rfitness;
end;
UNIVERSIDAD AUTÓNOMA METROPOLITANA
105
for i:=0 to FGeneral.Generacion.Count-1 do
begin
new(NewIndividuo);
fillchar(NewIndividuo^,sizeof(NewIndividuo^),0);
NewGeneracion.Add(NewIndividuo);
end;
for i:=0 to FGeneral.Generacion.Count-1 do
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;
UNIVERSIDAD AUTÓNOMA METROPOLITANA
106
end;
for i:=0 to FGeneral.Generacion.Count-1 do
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;
for mem:=0 to FGeneral.Generacion.Count-1 do
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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;
Individuo : PCromosoma;
begin
for i:=0 to FGeneral.Generacion.Count-1 do
begin
x:=random(1000)/1000.0;
if (x<PMUTATION) then
begin
Individuo:=FGeneral.Generacion[i];
with Individuo^ do
begin
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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);
PS2a:=FGeneral.IndividuoLow.PS2a+Random*(FGeneral.IndividuoUp.PS2a-
FGeneral.IndividuoLow.PS2a);
PS2b:=FGeneral.IndividuoLow.PS2b+Random*(FGeneral.IndividuoUp.PS2b-
FGeneral.IndividuoLow.PS2b);
PS2c:=FGeneral.IndividuoLow.PS2c+Random*(FGeneral.IndividuoUp.PS2c-
FGeneral.IndividuoLow.PS2c);
PS2d:=FGeneral.IndividuoLow.PS2d+Random*(FGeneral.IndividuoUp.PS2d-
FGeneral.IndividuoLow.PS2d);
PS1a:=FGeneral.IndividuoLow.PS1a+Random*(FGeneral.IndividuoUp.PS1a-
FGeneral.IndividuoLow.PS1a);
UNIVERSIDAD AUTÓNOMA METROPOLITANA
109
PS1b:=FGeneral.IndividuoLow.PS1b+Random*(FGeneral.IndividuoUp.PS1b-
FGeneral.IndividuoLow.PS1b);
PS1c:=FGeneral.IndividuoLow.PS1c+Random*(FGeneral.IndividuoUp.PS1c-
FGeneral.IndividuoLow.PS1c);
PS1d:=FGeneral.IndividuoLow.PS1d+Random*(FGeneral.IndividuoUp.PS1d-
FGeneral.IndividuoLow.PS1d);
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);
UNIVERSIDAD AUTÓNOMA METROPOLITANA
110
PB1c:=FGeneral.IndividuoLow.PB1c+Random*(FGeneral.IndividuoUp.PB1c-
FGeneral.IndividuoLow.PB1c);
PB1d:=FGeneral.IndividuoLow.PB1d+Random*(FGeneral.IndividuoUp.PB1d-
FGeneral.IndividuoLow.PB1d);
PB2a:=FGeneral.IndividuoLow.PB2a+Random*(FGeneral.IndividuoUp.PB2a-
FGeneral.IndividuoLow.PB2a);
PB2b:=FGeneral.IndividuoLow.PB2b+Random*(FGeneral.IndividuoUp.PB2b-
FGeneral.IndividuoLow.PB2b);
PB2c:=FGeneral.IndividuoLow.PB2c+Random*(FGeneral.IndividuoUp.PB2c-
FGeneral.IndividuoLow.PB2c);
PB2d:=FGeneral.IndividuoLow.PB2d+Random*(FGeneral.IndividuoUp.PB2d-
FGeneral.IndividuoLow.PB2d);
PB3a:=FGeneral.IndividuoLow.PB3a+Random*(FGeneral.IndividuoUp.PB3a-
FGeneral.IndividuoLow.PB3a);
PB3b:=FGeneral.IndividuoLow.PB3b+Random*(FGeneral.IndividuoUp.PB3b-
FGeneral.IndividuoLow.PB3b);
PB3c:=FGeneral.IndividuoLow.PB3c+Random*(FGeneral.IndividuoUp.PB3c-
FGeneral.IndividuoLow.PB3c);
UNIVERSIDAD AUTÓNOMA METROPOLITANA
111
PB3d:=FGeneral.IndividuoLow.PB3d+Random*(FGeneral.IndividuoUp.PB3d-
FGeneral.IndividuoLow.PB3d);
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);
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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);
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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(PS2a,PS2b,PS2c,PS2d);
FGeneral.CorrigeFuncionMiembro(PS1a,PS1b,PS1c,PS1d);
FGeneral.CorrigeFuncionMiembro(PCEa,PCEb,PCEc,PCEd);
FGeneral.CorrigeFuncionMiembro(PB1a,PB1b,PB1c,PB1d);
FGeneral.CorrigeFuncionMiembro(PB2a,PB2b,PB2c,PB2d);
FGeneral.CorrigeFuncionMiembro(PB3a,PB3b,PB3c,PB3d);
end;
end;
end;
end;
procedure TFGenetico.report(generation:integer);
{var
i : integer;
best_val : double;
avg : double;
stddev : double;
sum_square : double;
UNIVERSIDAD AUTÓNOMA METROPOLITANA
114
square_sum : double;
sum : double;
Individuo : PCromosoma;}
begin
{ sum:=0;
sum_square:=0;
for i:=0 to FGeneral.Generacion.Count-1 do
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;
UNIVERSIDAD AUTÓNOMA METROPOLITANA
115
Individuo2 : PCromosoma;
begin
Individuo1:=FGeneral.Generacion[0];
worst:=Individuo1.fitness;
best:=Individuo1.fitness;
best_mem:=0;
worst_mem:=0;
for i:=0 to FGeneral.Generacion.Count-2 do
begin
Individuo1:=FGeneral.Generacion[i];
Individuo2:=FGeneral.Generacion[i+1];
if (Individuo1.fitness>Individuo2.fitness) then
begin
if (Individuo1.fitness>=best) then
begin
best:=Individuo1.fitness;
best_mem:=i;
end;
if (Individuo2.fitness<=worst) then
begin
worst:=Individuo2.fitness;
worst_mem:=i+1;
end;
end
else
begin
if (Individuo1.fitness<=worst) then
begin
UNIVERSIDAD AUTÓNOMA METROPOLITANA
116
worst:=Individuo1.fitness;
worst_mem:=i;
end;
if (Individuo2.fitness>=best) then
begin
best:=Individuo2.fitness;
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;
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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);
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
Individuo1 : PCromosoma;
Individuo2 : PCromosoma;
begin
Individuo1:=FGeneral.Generacion[one];
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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.PS2a,Individuo2.PS2a);
SwapGenes(Individuo1.PS2b,Individuo2.PS2b);
SwapGenes(Individuo1.PS2c,Individuo2.PS2c);
SwapGenes(Individuo1.PS2d,Individuo2.PS2d);
SwapGenes(Individuo1.PS1a,Individuo2.PS1a);
SwapGenes(Individuo1.PS1b,Individuo2.PS1b);
SwapGenes(Individuo1.PS1c,Individuo2.PS1c);
SwapGenes(Individuo1.PS1d,Individuo2.PS1d);
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);
SwapGenes(Individuo1.PB2a,Individuo2.PB2a);
SwapGenes(Individuo1.PB2b,Individuo2.PB2b);
SwapGenes(Individuo1.PB2c,Individuo2.PB2c);
SwapGenes(Individuo1.PB2d,Individuo2.PB2d);
SwapGenes(Individuo1.PB3a,Individuo2.PB3a);
SwapGenes(Individuo1.PB3b,Individuo2.PB3b);
SwapGenes(Individuo1.PB3c,Individuo2.PB3c);
UNIVERSIDAD AUTÓNOMA METROPOLITANA
120
SwapGenes(Individuo1.PB3d,Individuo2.PB3d);
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
FGeneral.CorrigeFuncionMiembro(PS3a,PS3b,PS3c,PS3d);
FGeneral.CorrigeFuncionMiembro(PS2a,PS2b,PS2c,PS2d);
FGeneral.CorrigeFuncionMiembro(PS1a,PS1b,PS1c,PS1d);
FGeneral.CorrigeFuncionMiembro(PCEa,PCEb,PCEc,PCEd);
FGeneral.CorrigeFuncionMiembro(PB1a,PB1b,PB1c,PB1d);
UNIVERSIDAD AUTÓNOMA METROPOLITANA
121
FGeneral.CorrigeFuncionMiembro(PB2a,PB2b,PB2c,PB2d);
FGeneral.CorrigeFuncionMiembro(PB3a,PB3b,PB3c,PB3d);
FGeneral.CorrigeFuncionMiembro(XS2a,XS2b,XS2c,XS2d);
FGeneral.CorrigeFuncionMiembro(XS1a,XS1b,XS1c,XS1d);
FGeneral.CorrigeFuncionMiembro(XCEa,XCEb,XCEc,XCEd);
FGeneral.CorrigeFuncionMiembro(XB1a,XB1b,XB1c,XB1d);
FGeneral.CorrigeFuncionMiembro(XB2a,XB2b,XB2c,XB2d);
end;
With Individuo2^ do
begin
FGeneral.CorrigeFuncionMiembro(PS3a,PS3b,PS3c,PS3d);
FGeneral.CorrigeFuncionMiembro(PS2a,PS2b,PS2c,PS2d);
FGeneral.CorrigeFuncionMiembro(PS1a,PS1b,PS1c,PS1d);
FGeneral.CorrigeFuncionMiembro(PCEa,PCEb,PCEc,PCEd);
FGeneral.CorrigeFuncionMiembro(PB1a,PB1b,PB1c,PB1d);
FGeneral.CorrigeFuncionMiembro(PB2a,PB2b,PB2c,PB2d);
FGeneral.CorrigeFuncionMiembro(PB3a,PB3b,PB3c,PB3d);
FGeneral.CorrigeFuncionMiembro(XS2a,XS2b,XS2c,XS2d);
FGeneral.CorrigeFuncionMiembro(XS1a,XS1b,XS1c,XS1d);
FGeneral.CorrigeFuncionMiembro(XCEa,XCEb,XCEc,XCEd);
FGeneral.CorrigeFuncionMiembro(XB1a,XB1b,XB1c,XB1d);
FGeneral.CorrigeFuncionMiembro(XB2a,XB2b,XB2c,XB2d);
end;
end;
procedure TFGenetico.SwapGenes(var Gene1,Gene2 : double);
var
x : double;
UNIVERSIDAD AUTÓNOMA METROPOLITANA
122
begin
x:=Gene1;
Gene1:=Gene2;
Gene2:=x;
end;
procedure TFGenetico.FormShow(Sender: TObject);
begin
BitBtn1.Enabled:=true;
ProgressBar1.Max:=MAXGENS;
ProgressBar1.Position:=0;
ProgressBar2.Max:=MAXGENERACION;
ProgressBar2.Position:=0;
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;
UNIVERSIDAD AUTÓNOMA METROPOLITANA
123
procedure TFGenetico.BitBtn2Click(Sender: TObject);
begin
generation:=MAXGENS;
BitBtn1.Enabled:=true;
Close;
end;
end.
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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
UNIVERSIDAD AUTÓNOMA METROPOLITANA
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/
• Genetic algorithms
http://www.doc.ic.ac.uk/~nd/surprise_96/journal/vol4/tcw2/report.html
• Genetic algorithms
http://www.doc.ic.ac.uk/~nd/surprise_96/journal/vol4/tcw2/report.html
Top Related