IA2016-GRUPOMSN-TP02

FACULTAD DE INGENIERÍA – UNJu – INTELIGENCIA ARTIFICIAL 2016 TP2 – LÓGICA FUZZY Y SISTEMAS DE INFERENCIA Calificación

Grupo MSN

Inicio

Entrega

21/04/16

28/04/16

Pérez Ricardo Daniel, 6590 Ponce Cristian Marcelo, 6454 Ramos Pablo Nicolás, 6969

Problema 1 (3 ptos.) •

•

•

•

•

•

Diseñar y configurar en MATLAB una interfaz gráfica de usuario (GUI), para manejar un Sistema de Inferencia Fuzzy Mamdani (MFIS), de tipo MISO mononivel, que permita: Incorporar dos variables de entrada y una variable de salida. Definir o aplicar aplicar funciones de pertenencia pertenencia tipo triángulo ( trimf ), ), a las variables del sistema (entradas/salida) con hasta 7 particiones, relacionadas con el operador fuzzy AND. Cargar las reglas que formarán la base de reglas, con las características definidas en el punto anterior. Defuzzyficar mediante el método de centro de gravedad (existe una función de Matlab que realiza este cálculo). Seleccionar Seleccionar o diseñar diseñar un caso de uso para mostrar el funcionamiento funcionamiento de la nueva GUI generada.

PRESENTACIÓN DE LA INTERFAZ GRÁFICA DE USUARIO (GUI).

En términos generales, el programa cuenta básicamente con 5 (cinco) paneles.

1. Variable de Entrada 1:   en éste panel se coloca, en el campo “Nombre”, el nombre correspondiente a la primera variable de entrada; en el campo “Rango” se establece el rango de valores que toma dicha variable. Paso siguiente se escribe para cada partición su nombre y sus parámetros, el formato de escritura de los parámetros debe ser [X1 X2 X3] (siendo X1, X2 y X3 números). Se admite hasta 7 (siete) particiones, dejando vacío aquellos campos que no se requieren, es decir, si el problema requiere 3 (tres) particiones se deja en blanco los campos correspondientes al resto de particiones. Rellenado los campos se presiona el botón “Cargar” y automáticamente se muestra en la lista todas las particiones, opcionalmente se puede visualizar un gráfico de las particiones para mayor claridad presionando el botón “Ver Gráfico”.

Entr ada 2: ídem al panel anterior. 2. Variable de Entrada

1. Variable de Entrada 1:   en éste panel se coloca, en el campo “Nombre”, el nombre correspondiente a la primera variable de entrada; en el campo “Rango” se establece el rango de valores que toma dicha variable. Paso siguiente se escribe para cada partición su nombre y sus parámetros, el formato de escritura de los parámetros debe ser [X1 X2 X3] (siendo X1, X2 y X3 números). Se admite hasta 7 (siete) particiones, dejando vacío aquellos campos que no se requieren, es decir, si el problema requiere 3 (tres) particiones se deja en blanco los campos correspondientes al resto de particiones. Rellenado los campos se presiona el botón “Cargar” y automáticamente se muestra en la lista todas las particiones, opcionalmente se puede visualizar un gráfico de las particiones para mayor claridad presionando el botón “Ver Gráfico”.

Entr ada 2: ídem al panel anterior. 2. Variable de Entrada

3. Variable de Salida:  ídem al panel anterior pero para el caso de una variable de salida.

4. Reglas:   en éste panel es donde se añade (o elimina) las reglas de nuestro sistema de inferencia fuzzy. El mecanismo es sencillo, se selecciona, de la lista correspondiente a cada panel de variables (Entrada 1, Entrada 2 y Salida), una partición. Opcionalmente se puede operar de modo negado con la partición, marcando el checkbox “not”. Seleccionada las particiones se presiona el botón “Agregar Regla” del panel de reglas, y se visualiza en la lista, de manera inmediata, la regla agregada. Procediendo de la manera anterior se puede agregar tantas reglas como se necesite. El mecanismo para eliminar una regla consiste en seleccionar algún ítem de la lista y presionar, luego, el botón “Eliminar Regla” y automáticamente la regla desaparece de la lista.

5. Solución:  en éste último panel se ingresa, en el campo “Valor de Entrada 1”, algún valor para la primera variable de entrada y, en el campo “Valor de Entrada 2”, algún valor para la segunda variable de entrada. Si se presiona el botón “Calcular” se muestra, en el campo “Resultado”, el resultado (valga la redundancia) de la inferencia. También se puede visualizar gráficamente el resultado presionando el botón “Graficar”. Para limpiar todos los campos del programa se presiona el botón “Limpiar”.

Es importante mencionar que el programa, como se pidió, aplica funciones de pertenencia tipo triángulo (trimf) a las variables del sistema, relacionadas con el operador fuzzy AND. Además, el programa utiliza el método de centro de gravedad (centroide) para defuzzyficar.

FUNCIONAMIENTO DE LA INTERFAZ GRÁFICA DE USUARIO (GUI).

Como caso de uso, para mostrar el funcionamiento de la interfaz gráfica de usuario, se seleccionó el problema de la propina (tipping problem). Problema que el mismo MatLab utiliza para explicar el funcionamiento de la herramienta Fuzzy Logic Toolbox. El problema utiliza dos variables de entrada y una única variable de salida. Dado un número entre 0 y 10 que representa la calidad del servicio de un restaurante (donde 10 es excelente), y otro número entre 0 y 10 que representa la calidad de la comida (donde de nuevo 10 es excelente), ¿cuál debería ser la propina? Antes de nada escribimos las reglas de inferencia del problema: 1. Si el servicio es malo y la comida es horrible, entonces la propina es miserable. 2. Si el servicio es bueno, entonces la propina es normal.

3. Si el servicio es excelente y la comida es deliciosa, entones la propina es generosa. Se asume que una propina normal es del 15%, una propina generosa es del 25%, y una propina miserable es del 5%. Aclaradas y definidas las reglas de inferencia (y otras cuestiones) se procede a utilizar el programa. Escribimos en la ventana de comandos de MatLab el comando “ejercicio1”.

Y vemos la siguiente ventana.

Ahora, en el panel Variable de Entrada 1, escribimos el nombre de la primera variable de entrada, el rango de valores de dicha variable y los nombres y parámetros de las particiones involucradas. Para nuestro problema el nombre de la primera variable de entrada es “servicio” y el rango de valores es [0 10]. Para las particiones tenemos: 1. Partición 1: el nombre es “malo” y los parámetros son [0 0 3.5]. 2. Partición 2: el nombre es “bueno” y los parámetros son [1.5 5 8.5]. 3. Partición 3: el nombre es “excelente” y los parámetros son [6.5 10 10]. Entonces tenemos.

Presionamos el botón “Cargar”.

Presionamos el botón “Ver Grafico”.

Ahora, en el panel Variable de Entrada 2, escribimos el nombre de la segunda variable de entrada, el rango de valores de dicha variable y los nombres y parámetros de las particiones involucradas. Para nuestro problema el nombre de la segunda variable de entrada es “comida” y el rango de valores es [0 10]. Para las particiones tenemos: 1. Partición 1: el nombre es “horrible” y los parámetros son [-0.6 0.6 7.5]. 2. Partición 2: el nombre es “deliciosa” y los parámetros son [2.5 9.4 10.6]. Entonces tenemos.

Presionamos el botón “Cargar”.

Presionamos el botón “Ver Gráfico”.

Ahora, en el panel Variable de Salida, escribimos el nombre de la variable de salida, el rango de valores de dicha variable y los nombres y parámetros de las particiones involucradas. Para nuestro problema el nombre de la variable de salida es “propina” y el rango de valores es [0 30]. Para las particiones tenemos: 1. Partición 1: el nombre es “miserable” y los parámetros son [0 5 10]. 2. Partición 2: el nombre es “normal” y los parámetros son [10 15 20]. 3. Partición 3: el nombre es “generosa” y los parámetros son [20 25 30]. Entonces tenemos.

Presionamos el botón “Cargar”.

Presionamos el botón “Ver Gráfico”.

Luego, utilizando los selectores de cada variable, elegimos las particiones para armar las reglas. En la siguiente captura se muestra como se armó la última regla. Elegimos la partición “excelente” utilizando el selector del panel Variable de Entrada 1, elegimos la partición “deliciosa” utilizando el selector del panel Variable de Entrada 2 y elegimos la partición “generosa” utilizando el selector del panel Variable de Salida.

Luego, una vez elegidas las particiones, presionamos el botón “Agregar Regla” para agregar la regla.

Por último, nos ubicamos en el panel “Solución” para evaluar nuestro sistema de inferencia fuzzy. En el campo “Valor de Entrada 1” introducimos un valor para la primera variable de entrada, y en el campo “Valor de Entrada 2” introducimos un valor para la segunda variable de entrada.

Presionamos el botón “Calcular” y obtenemos el resultado.

Presionamos el botón “Graficar” y obtenemos una gráfica del resultado.

Comparando el resultado anterior con el obtenido utilizando la herramienta Fuzzy Logic Toolbox, vemos que ambos programas arrojan el mismo resultado.

CÓDIGO FUENTE DE LA INTERFAZ GRÁFICA DE USUARIO (GUI).  Archivo ejercicio1.m: Función inicializarSistemaInferencia %f unci on que i ni ci al i za el si st ema de i nf er enci a f uzzy f uncti on i ni c i al i z ar Si s t emaI nf er e nc i a( ) %decl ar amos l a var i abl e f i s como gl obal gl obal   f i s; %decl ar amos l a var i abl e numer o de r egl as como gl obal gl obal   numer oRegl as; %decl ar amos l a var i abl e gr ado de pr eci si on como gl obal gl obal   gr adoPr eci si on; %cr eamos un nuevo si st ema de i nf er enci a f uzzy f i s = {}; %i ni ci al i zamos a cer o el numero de r egl as numer oRegl as = 0; %i ni ci al i zamos el gr ado de pr eci si on gr adoPr eci si on = 0. 0001;

Función agregarParticiones %f unci on que agr ega l as part i ci ones al si st ema de i nf er enci a f uzzy f uncti on  agr egar Par t i ci ones( i d, i ndi ce, handl es) %t r abaj amos con l a var i abl e gl obal f i s gl obal   f i s; %def i ni mos var i abl es necesar i as  j = 0; cel da = {}; %obt enemos l a l i st a de part i ci ones de l a vari abl e que se est e t r atando l i staPar t i ci ones = eval ( str cat ( ' handl es . l i s t aPar t i c i ones ' , num2str ( i d) ) ) ; %r ecor r emos l os campos ( nombr e y par amet r os) de t odas l as par t i ci ones f or   i = 1: 1: 7 %obt enemos el nombr e de l a par t i ci on campoNombr ePar t i ci on = get ( eval ( st r cat ( ' handl es. campoNombr ePar t i ci on' , num2st r ( i d) , num2str ( i ) ) ) , ' St r i ng' ) ; %obt enemos el r ango de val or es de l a par t i ci on campoPar amet r osPar t i ci on = st r 2num( get ( eval ( st r cat ( ' handl es. campoPar amet r osPar t i ci on' , num2st r ( i d) , num2str ( i ) ) ) , ' St r i ng' ) ) ; %si l os campos nombr e y par amet r os no est an vaci os, ent onces i f ( ~i sempt y( campoNombr ePar t i ci on) && ~i sempt y( campoPar amet r osPar t i ci on) ) %sumamos en una uni dad l a var i abl e j  j = j + 1; %añadi mos l a part i ci on al si st ema de i nf er enci a f uzzy f i s{i ndi ce}{3}{j } = {campoNombr ePar t i ci on, campoPar amet r osPar t i ci on}; %añadi mos un nuevo el ement o a l a cel da cel da( j ) = {campoNombr ePar t i ci on}; end; end; %sumamos en una uni dad l a var i abl e j  j = j + 1;

%añadi mos el ul t i mo el ement o a l a cel da cel da( j ) = {' Nada' }; %obt enemos l a t r anspuest a de l a cel da cel da = cel da' ; %agr egamos l os el ement os de l a cel da a l a l i st a de par t i ci ones s et ( l i s t aPar t i ci ones , ' St r i ng' , cel da) ;

Función graficarParticiones %f unci on que gr af i ca l as part i ci ones de l a vari abl e que se est e t r atando f uncti on  gr af i car Par t i ci ones(i ndi ce, r esul t ado) %t r abaj amos con l a var i abl e gl obal f i s gl obal   f i s; %t r abaj amos con l a var i abl e gl obal gr ado de pr eci si on gl obal   gr adoPr eci si on; %guar damos l os dat os necesar i os par a poder gr af i car l as par t i ci ones %en otr a vent ana ( gr af i ca. f i g) manej ador Vent anaPr i nci pal = get appdat a( 0, ' manej ador Vent anaPr i nci pal ' ) ; %guar damos el r ango de val or es de l a var i abl e set appdat a( manej ador Vent anaPr i nci pal , ' r ango' , f i s{i ndi ce}{2}) ; %guar damos l as par t i ci ones de l a var i abl e set appdat a( manej ador Vent anaPr i nci pal , ' par t i c i ones ' , f i s{i ndi ce}{3}) ; %guar damos el r esul t ado de l a i nf erenci a set appdat a( manej ador Vent anaPr i nci pal , ' r esul t ado' , r e sul t ado) ; %abr i mos l a vent ana gr af i ca. f i g par a gr af i car l as par t i ci ones wi nopen( ' gr af i ca. f i g' ) ;

Función actualizarListaReglas %f unci on que act ual i za l a l i st a de r egl as de l a vent ana f uncti on actual i zar Li st aRegl as( handl es) %t r abaj amos con l a var i abl e gl obal f i s gl obal   f i s; %i ni ci al i zamos una obj et o t i po cel da para al macenar l as r egl as l i s t aRegl as = c el l ( 1, s i z e( f i s {4}, 2) ) ; %r ecor r emos t odas l as r egl as del si st ema de i nf erenci a f or   i = 1: 1: si ze( l i staRegl as, 2) %def i ni mos una sal i da ( vi sual ) de l a r egl a ' . I f . . . ' sal i daRegl a = st r cat ( mat 2st r ( i ) , ' . I f ' , {' ' } ) ; %r ecor r emos t odas l as part i ci ones i nvol ucr adas en l a regl a f or   j = 1: 1: si ze( f i s{4}{i }, 2) %si es l a par t i ci on de l a var i abl e de sal i da, ent onces i f ( j == si ze( f i s{4}{i }, 2) ) %l a sal i da es ' t hen . . . ' sal i daRegl a = st r cat ( sal i daRegl a, {' ' }, ' t hen' , {' ' } ) ; end; %si l a part i ci on es negati va, ent onces i f ( f i s{4}{i }( j ) < 0) %l a s al i da es ' i s not . . . ' sal i daRegl a = st r cat ( sal i daRegl a, ' ( ' , f i s {j }{1}, {' ' }, ' i s not ' , {' ' }, f i s{j }{3}{abs( f i s{4}{i }( j ) ) }{1}, ' ) ' ) ; %si l a par t i ci on es posi t i va, ent onces el s ei f  ( f i s{4}{i }( j ) > 0)

%l a s al i da es ' i s . . . ' sal i daRegl a = st r cat ( sal i daRegl a, ' ( ' , f i s {j }{1}, {' ' }, ' i s ' , {' ' }, f i s{j }{3}{f i s{4}{i }( j ) }{1}, ' ) ' ) ; end; %si es l a pr i mer a par t i ci on y es di st i nt a de cer o, y l a si gui ent e %part i ci on es di st i nt a de cer o, ent onces i f ( j == 1 && f i s{4}{i }( j ) ~= 0 && f i s{4}{i }( j + 1) ~= 0) %l a sal i da es ' and. . . ' sal i daRegl a = st r cat ( sal i daRegl a, {' ' }, ' and' , {' ' } ) ; end; end; %agr egamos l a r egl a a l a l i st a de r egl as l i staRegl as(i ) = sal i daRegl a; end; %most r amos l as r egl as en set ( handl es. l i staRegl as, %sel ecci onamos el ul t i mo set ( handl es. l i staRegl as,

l a l i st a de l a vent ana ' St r i ng' , l i s t aRegl as ) ; el ement o de l a l i st a ' Val ue' , s i z e( l i s t aRegl as , 2) ) ;

Función obtenerGradoPertenencia %f unci on que obt i ene el gr ado de per t enenci a dado un x f uncti on gr adoPer t enenci a = obt ener Gr adoPer t enenci a(i ndi ceVari abl e, i ndi cePar t i ci on, xPedi do) %t r abaj amos con l a var i abl e gl obal f i s gl obal   f i s; %t r abaj amos con l a var i abl e gl obal gr ado de pr eci si on gl obal   gr adoPr eci si on; %obt enemos l os par amet r os de l a cur va de l a par t i ci on paramet r osCur va = f i s{i ndi ceVari abl e}{3}{i ndi cePar t i ci on}{2}; %def i ni mos l os val or es de x x = f i s{i ndi ceVar i abl e}{2}( 1) : gr adoPr eci si on: f i s{i ndi ceVar i abl e}{2}( 2) ; %def i ni mos l os val or es de y y = max( mi n( ( x - par amet r osCur va( 1) ) / ( par amet r osCur va( 2) - par amet r osCur va( 1) ) , ( paramet r osCur va( 3) - x) / ( paramet r osCur va( 3) - paramet r osCur va( 2) ) ) , 0) ; %i ni ci al i zamos a cer o el gr ado de per t enenci a yPedi do = 0; %r ecor r emos t odos l os val or es del vect or x f or   i = 1: 1: si ze( x, 2) %si el val or del vect or x es mayor o i gual al val or de l a var i abl e %xPedi do, ent onces i f ( x( i ) >= xPedi do) %encont r amos el gr ado de per t enenci a yPedi do = y(i ) ; br eak; end; end;

%devol vemos el gr ado de per t enenci a gr adoPer t enenci a = yPedi do;

Función calcularInferencia %f unci on que cal cul a el si st ema de i nf er enci a f uzzy f uncti on  cal cul ar I nf er enci a( handl es) %t r abaj amos con l a var i abl e gl obal f i s gl obal   f i s; %t r abaj amos con l a var i abl e gl obal gr ado de pr eci si on gl obal   gr adoPr eci si on; %obt enemos el val or de l a pr i mer a var i abl e de ent r ada campoVal or Ent r ada1 = st r 2num( get ( handl es. campoVal or Ent r ada1, ' St r i ng' ) ) ; %obt enemos el val or de l a segunda var i abl e de ent r ada campoVal or Ent r ada2 = st r 2num( get ( handl es. campoVal or Ent r ada2, ' St r i ng' ) ) ; %si l os campos val or de ent r ada no est an vaci os, ent onces i f ( ~i sempt y( campoVal or Ent r ada1) && ~i sempt y( campoVal or Ent r ada2) ) %ubi camos l os val or es de ent r ada en un vect or val or Ent r adas = [ campoVal or Ent r ada1, campoVal or Ent r ada2] ; %i ni ci al i zamos el vect or que al macenar a el gr ado de pert enenci a de %cada r egl a gr adoPer t enenci aRegl as = zer os( 1, si ze( f i s{4}, 2) ) ; %r ecor r emos t odas l as r egl as del si st ema de i nf erenci a f or   i = 1: 1: si ze( gr adoPer t enenci aRegl as, 2) %i ni ci al i zamos un cont ador k k = 0; %i ni ci al i zamos el vect or que al macena el gr ado de pert enenci a de %cada par t i ci on gr adoPer t enenci aPar t i ci ones = [ ] ; %r ecor r emos t odas l as part i ci ones de l a r egl a, except o de l a %var i abl e de sal i da f or   j = 1: 1: si ze( f i s{4}{i }, 2) - 1 %si l a par t i ci on es di st i nt a de cer o, ent onces i f ( f i s{4}{i }( j ) ~= 0) %agr egamos un nuevo gr ado de per t enenci a k = k + 1; %si l a part i ci on es negati va, ent onces i f ( f i s{4}{i }( j ) < 0) %el gr ado de per t enenci a es 1 - mu gr adoPert enenci aObt eni do = 1 - obt enerGr adoPert enenci a( j , abs ( f i s {4}{i }( j ) ) , val or Ent r a das ( j ) ) ; %si no el s e %el gr ado de per t enenci a es mu gr adoPer t enenci aObt eni do = obt ener Gr adoPer t enenci a(j , f i s{4}{i }( j ) , val or Ent r a das ( j ) ) ; end; %añadi mos el gr ado de pert enenci a de l a par t i ci on gr adoPert enenci aPar t i ci ones( k) = gr adoPert enenci aObt eni do; end; end;

%t omamanos el mi ni mo de l os gr ados de per t enenci a de l as %par t i ci ones ( oper aci on AND) %si l a par t i ci on de l a var i abl e de sal i da es negat i va, ent onces i f ( f i s{4}{i }( 3) < 0) %el gr ado de per t enenci a de l a r egl a es 1 - mi n gr adoPer t enenci aRegl as( i ) = 1 - mi n( gr adoPer t enenci aPar t i ci ones) ; %si no el s e %el gr ado de per t enenci a de l a r egl a es mi n gr adoPer t enenci aRegl as( i ) = mi n( gr adoPer t enenci aPart i ci ones) ; end; end; %def i ni mos l os val or es de x x = f i s{3}{2}( 1) : gr adoPr eci si on: f i s{3}{2}( 2) ; %def i ni mos una var i abl e y auxi l i ar yAuxi l i ar = cel l ( 1, si ze( gr adoPer t enenci aRegl as, 2) ) ; %r ecor r emos el grado de per t enenci a de t odas l as r egl as f or   i = 1: 1: si ze( gr adoPer t enenci aRegl as, 2) %obt enemos l os par amet r os de l a cur va de l a par t i ci on i nvocl ucr ada %en l a vari abl e de sal i da par amet r osCur va = f i s{3}{3}{abs( f i s{4}{i }( 3) ) }{2}; yAct ual = max( mi n( ( x - par amet r osCur va( 1) ) / ( par amet r osCur va( 2) paramet r osCur va( 1) ) , ( paramet r osCur va( 3) - x) / ( par amet r osCur va( 3) par amet r osCur va( 2) ) ) , 0) ; %r ecor r emos t odos l os val or es del vect or yAct ual f or   j = 1: 1: si ze( yActual , 2) %si el val or del vect or es mayor al gr ado de pert enenci a de l a %r egl a, ent onces i f ( yAct ual ( j ) > gr adoPer t enenci aRegl as( i ) ) %l e asi gnamos el val or del gr ado de pert enenci a de l a r egl a yAct ual ( j ) = gr adoPer t enenci aRegl as( i ) ; end; end; %añadi mos a l a cel da un nuevo vect or de val or es y yAuxi l i ar {i } = yAct ual ; end; %def i ni mos l os val or es de y y = zer os( 1, si ze( yAuxi l i ar {1}, 2) ) ; %r ecor r emos t odos l os val or es de y f or   i = 1: 1: si ze( y, 2) %def i ni mos un vect or par a al macenar l os val or es i de cada vect or %al macenado en l a cel da yAuxi l i ar val or esY = zer os(1, si ze( yAuxi l i ar , 2) ) ; %r ecor r emos l os val or es i de cada vect or f or   j = 1: 1: s i z e( yAuxi l i ar , 2) %añadi mos el val or i al vect or val oresY val or e sY( j ) = yAuxi l i ar {j }( i ) ; end; %t omamos el maxi mo de l os val or es del vect or ( Mamdani ) y(i ) = max(val or esY) ;

end; %cal cul amos el ar ea t ot al areaTot al = sum( y) ; %si el ar ea tot al es di st i nt o de cer o, ent onces i f ( ar eaTot al ~= 0) %el r esul t ado r esul t adoFi nal %si no el s e %el r esul t ado r esul t adoFi nal

f i nal es: = sum( y. *x) / ar eaTot al ;

f i nal es cer o = ar eaTot al ;

end; %most r amos el r esul t ado en el campo r esul t ado de l a vent ana set ( handl es. campoResul t ado, ' St r i ng' , r e sul t adoFi nal ) ; end;

Función figure1_CreateFcn % - - - Execut es dur i ng obj ect creat i on, af t er set t i ng al l pr oper t i es. f uncti on  f i gur e1_Cr eat eFcn( hObj ect , event data, handl es) %l l amada a l a f unci on que i ni ci al i za el si st ema de i nf er enci a f uzzy i ni c i al i z ar Si s t emaI nf er e nc i a( ) ; %conf i gur amos l o necesar i o par a habi l i t ar l a comuni caci on ent r e l a vent ana %ej er c i c i o1. f i g y gr a f i c a. f i g setappdata( 0, ' manej ador Vent anaPr i nci pal ' , gcf ) ;

Función botonCargar1_Callback % - - - Execut es on but t on pr ess i n botonCargar 1. f uncti on botonCar gar1_Cal l back( hObj ect , event data, handl es) %t r abaj amos con l a var i abl e gl obal f i s gl obal   f i s; %obt enemos el nombr e de l a pr i mer a var i abl e de ent r ada campoNombr eEnt r ada1 = get ( handl es. campoNombr eEnt r ada1, ' St r i ng' ) ; %obt enemos el r ango de val or es de l a pr i mer a var i abl e de ent r ada campoRangoEnt r ada1 = st r 2num( get ( handl es. campoRangoEnt r ada1, ' St r i ng' ) ) ; %añadi mos l a pr i mera var i abl e de ent r ada al si st ema de i nf erenci a f uzzy f i s{1} = {campoNombr eEnt r ada1, campoRangoEnt r ada1}; %l l amada a l a f unci on que agr ega l as par t i ci ones agr egar Par t i ci ones( 1, 1, handl es) ; %modi f i camos el t ext o si . . . es set ( handl es. t exto1, ' St r i ng' , s t r c at ( ' s i ' , {' ' }, campoNombr eEnt r ada1, {' ' }, ' es ' ) ) ; %hacemos vi si bl e el t ext o set ( handl es. t exto1, ' Vi s i bl e' , ' on' ) ;

Función botonGraficar1_Callback % - - - Execut es on but t on pr ess i n botonGr af i car 1. f uncti on  botonGr af i car 1_Cal l back( hObj ect , event data, handl es)

%l l amada a l a f unci on que gr af i ca l as part i ci ones gr af i car Par t i ci ones ( 1, [ ] ) ;

Función botonCargar2_Callback % - - - Execut es on but t on pr ess i n botonCargar 2. f uncti on botonCar gar2_Cal l back( hObj ect , event data, handl es) %t r abaj amos con l a var i abl e gl obal f i s gl obal   f i s; %obt enemos el nombr e de l a segunda var i abl e de ent r ada campoNombr eEnt r ada2 = get ( handl es. campoNombr eEnt r ada2, ' St r i ng' ) ; %obt enemos el r ango de val or es de l a segunda var i abl e de ent r ada campoRangoEnt r ada2 = st r 2num( get ( handl es. campoRangoEnt r ada2, ' St r i ng' ) ) ; %añadi mos l a segunda var i abl e de ent r ada al si st ema de i nf erenci a f uzzy f i s{2} = {campoNombr eEnt r ada2, campoRangoEnt r ada2}; %l l amada a l a f unci on que agr ega l as par t i ci ones agr egar Par t i ci ones( 2, 2, handl es) ; %modi f i camos el t ext o y . . . es set ( handl es. t exto2, ' St r i ng' , s t r c at ( ' y' , {' ' }, campoNombr eEnt r ada2, {' ' }, ' es ' ) ) ; %hacemos vi si bl e el t ext o set ( handl es. t exto2, ' Vi s i bl e' , ' on' ) ;

Función botonGraficar2_Callback % - - - Execut es on but t on pr ess i n botonGr af i car 2. f uncti on  botonGr af i car 2_Cal l back( hObj ect , event data, handl es) %l l amada a l a f unci on que gr af i ca l as part i ci ones gr af i car Par t i ci ones ( 2, [ ] ) ;

Función botonCargar3_Callback % - - - Execut es on but t on pr ess i n botonCargar 3. f uncti on botonCar gar3_Cal l back( hObj ect , event data, handl es) %t r abaj amos con l a var i abl e gl obal f i s gl obal   f i s; %obt enemos el nombr e de l a var i abl e de sal i da campoNombr eSal i da = get ( handl es. campoNombr eSal i da, ' St r i ng' ) ; %obt enemos el r ango de val or es de l a var i abl e de sal i da campoRangoSal i da = st r 2num( get ( handl es. campoRangoSal i da, ' St r i ng' ) ) ; %añadi mos l a vari abl e de sal i da al si st ema de i nf er enci a f uzzy f i s{3} = {campoNombr eSal i da, campoRangoSal i da}; %l l amada a l a f unci on que agr ega l as par t i ci ones agr egar Par t i ci ones( 3, 3, handl es) ; %modi f i camos el t ext o ent onces . . . es set ( handl es. t exto3, ' St r i ng' , s t r c at ( ' ent onces' , {' ' }, campoNombr eSal i da, {' ' }, ' es ' ) ) ; %hacemos vi si bl e el t ext o set ( handl es. t exto3, ' Vi s i bl e' , ' on' ) ;

Función botonGraficar3_Callback % - - - Execut es on but t on pr ess i n botonGr af i car 3. f uncti on  botonGr af i car 3_Cal l back( hObj ect , event data, handl es) %l l amada a l a f unci on que gr af i ca l as part i ci ones gr af i car Par t i ci ones ( 3, [ ] ) ;

Función botonAgregarRegla_Callback % - - - Execut es on but t on pr ess i n bot onAgr egar Regl a. f uncti on bot onAgr egarRegl a_Cal l back( hObj ect , event dat a, handl es) %t r abaj amos con l a var i abl e gl obal f i s gl obal   f i s; %t r abaj amos con l a var i abl e gl obal numer o de r egl as gl obal   numer oRegl as; %obt enemos l a par t i ci on sel ecci onada en l a pr i mera var i abl e de ent r ada numer oPar t i ci on1 = get ( handl es. l i st aPar t i ci ones1, ' Val ue' ) ; %obt enemos l a par t i ci on sel ecci onada en l a segunda var i abl e de ent r ada numer oPar t i ci on2 = get ( handl es. l i st aPar t i ci ones2, ' Val ue' ) ; %obt enemos l a part i ci on sel ecci onada en l a vari abl e de sal i da numer oPar t i ci on3 = get ( handl es. l i st aPar t i ci ones3, ' Val ue' ) ; %obt enemos l a l i st a de par t i ci ones de l a pr i mera var i abl e de ent r ada l i staPar t i ci ones1 = get ( handl es. l i staPar t i ci ones1, ' St r i ng' ) ; %obt enemos l a l i st a de par t i ci ones de l a segunda vari abl e de ent r ada l i staPar t i ci ones2 = get ( handl es. l i staPar t i ci ones2, ' St r i ng' ) ; %obt enemos l a l i st a de part i ci ones de l a var i abl e de sal i da l i staPar t i ci ones3 = get ( handl es. l i staPar t i ci ones3, ' St r i ng' ) ; %obt enemmos el val or del checkbox de l a pr i mer a vari abl e de ent r ada oper aci onNot 1 = get ( handl es. checkNot 1, ' Val ue' ) ; %obt enemmos el val or del checkbox de l a segunda var i abl e de ent r ada oper aci onNot 2 = get ( handl es. checkNot 2, ' Val ue' ) ; %obt enemmos el val or del checkbox de l a var i abl e de sal i da oper aci onNot 3 = get ( handl es. checkNot 3, ' Val ue' ) ; %si el usuar i o sel ecci ona l a ul t i ma opci on de l a l i st a de par t i ci ones %de l a pr i mer a var i abl e de ent r ada, ent onces i f ( si ze( l i st aPar t i ci ones1, 1) == numer oPar t i ci on1) %no hacer nada numer oPar t i ci on1 = 0; %si no, si el usuar i o sel ecci ona una par t i ci on, ent onces el s e %compr obar si el usuar i o mar ca el oper ador NOT i f ( oper aci onNot 1 == 1) %ent onces es menos l a par t i ci on numeroPar t i ci on1 = - numeroPar t i ci on1; end; end; %si el usuar i o sel ecci ona l a ul t i ma opci on de l a l i st a de par t i ci ones %de l a segunda var i abl e de ent r ada, ent onces i f ( si ze( l i st aPar t i ci ones2, 1) == numer oPar t i ci on2) %no hacer nada numer oPar t i ci on2 = 0; %si no, si el usuar i o sel ecci ona una par t i ci on, ent onces el se

%compr obar si el usuar i o mar ca el oper ador NOT i f ( oper aci onNot 2 == 1) %ent onces es menos l a par t i ci on numeroPar t i ci on2 = - numeroPar t i ci on2; end; end; %si el usuar i o sel ecci ona l a ul t i ma opci on de l a l i st a de par t i ci ones %de l a vari abl e de sal i da, ent onces i f ( si ze( l i st aPar t i ci ones3, 1) == numer oPar t i ci on3) %no hacer nada numer oPar t i ci on3 = 0; %si no, si el usuar i o sel ecci ona una par t i ci on, ent onces el s e %compr obar si el usuar i o mar ca el oper ador NOT i f ( oper aci onNot 3 == 1) %ent onces es menos l a par t i ci on numeroPar t i ci on3 = - numeroPar t i ci on3; end; end; %si el usuari o sel ecci ona una part i ci on de l a var i abl e de sal i da ( que no %sea ' nada' ) , ent onces i f ( numer oPar t i ci on3 ~= 0) %ar mamos l a nueva r egl a nuevaRegl a = [ numer oPar t i ci on1 numer oPar t i ci on2 numer oPar t i ci on3] ; %añadi mos l a nueva r egl a al si st ema de i nf erenci a f uzzy numer oRegl as = numer oRegl as + 1; f i s{4}{numer oRegl as} = nuevaRegl a; %l l amada a l a f unci on que act ual i za l a l i st a de r egl as de l a vent ana actual i zar Li st aRegl as( handl es) ; %deshabi l i t amos t odos l os bot ones car gar f or   i = 1: 1: 3 botonCargar = eval ( st r cat ( ' handl es. botonCargar ' , num2s t r ( i ) ) ) ; set( botonCargar , ' Enabl e' , ' of f ' ) ; end; end;

Función botonEliminarRegla_Callback % - - - Execut es on but t on pr ess i n bot onEl i mi narRegl a. f uncti on  botonEl i mi nar Regl a_Cal l back( hObj ect , event data, handl es) %t r abaj amos con l a var i abl e gl obal f i s gl obal   f i s; %t r abaj amos con l a var i abl e gl obal numer o de r egl as gl obal   numer oRegl as; %obt enemos l a r egl a sel ecci onada en l a l i st a de l a vent ana numeroRegl a = get ( handl es. l i st aRegl as, ' Val ue' ) ;

%bor r amos l a r egl a sel ecci onada del si st ema de i nf er enci a f uzzy numer oRegl as = numer oRegl as - 1; f or   i = numer oRegl a: 1: ( si ze( f i s{4}, 2) - 1) f i s{4}( i ) = f i s{4}( i + 1) ; end; %bor r amos el ul t i mo el ement o de l a cel a donde se encuent r an l as r egl as f i s {4}( s i z e( f i s {4}, 2) ) = [ ] ; %l l amada a l a f unci on que act ual i za l a l i st a de regl as de l a vent ana actual i zar Li st aRegl as( handl es) ;

Función botonCalcular_Callback % - - - Execut es on but t on pr ess i n bot onCal cul ar. f uncti on  botonCal cul ar _Cal l back( hObj ect , event data, handl es) %l l amada a l a f unci on que cal cul a el si st ema de i nf er enci a f uzzy cal cul ar I nf er enci a( handl es);

Función botonGraficar_Callback % - - - Execut es on but t on pr ess i n bot onGr af i car . f uncti on  botonGr af i car _Cal l back( hObj ect , event data, handl es) %l l amada a l a f unci on que gr af i ca el r esul t ado gr af i car Par t i ci ones( 3, get ( handl es. campoResul t ado, ' St r i ng' ) ) ;

Función botonLimpiar_Callback % - - - Execut es on but t on pr ess i n bot onLi mpi ar. f uncti on  botonLi mpi ar_Cal l back( hObj ect , event data, handl es) %t r abaj amos con l a var i abl e gl obal f i s gl obal   f i s; %l i mpi amos t odos l os campos de l a vent ana f or   i = 1: 1: 2 campoNombr eEnt r ada = eval ( st r cat ( ' handl es. campoNombr eEnt r ada' , num2s t r ( i ) ) ) ; campoRangoEnt r ada = eval ( st r cat ( ' handl es. campoRangoEnt r ada' , num2s t r ( i ) ) ) ; campoVal or Ent r ada = eval ( st r cat ( ' handl es. campoVal or Ent r ada' , num2s t r ( i ) ) ) ; set ( campoNombr eEnt r ada, ' St r i ng' , ' ' ) ; set ( campoRangoEnt r ada, ' St r i ng' , ' ' ) ; set ( campoVal or Ent r ada, ' St r i ng' , ' ' ) ; end; f or   i = 1: 1: 3 bot onCargar = eval ( st r cat ( ' handl es. botonCargar ' , num2s t r ( i ) ) ) ; t exto = eval ( st r cat ( ' handl es. t ext o' , num2s t r ( i ) ) ) ; l i staPar t i ci ones = eval ( str cat ( ' handl es. l i staPar t i ci ones' , num2s t r ( i ) ) ) ; checkNot = eval ( st r cat ( ' handl es. checkNot ' , num2s t r ( i ) ) ) ; set ( botonCargar , ' Enabl e' , ' on' ) ; set ( t ext o, ' Vi s i bl e' , ' of f ' ) ;

s et ( l i s t aPar t i ci ones , ' St r i ng' , ' ' ) ; set ( checkNot, ' Val ue' , 0) ; end; f or   i = 1: 1: 3 f or   j = 1: 1: 7 campoNombr ePar t i ci on = eval ( st r cat ( ' handl es. campoNombr ePar t i ci on' , num2str ( i ) , num2str ( j ) ) ) ; campoPar amet r osPar t i ci on = eval ( st r cat ( ' handl es. campoPar amet r osPar t i ci on' , num2str ( i ) , num2str ( j ) ) ) ; set ( campoNombr ePar t i ci on, ' St r i ng' , ' ' ) ; set ( campoPar amet r osPar t i ci on, ' St r i ng' , ' ' ) ; end; end; set ( handl es. campoNombr eSal i da, ' St r i ng' , ' ' ) ; set ( handl es. campoRangoSal i da, ' St r i ng' , ' ' ) ; set ( handl es. l i staRegl as, ' St r i ng' , ' ' ) ; set ( handl es. campoResul t ado, ' St r i ng' , ' ' ) ; %r eset eamos el si st ema de i nf erenci a f uzzy i ni c i al i z ar Si s t emaI nf er e nc i a( ) ;

 Archivo grafica.m: Función graficarParticiones %f unci on que gr af i ca l as part i ci ones de l a vari abl e que se est e t r atando f uncti on gr af i car Par t i ci ones(r ango, par t i ci ones, r esul t ado) %t r abaj amos con l a var i abl e gl obal gr ado de pr eci si on gl obal   gr adoPr eci si on; %habi l i t amos l a super posi ci on de gr af i cos hol d on; %def i ni mos l os col ores de t r azo para l as gr af i cas col or esTr azo = {[ 0 0 1] , [ 0 1 0] , [ 0 1 1] , [ 0. 5 0 0] , [ 0. 5 0 1] , [ 1 0 1] , [ 1 1 0] }; %r ecor r emos t odas l as part i ci ones de l a vari abl e f or   i = 1: 1: si ze( par t i ci ones, 2) %obt enemos l os par amet r os de l a gr af i ca paramet r osGr af i ca = par t i ci ones{i }{2}; %def i ni mos l os val or es de x x = r ango( 1) : gr adoPr eci si on: r ango( 2) ; %def i ni mos l os val or es de y y = max( mi n( ( x - paramet r osGr af i ca( 1) ) / ( paramet r osGr af i ca( 2) par amet r osGr af i ca( 1) ) , ( par amet r osGr af i ca( 3) - x) / ( par amet r osGr af i ca( 3) par amet r osGr af i ca( 2) ) ) , 0) ; %gr af i camos l a par t i ci on pl ot ( x, y, ' Col or ' , col or esTr azo{i }) ; %col ocamos un t ext o sobr e l a gr af i ca t ext( ( par amet r osGr af i ca( 2) - l engt h( par t i ci ones{i }{1}) / ( 2 * l engt h( par t i ci ones{i }{1}) ) ) , ( 1 + 0. 05) , par t i ci ones{i }{1}) ;

end; %si l a var i abl e r esul t ado no est a vaci a, ent onces i f ( ~i sempt y( r esul t ado) ) %def i ni mos l os val or es de y y = 0: gr adoPr eci si on: 1; %gr af i camos el r esul t ado pl ot ( st r 2num( r esul t ado) , y, ' r ' ) ; end; %def i ni mos l os l i mi t es del ej e y yl i m( [ - 0. 1 1. 1] ) ;

Función figure1_CreateFcn % - - - Execut es dur i ng obj ect creat i on, af t er set t i ng al l pr oper t i es. f uncti on  f i gur e1_Cr eat eFcn( hObj ect , event data, handl es) %decl ar amos l a var i abl e gr ado de pr eci si on como gl obal gl obal   gr adoPr eci si on; %i ni ci al i zamos el gr ado de pr eci si on gr adoPr eci si on = 0. 001; %conf i gur amos l o necesar i o par a habi l i t ar l a comuni caci on ent r e l a vent ana %ej er c i c i o1. f i g y gr a f i c a. f i g manej ador Vent anaPr i nci pal = get appdat a( 0, ' manej adorVent anaPr i nci pal ' ) ; %obt enemos l a var i abl e r ango r ango = get appdat a( manej ador Vent anaPr i nci pal , ' r ango' ) ; %obt enemos l a var i abl e par t i ci ones par t i ci ones = get appdat a( manej ador Vent anaPr i nci pal , ' par t i c i ones ' ) ; %obt enemos l a var i abl e r esul t ado r esul t ado = get appdat a( manej ador Vent anaPr i nci pal , ' r esul t ado' ) ; %l l amada a l a f unci on que gr af i ca l as part i ci ones gr af i car Par t i ci ones(r ango, par t i ci ones, r esul t ado) ;

Problema 2 – Sistema FIS genérico (3 ptos.)

Diseñar un script que configure un sistema de inferencia fuzzy para un problema genérico que contiene tres variables, dos de entrada (x, y) y una de salida (z). Las variables (x, y, z) toman valores en el intervalo [0,10]. El script debe utilizar las funciones del toolbox fuzzy y responder a los requerimientos que se indican: •

Debe solicitar el tipo de función de pertenencia a utilizar, la misma para todas las variables. Se recomienda trabajar con triángulos y gaussianas.

•

Debe solicitar la cantidad de particiones, entre tres, cinco y siete.

•

Debe solicitar el porcentaje de solapamiento (ej. 20%, 50% y 80%).

•

•

•

Las funciones se dispondrán igualmente espaciadas sobre el universo de cada variable, solapadas según el porcentaje indicado. Los vértices de la primera y última función deben coincidir con los extremos del universo de cada variable. Utilizar como base de reglas, las mostradas en el paper DERIVACIÓN DE REGLAS DE CONTROL MIMO PARA UN CONTROLADOR FUZZY SIN CONOCIMIENTO EXPERTO, para tres, cinco y siete particiones. Debe graficarse la función de transferencia z =  f(x,y).

A partir de la función de transferencia z =  f(x,y) establecer conclusiones de cómo afecta el grado de solapamiento, la cantidad de particiones y el tipo de función de pertenencia sobre la salida del sistema. FUNCIONAMIENTO DEL SCRIPT.

Como caso de uso, para mostrar el funcionamiento del script, se seleccionó el problema del hotel. El problema utiliza dos variables de entrada y una única variable de salida. Dado un número entre 0 y 10 que representa la comodidad de la cama del hotel (donde 10 es excelente), y otro número entre 0 y 10 que representa la calidad del desayuno (donde de nuevo 10 es excelente), ¿Cómo es el servicio del hotel? Antes de nada escribimos las reglas de inferencia del problema: 1. Si la cama es incomoda o el desayuno es horrible, entonces el servicio es malo. 2. Si la cama es normal, entonces el servicio es normal.

3. Si la cama es cómoda o el desayuno es delicioso, entonces el servicio es bueno. Aclaradas y definidas las reglas de inferencia (y otras cuestiones) se procede a utilizar el programa.

Escribimos en la ventana de comandos de MatLab el comando “ejercicio2”.

Y vemos la siguiente salida.

Ahora, escribimos el nombre de la primera variable de entrada y un valor para la misma. En nuestro problema el nombre de la primera variable de entrada es “cama” y un valor puede ser 7 por ejemplo. Entonces tenemos.

Presionamos la tecla “ENTER” y hacemos lo mismo para la segunda variable de entrada, considerando que el nombre de la segunda variable de entrada es “desayuno” y el valor es 8 (por ejemplo). Entonces tenemos.

Presionamos la tecla “ENTER” y escribimos el nombre de la variable de salida, el nombre de la misma es “servicio”. Entonces tenemos.

Presionamos la tecla “ENTER” y vemos la siguiente salida.

Ahora, elegimos alguna función de pertenencia de las dos que muestra el programa. Si queremos utilizar la función triangular escribimos “1” sino escribimos “2”. En nuestro caso utilizaremos una función triangular.

Presionamos la tecla “ENTER” y vemos la siguiente salida.

Ahora, elegimos el número de particiones que tendrán todas las variables del sistema. Escribimos “1” si queremos 3 (tres) particiones, “2” si queremos 5 (cinco), “3” si queremos 7 (siete). Para nuestro ejemplo elegiremos solamente 3 (tres) particiones.

Presionamos la tecla “ENTER” y obtenemos la siguiente salida.

Ahora, escribimos el porcentaje de solapamiento, tomaremos un solapamiento del 20%.

Presionamos la tecla “ENTER” y vemos la siguiente salida.

Ahora, escribimos el nombre de cada una de las 3 (tres) particiones que forman parte de la primera variable de entrada (la variable “cama”). Para nuestro problema, el nombre de la partición 1 es “incomoda”, de la partición 2 es “normal” y de la partición 3 es “cómoda”. Entonces tenemos.

Presionamos la tecla “ENTER” y hacemos lo mismo para la segunda variable de entrada (la variable desayuno), considerando que el nombre de la partición 1 es “horrible”, de la partición 2 es “normal” y de la partición 3 es “delicioso”. Entonces tenemos.

Presionamos la tecla “ENTER” y lo mismo para la variable de salida (la variable servicio), el nombre de la partición 1 es “malo”, de la partición 2 es “normal” y de la partición 3 es “bueno”. Entonces tenemos.

Presionamos la tecla “ENTER” y vemos la siguiente salida.

Luego, introducimos las reglas de nuestro sistema de inferencia. Las reglas deben tener el siguiente formato: [particionVarEntrada1, particionVarEntrada2, particionVarSalida, operacionLogica] donde, •

•

•

•

“particionVarEntrada1” es el número de partición correspondiente a la primera variable de entrada. Si se quiere negar éste antecedente, operación lógica NOT, se coloca el signo “-” (menos) acompañado del número de partición. También se puede excluir el antecedente colocando un número “0” (cero). “particionVarEntrada2” es el número de partición correspondiente a la segunda variable de entrada. Si se quiere negar éste antecedente, operación lógica NOT, se coloca el signo “-” (menos) acompañado del número de partición. También se puede excluir el antecedente colocando un número “0” (cero). “particionVarSalida” es el número de partición correspondiente a la variable de salida. Si se quiere negar éste consecuente, operación lógica NOT, se coloca el signo “-” (menos) acompañado del número de partición. Es importante recalcar que no se puede excluir el consecuente. “operacionLogica” es el número correspondiente al tipo de operación lógica a realizar con los antecedentes. “1” si trata de una operación lógica AND o “2” si se trata de una operación lógica OR.

Entonces, las reglas mencionadas al principio quedarían expresadas en la consola de la siguiente manera.

Finalmente, presionamos la tecla “ENTER” y el programa nos muestra el valor de la variable de salida en relación a los valores asignados a la primera y segunda variable de entrada.

Además, el programa nos muestra la siguiente gráfica de superficie.

Si abrimos el archivo generado por el script podemos observar como las particiones de cada variable están solapadas un 20%. Las siguientes figuras describen tal situación.

La siguiente captura visualiza las reglas de nuestro sistema de inferencia, las cuales coinciden con las enunciadas en nuestro problema de ejemplo.

CÓDIGO FUENTE DEL SCRIPT.  Archivo ejercicio2.m: %cerr amos t odas l as vent anas, bor r amos t odas l as var i abl es y l i mpi amos l a %consol a cl ose al l ; cl ear ; cl c; %def i ni mos un nombr e par a el ar chi vos f i s nombr eAr chi vo = ' ej er c i ci o2' ; %cr eamos un nuevo si st ema de i nf er enci a f uzzy f i s = newf i s( nombr eAr chi vo) ; %el met odo de def uzzi f i caci on es el del cent r oi de f i s = set f i s( f i s, ' def uzzmet hod' , ' cent r oi d' ) ; %def i ni mos el r ango de val ores de l as vari abl es i nvol ucr adas r angoVal or es = [ 0 10] ; %def i ni mos un vect or que cont endr a l os t i pos de f unci ones de pert enenci a f unci onesPert enenci a = {' t r i mf ' , ' gaussmf ' }; %def i ni mos un vect or que cont endr a l os numer os de par t i ci ones numer osPar t i ci ones = [ 3, 5, 7] ; %def i ni mos un obj et o t i po cel da par a al macenar l os nombr es de l as var i abl es nombr eVari abl es = cel l ( 1, 3) ; %sal i da en consol a f pr i nt f ( ' Pr i mer a var i abl e de ent r ada: \ n' ) ; f pr i nt f ( ' \ t Nombr e: ' ) ; %pedi mos al usuar i o el nombr e de l a pr i mer a var i abl e de ent r ada nombr eVar i abl es{1} = i nput ( ' ' , ' s' ) ; %sal i da en consol a f pr i nt f ( ' \ t Val or : ' ) ; %pedi mos al usuar i o el val or de l a pr i mera var i abl e de ent r ada val orVari abl eEnt r ada1 = i nput ( ' ' ) ; %sal i da en consol a f pr i nt f ( ' \ nSegunda var i abl e de ent r ada: \ n' ) ; f pr i nt f ( ' \ t Nombr e: ' ) ; %pedi mos al usuar i o el nombr e de l a segunda var i abl e de ent r ada nombr eVar i abl es{2} = i nput ( ' ' , ' s' ) ; %sal i da en consol a f pr i nt f ( ' \ t Val or : ' ) ; %pedi mos al usuar i o el val or de l a segunda var i abl e de ent r ada val orVari abl eEnt r ada2 = i nput ( ' ' ) ; %sal i da en consol a f pr i nt f ( ' \ nVar i abl e de sal i da: \ n' ) ; f pr i nt f ( ' \ t Nombr e: ' ) ; %pedi mos al usuar i o el nombr e de l a var i abl e de sal i da nombr eVar i abl es{3} = i nput ( ' ' , ' s' ) ; %r ecor r emos t odas l as var i abl es f or   i = 1: 1: si ze( nombr eVar i abl es, 2) %si es una var i abl e de ent r ada, ent onces i f ( i < si ze( nombr eVar i abl es, 2) ) %agr egamos una var i abl e de ent r ada al si st ema de i nf er enci a f i s = addvar ( f i s, ' i nput ' , nombr eVari abl es{i }, r angoVal ores) ; %si no el s e %agr egamos una var i abl e de sal i da al si st ema de i nf erenci a f i s = addvar ( f i s, ' out put ' , nombr eVari abl es{i }, r angoVal ores) ; end;

end; %sal i da en consol a f pr i nt f ( ' \ nFunci on de per t enenci a: ' ) ; f pr i nt f ( ' \ n\ t ( 1) Tr i angul ar ' ) ; f pr i nt f ( ' \ n\ t ( 2) Gaussi ana' ) ; f pr i nt f ( ' \ nOpci on: ' ) ; %pedi mos al usuari o que i ngr ese l a f unci on de per t enenci a a ut i l i zar t i poFunci onPer t enenci a = i nput ( ' ' ) ; %sal i da en consol a f pr i nt f ( ' \ nCant i dad de par t i ci ones: ' ) ; f pr i nt f ( ' \ n\ t ( 1) T r es ' ) ; f pr i nt f ( ' \ n\ t ( 2) Ci nco' ) ; f pr i nt f ( ' \ n\ t ( 3) Si et e' ) ; f pr i nt f ( ' \ nOpci on: ' ) ; %pedi mos al usuar i o que i ngr ese l a cant i dad de par t i ci ones cant i dadPar t i ci ones = i nput ( ' ' ) ; %sal i da en consol a f pr i nt f ( ' \ nPor cent aj e de sol apami ent o: ' ) ; %pedi mos al usuar i o que i ngr ese el por cent aj e de sol apami ent o por cent aj eSol apami ent o = i nput ( ' ' ) ; %l l amamos a l a f unci on obt ener Par t i ci ones par a obt ener l as part i ci ones con %sus r espect i vos par amet r os ( sol apados con el por cent aj e i ndi cado) par t i ci onesSi st ema = obt ener Par t i ci ones( numer osPar t i ci ones( cant i dadPar t i ci ones) , porcent aj eSol apami ent o, f unci onesPer t enenci a{t i poFunci onPer t enenci a}) ; %r ecor r emos t odas l as var i abl es f or   i = 1: 1: si ze( nombr eVar i abl es, 2) %sal i da en consol a f pr i nt f ( ' \ nPar t i ci ones de l a var i abl e %s: \ n' , nombr eVari abl es{i }) ; %r ecor r emos t odas l as part i ci ones de l a vari abl e f or   j = 1: 1: numer osPar t i ci ones( cant i dadPar t i ci ones) %sal i da en consol a f pr i nt f ( ' \ t Nombr e de l a part i ci on %d: ' , j ) ; %pedi mos al usuar i o el nombr e de l a par t i ci on nombr ePar t i ci on = i nput ( ' ' , ' s' ) ; %si es una var i abl e de ent r ada, ent onces i f ( i < si ze( nombr eVar i abl es, 2) ) %agr egamos una par t i ci on de ent r ada al si st ema de i nf er enci a f i s = addmf ( f i s, ' i nput ' , i , nombr ePar t i ci on, f unci onesPer t enenci a{t i poFunci onPer t enenci a}, part i ci onesSi st ema{j }) ; %si no el s e %agr egamos una par t i ci on de sal i da al si st ema de i nf erenci a f i s = addmf ( f i s, ' out put ' , 1, nombr ePar t i ci on, f unci onesPer t enenci a{t i poFunci onPer t enenci a}, part i ci onesSi st ema{j }) ; end; end; end; %sal i da en consol a f pr i nt f ( ' \ nRegl as: ' ) ; f pr i nt f ( ' \ n\ t For ma de l a r egl a: [ par t i ci onVar Ent r ada1, par t i ci onVar Ent r ada2, par t i ci onVar Sal i da, oper aci onLogi ca] \ n' ) ;

%def i ni mos una bander a par a el bucl e whi l e bander aBucl e = t r ue; whi l e  bander aBucl e %sal i da en consol a f pr i nt f ( ' \ t \ t Regl a: ' ) ; %pedi mos al usuar i o una r egl a r egl aSi st ema = i nput ( ' ' ) ; %si l a r egl a no est a vaci a, ent onces i f ( ~i sempt y( r egl aSi st ema)) %agr egamos una nueva r egl a al si st ema de i nf er enci a f i s = addr ul e( f i s, [ r egl aSi st ema( 1) , r egl aSi st ema( 2) , r egl aSi st ema( 3) , 1, r egl aSi st ema( 4) ] ) ; %si no el s e %sal i mos del bucl e, el usuar i o ya no qui ere i ngr esar mas r egl as banderaBucl e = f al se; end; end; %cal cul amos el si st ema de i nf erenci a f uzzy r esul t adoFi nal = eval f i s( [ val or Var i abl eEnt r ada1, val or Var i abl eEnt r ada2] , f i s) ; %sal i da en consol a f pr i nt f ( ' \ nResul t ado: %d\ n' , r e sul t adoFi nal ) ; %guar damos el f i s como un ar chi vo wr i t ef i s(f i s, nombr eAr chi vo) ; %most r amos l a gr af i ca de superf i ci e gens ur f ( f i s ) ; %abr i mos el f uzzy l ogi c t ool box con nuest r o ej empl o f uzzy(st r cat ( nombr eAr chi vo, ' . f i s ' ) ) ;

 Archivo obtenerParticiones.m: Función obtenerParticiones %f unci on que obt i ene l as part i ci ones f uncti on  part i ci ones = obt ener Par t i ci ones( numer oPart i ci ones, porcent aj eSol apami ent o, t i poFunci on) %def i ni mos el t amaño par a l a base de un t r i angul o t amanoBase = 10; %cal cul amos l a mi t ad de l a base mi t adTamanoBase = t amanoBase * 0. 5; %def i ni mos l os paramet r os del t r i angul o ubi cado mas a l a i zqui erda t r i angul oI zqui er do = [ - mi t adTamanoBase 0 mi t adTamanoBase] ; %def i ni mos l os paramet r os del t r i angul o ubi cado despues del t r i angul o %i zqui erdo t r i angul oSi gui ent e = [ mi t adTamanoBase t amanoBase ( mi t adTamanoBase * 3) ] ; %cal cul amos el area del t r i angul o ubi cado mas a l a i zqui erda areaTr i angul oI zqui erdo = mi t adTamanoBase * 0. 5 * ( por cent aj eSol apami ent o * 0. 01) ; %def i ni mos un di f er enci al de aument o di f er enci al Del t a = 0. 0; %def i ni mos un l i mi t e i nf eri or de busqueda l i mi t eI nf er i orBusqueda = 0; %def i ni mos un l i mi t e super i or de busqueda l i mi t eSuperi or Busqueda = 0;

%def i ni mos l a pr eci si on de busqueda del r esul t ado pr eci si onBusqueda = 0. 0000001; %def i ni mos un nuevo t amaño par a l a base del t r i angul o nuevoTamanoBas e = 0; %def i ni mos un obj et o t i po cel da par a al macenar l os par amet r os de cada %par t i ci on t r i angul o par t i ci onesTr i angul o = cel l ( 1, numer oPar t i ci ones) ; %busc amos l a sol uci on aument ando el val or de x de 0. 1 en 0. 1 %( hast a t amanoBase) f or   i = 1: 1: t amanoBase %aument amos el di f er enci al en 0. 1 di f er enci al Del t a = di f er enci al Del t a + 0. 1; %cal cul amos el ar ea del t r i angul o act ual ar eaTr i angul oActual = ( t r i angul oI zqui er do( 3) - ( t r i angul oSi gui ent e( 1) - i ) ) * 0. 5 * di f er enci al Del t a; %si el area del t r i angul o act ual es mayor o i gual al area del %t r i angul o i zqui er do, ent onces i f ( areaTri angul oAct ual >= areaTri angul oI zqui er do) %r est r i ngi mos l os l i mi t es de busqueda l i mi t eI nf er i or Busqueda = t r i angul oI zqui er do( 3) - ( t r i angul oSi gui ent e( 1) ( i - 1) ) ; l i mi t eSuper i or Busqueda = t r i angul oI zqui er do( 3) - ( t r i angul oSi gui ent e( 1) i); br eak; end; end; %segui mos buscando l a sol uci on per o aument ando el val or de x en un %val or mucho mas pequeño f or   i = l i mi t eI nf er i orBusqueda: pr eci si onBusqueda: l i mi t eSuper i or Busqueda %cal cul amos el ar ea del t r i angul o act ual ar eaTr i angul oActual = ( t r i angul oI zqui er do( 3) - ( t r i angul oSi gui ent e( 1) - i ) ) * 0. 5 * ( i * 0. 1) ; %si el area del t r i angul o act ual es mayor o i gual al area del %t r i angul o i zqui er do, ent onces i f ( areaTri angul oAct ual >= areaTri angul oI zqui er do) %encont r amos l a sol uci on, el nuevo t amaño de l a base del %t r i angul o es: nuevoTamanoBase = i ; br eak; end; end; %l a pr i mer a par t i ci on es el t r i angul o i zqui er do par t i ci onesTr i angul o{1} = t r i angul oI zqui er do; %movemos t odas l as par t i ci ones t r i angul o f or   i = 2: 1: numer oPart i ci ones %obt enemos l os par amet r os de l a par t i ci on ant eri or par t i ci onAnt er i or = cel l 2mat ( par t i ci onesTr i angul o( i - 1)) ; %cal cul amos el pr i mer paramet r o de l a par t i ci on ext r emoI zqui er do = par t i ci onAnt eri or ( 3) - nuevoTamanoBase; %cal cul amos el t er cer paramet r o de l a part i ci on ext r emoDer echo = t amanoBase - nuevoTamanoBase + par t i ci onAnt er i or ( 3) ;

%cal cul amos el segundo par amet r o de l a par t i ci on ext r emoMedi o = ext r emoI zqui er do + mi t adTamanoBase; %añadi mos una nueva par t ci on con l os par amet r os cal cul ados par t i ci onesTr i angul o{i } = [ ext r emoI zqui erdo ext r emoMedi o ext r emoDerecho] ; end; %obt enemos l os par amet r os de l a ul t i ma par t i ci on ul t i maPar t i ci on = cel l 2mat ( par t i ci onesTr i angul o( si ze( par t i ci onesTr i angul o, 2) ) ) ; %r edi mensi onamos t odos l as par t i ci ones t r i angul os f or   i = 1: 1: si ze( par t i ci onesTr i angul o, 2) %r edi mensi onamos el t r i angul o par t i ci onesTr i angul o{i } = cel l 2mat ( par t i ci onesTr i angul o( i ) ) * t amanoBase / ul t i maPar t i ci on( 2) ; %conver t i mos l as part i ci ones t r i angul o a al gun t i po swi t ch( t i poFunci on) %si el t i po de f unci on a conver t i r es gaussmf , ent onces case ' gauss mf ' %l a nueva par t i ci on es del t i po gaussmf  par t i ci onesTr i angul o{i } = mf 2mf ( cel l 2mat ( par t i ci onesTr i angul o( i ) ) , ' t r i mf ' , t i poFunci on) ; end; end; %devol vemos l as par t i ci ones par t i ci ones = par t i ci onesTr i angul o; end

PORCENTAJE DE SOLAPAMIENTO VS. FUNCIÓN DE PERTENENCIA. Comparativa de r esultados % 20

50

80

Triangulo

Gauss

Comparativa de gr aficas de superfici e %

Triangulo

Gauss

20

50

80

Conclusión: comparando los resultados y las gráficas de superficie, se puede observar claramente como al aumentar el porcentaje de solapamiento disminuye el resultado de la salida al defuzzificar. Esto sucede tanto para la función triangulo como para la función gaussiana.

Problema 3 – Modelo Simulink (4 ptos.)

El motor de un molino de trigo requiere, para un funcionamiento normal, el ingreso de los granos de trigo con una humedad relativa entre el 15.7 y 16.2 %. Si la humedad es baja el molino “se esfuerza” más y por lo tanto el consumo de corriente del motor principal se incrementa a 22.6 Amperes, provocando un daño permanente en el sistema, si se mantiene en esta condición durante demasiado tiempo. Por otro lado, si la humedad del trigo es alta, el consumo del motor es bajo, alrededor de los 18 Amperes. Un consumo ideal del motor oscila entre 19.2 a 21.1 Amperes. Para incrementar la humedad se emplean rociadores de agua de tipo ON-OFF. Para reducir la humedad se utiliza aire impulsado a gran velocidad por un ventilador, que es activado o desactivado según se requiera. Diseñar mediante el Fuzzy Logic Toolbox, la interfaz gráfica fuzzy y simular en el entorno de Simulink el modelo fuzzy del molino asociado a un FLC (sistema de control fuzzy), que muestre la operación del sistema completo. Debe decidir el tipo apropiado de controlador: P, PI, PD o PID. Mostrar las curvas de control según el modelo seleccionado. Nótese que se trata de un sistema con medición indirecta; no se cuenta con un medidor de humedad, pero sí con un amperímetro que indica el consumo de corriente del motor. Desarrollo:

Lo primero que hemos hecho es realizar la interfaz gráfica fuzzy de nuestro sistema en el Fuzzy Logic Toolbox, para ello: 1. Hemos creado un FIS al que hemos llamado Molino.fis (El archivo se encuentra dentro de la carpeta que contiene a este documento). En este caso, nuestro FIS recibe como entrada el consumo de corriente del motor principal y como salida tenemos el estado en el que se encuentran los rociadores o el ventilador ante dicho consumo.

2. La variable de entrada Consumo, la hemos definido en un rango que va desde los 16 Amperes hasta los 25 Amperes, ya que consideramos a este intervalo como el más significante para la operación de nuestro sistema. Hemos identificado tres conjuntos, los conjuntos Bajo y Alto son conjuntos Fuzzy con forma trapezoidal, mientras que el conjunto Ideal, es un conjunto Crisp. Se utilizó esta representación de los conjuntos para poder indicar que cuando el consumo sea mayor a 21.1 amperes entonces automáticamente se prendan los rociadores y si el consumo es menor a 19.2 amperes entonces automáticamente se prenda el ventilador. Nota: Si vamos View -> Rules (o apretamos Ctrl+5) Podemos ver cómo cambia automáticamente el estado de los rociadores o del ventilador si nos desviamos un poco del límite dado en el intervalo Ideal.

3. Las variables de Salida a las que llamamos Rociadores y Ventilador, tienen dos conjuntos Crisp, a los que llamamos Encendido y Apagado. Utilizamos esa representación para indicar que únicamente nos interesan los valores cero (para indicar que esta pagado) y uno (para indicar que esta encendido) para definir el estado de los Rociadores y del Ventilador.

4. La Base de Reglas que hemos definido para nuestro FIS es la siguiente:

Ya creado nuestro FIS nos dirigimos a Simulink para poder simular como opera nuestro Sistema. En este caso estamos hablando de un Sistema con Servo Control, el consumo ingresa, pero no hay ninguna realimentación que me permita corregir el consumo en el caso de que este sea muy elevado. Nuestro Sistema implementado en Simulink y guardado como Molino_Simulink.mdl (El archivo se encuentra dentro de la carpeta que contiene a este documento), es el siguiente:

Tenemos como entrada una señal sinusoidal con una amplitud de 4.5 amperes y un bias de 20.5 amperes dándonos el intervalo necesario para el FIS, es decir de 16 a 25 amperes. Presionamos Start Simulation y obtenemos los siguientes resultados:

Hemos definido el tiempo de Simulación en 10 segundos. Como dijimos la entrada es una señal sinusoidal definida entre 16 y 25 Amperes, como salidas tenemos señales que pueden tomar el valor 0 para indicar el estado apagado o 1 para indicar el estado encendido de los rociadores y del ventilador. Como podemos ver el sistema funciona de manera correcta pero no nos avisa en el caso de que el sistema sobrepase los 22.6 amperes, por lo que no es aconsejable esta implementación. Para ello recurrimos a la implementación de un sistema con realimentación capaz de corregirme este consumo elevado que puede llegar a dañarme el sistema. Hemos optado por utilizar un controlador P, el error ingresado es proporcional a la acción de control. La justificación de esto es clara en este caso, ya que a medida que el consumo vaya más lejos de los 22.6 amperes, la acción de control necesaria para corregir dicho consumo elevado debe también ser más grande. La recomendación era utilizar un PD, pero creemos que la respuesta que nos da este controlador es muy buena. Como no disponemos de los conceptos necesarios para el desarrollo de la función de transferencia hemos utilizado dos FIS, al primero lo llamamos MolinoP.fis y al segundo lo llamamos Corrector.fis

MolinoP.fis tiene una única variable de entrada que me representa el error entre un valor de referencia o Set Point al que hemos definido como 20.15 amperes (rango medio del conjunto de valores que forman parte del consumo ideal) y el consumo que va desde los 16 hasta los 25 amperes. Además dispone de tres variables de salida, una de ellas me representa el estado de los rociadores, la otra el estado del ventilador y la otra me representa si el sistema se encuentra o no en peligro por haber superado el límite de 22.6 amperes.

La variable de entrada Error tiene cuatro conjuntos, dos de ellos son Crisp (Peligroso e Ideal) y dos son Fuzzy (Bajo y Alto) con forma triangular. Hemos utilizado esta representación para indicar que cuando el sistema me indique un error menor o igual a -2.45 (Consumo superior a 22.6 amperes) entonces deberemos dar una señal de peligro y si es mayor a -2.45 entonces el sistema deje de estar en peligro. Además me permite indicar que mientras el error este definido entre -0.95 y 0.95 entonces nos encontremos en el estado ideal del sistema y no será necesario realizar ningún tipo de corrección sobre el mismo.

Las variables de Salida a las que llamamos Peligro, Rociadores y Ventilador, tienen dos conjuntos Crisp, a los que llamamos Encendido y Apagado para las últimas y para la primera Sí y No. Utilizamos esa representación para indicar que únicamente nos interesan los valores cero y uno para definir el estado de los Rociadores, del Ventilador y del Sistema, para poder saber si está o no, en Peligro.

La base de reglas es la siguiente :

Corrector.fis tiene una única variable de entrada que me representa el error entre un valor de referencia o Set Point al que hemos definido como 20.15 amperes y el consumo que va desde los

16 hasta los 25 amperes. Además dispone de una variable de salida que me indica la corrección a realizar sobre el consumo que ha ingresado al sistema, si el consumo supera los 22.6 amperes.

La variable de entrada dispone de tres conjuntos fuzzy con forma triangular que me indican un Error Bajo, un Error Alto y un Error Medio. Lamentablemente no disponemos de la información suficiente para definir una forma particular para las funciones de pertenencia así que hemos optado por la forma estándar que es la triangular.

La variable de salida también dispone de tres conjuntos fuzzy con forma triangular que me indican si la acción de control o la corrección sobre el consumo es Baja, Alta o Intermedia, dependiendo por supuesto del error ingresado al FIS. Lamentablemente no disponemos de la información suficiente para definir una forma particular para las funciones de pertenencia así que hemos optado por la forma estándar que es la triangular.

La base de reglas es la siguiente:

Ya creados nuestros FIS nos dirigimos a Simulink para poder simular como opera nuestro Sistema. En este caso estamos hablando de un Sistema con Realimentación, el consumo ingresa,

y dicha realimentación me permite corregir el consumo en el caso de que este sea muy elevado, es decir superior a los 22.6 amperes. Nuestro Sistema implementado en Simulink y guardado como MolinoP_Simulink.mdl (El archivo se encuentra dentro de la carpeta que contiene a este documento), es el siguiente:

El tiempo de Simulación se estableció en 30 segundos con un paso fijo de 0.1 segundos, pero, ¿Cómo opera nuestro Sistema? Primeramente generamos un error tomando el Set Point y un valor de Consumo que se genera a partir de una función sinusoidal. Se coloca posteriormente un Transport Delay para que este error salga del bloque a los 0.2 segundos dándome como salida hasta ese entonces el valor 0 que es el que tomaremos como error inicial. En base a ese error, mi sistema opera y me devuelve una salida realimentada (es decir, la acción de control) que corregirá el error que teníamos inicialmente, el sistema entonces operara nuevamente dándome una salida igual a cero, indicándome que se ha corregido el error. Después de ese lapso de tiempo de 0,2 segundos y el Transport Delay deja salir el error calculado y procederemos a corregir dicho error si es necesario. El sistema seguirá operando hasta alcanzar los 30 segundos. La grafica de Control, donde ponemos el error, expresado en amarillo y la acción de control en violeta, es la siguiente: