Sistema de inferencia difusa y redes neuronales

Reporte de practicas de Sistemas Neurodifusos 2MM6Lunes y Martes de 8:30-10:00

Nombre de la práctica: Sistema de inferencia difusa, y redes neuronales.

Fecha: 14 de noviembre de 2011Numero de practica: 2

Nombres:Real Trujillo Nora Helena

Introducción.-

Sistema de Inferencia Difusa(FIS)

Los Sistemas de Inferencia Difusa son un método que interpreta los valores de un vector de entrada y con base en un conjunto de reglas lógicas difusas, asigna valores a un vector de salida.Un sistema experto es un sistema que incorpora las reglas lógicas de un experto para apoyar decisiones, de forma autónoma, en coherencia con el conocimiento del experto.Los conjuntos difusos y los operadores difusos son como los sujetos y los verbos de la lógica difusa.Las reglas lógicas de decisión del tipo SI/ENTONCES son usadas para formular las sentencias condicionales que componen la lógica difusa.Una regla lógica SI/ENTONCES se asume que tiene la siguiente forma:

Si x es A entonces y es BDonde:A y B son valores lingüísticos definidos por los conjuntos difusos en los rangos X y Y respectivamente.“SI”: Antecedente o premisa“Entonces y es B”: consecuente o conclusión.

Redes Neuronales ArtificialesLas redes de neuronas artificiales (denominadas habitualmente como RNA o en inglés como: "ANN" ) son un paradigma de aprendizaje y procesamiento automático inspirado en la forma en que funciona el sistema nervioso de los animales. Se trata de un sistema de interconexión de neuronas en una red que colabora para producir un estímulo de salida. En inteligencia artificial es frecuente referirse a ellas como redes de neuronas o redes neuronales.

Las redes neuronales consisten en una simulación de las propiedades observadas en los sistemas neuronales biológicos a través de modelos matemáticos recreados mediante mecanismos artificiales (como un circuito integrado, un ordenador o un conjunto de válvulas). El objetivo es conseguir que las máquinas den respuestas similares a las que es capaz de dar el cerebro que se caracterizan por su generalización y su robustez.


Una red neuronal se compone de unidades llamadas neuronas. Cada neurona recibe una serie de entradas a través de interconexiones y emite una salida. Esta salida viene dada por tres funciones:

1. Una función de propagación (también conocida como función de excitación), que por lo general consiste en el sumatorio de cada entrada multiplicada por el peso de su interconexión (valor neto). Si el peso es positivo, la conexión se denomina excitatoria; si es negativo, se denomina inhibitoria.

2. Una función de activación, que modifica a la anterior. Puede no existir, siendo en este caso la salida la misma función de propagación.

3. Una función de transferencia, que se aplica al valor devuelto por la función de activación. Se utiliza para acotar la salida de la neurona y generalmente viene dada por la interpretación que queramos darle a dichas salidas. Algunas de las más utilizadas son la función sigmoidea (para obtener valores en el intervalo [0,1]) y la tangente hiperbólica (para obtener valores en el intervalo [-1,1]).

Planteamiento del problema 1.-

Se desea orientar la posición del generador según el de la veleta. La veleta estará sin mantener una posición especifica, ya que se orientara sola con respecto al aire. Una vez que la veleta esta posicionada, hay que orientar el generador en la misma posición de la veleta.

Objetivo 1.-

Que el alumno implemente los sistemas de inferencia difusa para poder resolver problemas que puedan ser solucionados con este método simplificando su control.

Desarrollo 1.-

primero se realizó un programa a partir de FIS, utilizando el toolbox de MATLAB donde se modelo una veleta y el generador, se establecieron los parámetros de las velocidades, posiciones y sentidos bajo los cuales se regirá nuestro sistema.

Programa 1.-fprintf('\Orientacion de Generador con respecto a Veleta\n');

%caracterizacion de universos

i=1;

for x= 0:360 if x<60 GNorte1(i)=1; VNorte1(i)=1; GEste(i)=0; GSur(i)=0;


GOeste(i)=0; GNorte2(i)=0; VEste(i)=0; VSur(i)=0; VOeste(i)=0; VNorte2(i)=0; elseif x>=60 && x<120 GNorte1(i)=(120-x)./(120-60); VNorte1(i)=(120-x)/(120-60); GEste(i)=(x-60)./(120-60); GSur(i)=0; GOeste(i)=0; GNorte2(i)=0; VEste(i)=(x-60)./(120-60); VSur(i)=0; VOeste(i)=0; VNorte2(i)=0; elseif x>=120 && x<180 GNorte1(i)=0; VNorte1(i)=0; GEste(i)=(180-x)./(60); GSur(i)=(x-120)./60; GOeste(i)=0; GNorte2(i)=0; VEste(i)=(180-x)./(60); VSur(i)=(x-120)./60; VOeste(i)=0; VNorte2(i)=0;

elseif x>=180 && x<240 GNorte1(i)=0; VNorte1(i)=0; GEste(i)=0; GSur(i)=(240-x)./60; GOeste(i)=(x-180)./60; GNorte2(i)=0; VEste(i)=0; VSur(i)=(240-x)./60; VOeste(i)=(x-180)./60; VNorte2(i)=0;

elseif x>=240 && x<300 GNorte1(i)=0; VNorte1(i)=0; GEste(i)=0; GSur(i)=0; GOeste(i)=(300-x)./60; GNorte2(i)=(x-240)./60; VEste(i)=0; VSur(i)=0; VOeste(i)=(300-x)./60; VNorte2(i)=(x-240)./60;

elseif x>=300 && x<=360 GNorte1(i)=0; VNorte1(i)=0; GEste(i)=0; GSur(i)=0;


GOeste(i)=0; GNorte2(i)=1; VEste(i)=0; VSur(i)=0; VOeste(i)=1; VNorte2(i)=1;

end i=i+1;end

i=1;for x=0:100 if x<25 Baja(i)=1; Media(i)=0; Alta(i)=0; elseif x>=25 && x<50 Baja(i)=(50-x)./25; Media(i)=(x-25)./25; Alta(i)=0; elseif x>=50 && x<75 Baja(i)=0; Media(i)=(75-x)./25; Alta(i)=(50-x)./25; elseif x>=75 && x<=100 Baja(i)=0; Media(i)=0; Alta(i)=1; end i=i+1;end

i=1;for x=0:30 if x<10 Horario(i)=1; Nomover(i)=0; Antihorario(i)=0; elseif x>=10 && x<20 Horario(i)=(x-10)./10; Nomover(i)=(20-x)./10; Antihorario(i)=0; elseif x>=20 && x<=30 Horario(i)=0; Nomover(i)=(75-x)./25; Antihorario(i)=(50-x)./25; elseif x>=15 && x<20 Nomover(i)=(x-15)/5; elseif x>=20 && x<25 Nomover(i)=(25-x)/5;

end i=i+1;end

%Fuzzyficacion

Vvel=input('\nIngrese valor certero para la posicion de la veleta:\


n');Vgen=input('Ingrese valor certero para la posicion del generador:\n');

UN1=VNorte1(Vvel+1);UE=VEste(Vvel+1);US=VSur(Vvel+1);UO=VOeste(Vvel+1);UN2=VNorte2(Vvel+1);%UGN1=GNorte1(Vgen+1);UGE=GEste(Vgen+1);UGS=GSur(Vgen+1);UGO=GOeste(Vgen+1);UGN2=GNorte2(Vgen+1);

%Evaluacion de reglasR1=min(UN1,UGN1);R2=min(UE,UGN1);R3=min(US,UGN1);R4=min(UO,UGN1);R5=min(UN2,UN1);R6=min(UN1,UGE);R7=min(UE,UGE);R8=min(US,UGE);R9=min(UO,UGE);R10=min(UN2,UGE);R11=min(UN1,UGS);R12=min(UE,UGS);R13=min(US,UGS);R14=min(UO,UGS);R15=min(UN2,UGS);R16=min(UN1,UGO);R17=min(UE,UGO);R18=min(US,UGO);R19=min(UO,UGO);R20=min(UN2,UGO);R21=min(UN1,UGN2);R22=min(UE,UGN2);R23=min(US,UGN2);R24=min(UO,UGN2);R25=min(UN2,UGN2);

CorteBaja=max([R1,R2,R5,R7,R8,R13,R14,R18,R19,R20,R21,R24,R25]');CorteMedia=max([R3,R4,R6,R9,R12,R15,R16,R22]');CorteAlta=max([R10,R11,R17,R23]');%CorteNoMover=([R1,R5,R7,R13,R19,R21,R25]');CorteHorario=([R2,R3,R8,R9,R10,R11,R14,R15,R16,R17,R20,R22]');CorteAntihorario=([R4,R6,R12,R18,R24]');%Recorte de conjuntos de salida

%Velocidadfor x=0:100 if Baja(x+1) < CorteBaja BajaRec(x+1)=Baja(x+1); else BajaRec(x+1)=CorteBaja; end


if Media(x+1)<CorteMedia MediaRec(x+1)=Media(x+1); else MediaRec(x+1)=CorteMedia; end

if Alta(x+1)<CorteAlta AltaRec(x+1)=Alta(x+1); else AltaRec(x+1)=CorteAlta; endend

%sentido de giro

%i=1%for y=0:0.1:5 % if Horario(i)<CorteHorario % HorarioRec(i)=Horario(i); % else % HorarioRec(i)=CorteHorario; % end

%if Nomover(i)<CorteNomover % NomoverRec(i)=Nomover(i); %else % NomoverRec(i)=CorteNomover; % end

%if Antihorario(i)<CorteAntihorario % AntihorarioRec(i)=Antihorario(i); %else % AntihorarioRec(i)=CorteAntihorario; % end% i=i+1;%endfor x=0:30 if Horario(x+1)<CorteHorario HorarioRec(x+1)=Horario(x+1); else HorarioRec(x+1)=CorteHorario; end

if Nomover(x+1)<CorteNomover NomoverRec(x+1)=Nomover(x+1); else NomoverRec(x+1)=CorteNomover; end

if Antihorario(x+1)<CorteAntihorario AntihorarioRec(x+1)=Antihorario(x+1); else AntihorarioRec(x+1)=CorteAntihorario; endend

%union de conjuntos recortador para poder defuzzyficar

CurvaVel=max([BajaRec;MediaRec;AltaRec]);


CurvaSen=max([HorarioRec;NoMoverRec;AntihorarioRec]);

%Defuzzyficacion

Velocidad=0:100;Sentido=0:30;SalidaVel=defuzz(Velocidad,CurvaVel,'centroid')SalidaSen=defuzz(Sentido,CurvaSen,'centroid')

Planteamiento del problema 2.-

Modelar el comportamiento de una compuerta NOR bipolar.

Objetivo 2.-

Que el alumno implemente los sistemas de inferencia difusa para poder resolver problemas que puedan ser solucionados con este método simplificando su control.

Desarrollo 2.-

Se planteo la tabla de verdad de la compuerta y lo necesario para poder separarla en sus puntos. De ahí establecer como se entrenaría la neurona.

Programa 2.-close;clear all;clc;%w=[0,0];w=rand(1,2);p1=[0;0];p2=[0;1];p3=[1;0];p4=[1;1];b=rand;f=input('Introduzca el número de interacciones: ');

for x=0:f

a=hardlim(w*p1+b); e= 1-a; w=w+e*p1'; b=b+e;



a=hardlim(w*p4+b);


e= -a; w=w+e*p4'; b=b+e;

endwbpe=-w(2)/w(1);x=-3:0.1:3;x2=-1:0.1:0;y=pe.*x;plot(x,y);axis([-3 3 -3 3])grid onhold ony2=-1./pe.*x2;plot(p1(1),p1(2),'*b');hold on;plot(p2(1),p2(2),'*b');hold on;plot(p3(1),p3(2),'*b');hold on;plot(p4(1),p4(2),'*b');hold on;plot(x2,y2);

pf(1)=input('primer valor de p: ');pf(2)=input('segundo valor de p: ');hold on;plot(pf(1),pf(2),'*r');a=hardlim(w*pf'+b)

A continuación el segundo programa qclose;clear all;clc;

f=input('número de iteraciones: ');w1=rand(1,2);w2=rand(1,2);p1=[-2;2];p2=[-3;3];p3=[0;0];p4=[1;2];p5=[2;-1];p6=[3;-2];p7=[-3;-2];p8=[-2;-3];b1=rand;b2=rand;for x=1:f a1=hardlim(w1*p1+b1); e=1-a1; w1=w1+e*p1'; b1=b1+e;

a2=hardlim(w2*p1+b2); e=0-a2; w2=w2+e*p1';


b2=b2+e;

a1=hardlim(w1*p2+b1); e=1-a1; w1=w1+e*p2'; b1=b1+e;















end

w1w2b1b2

pe1=-w1(2)/w1(1);pe2=-w2(2)/w2(1);

x=-3:0.1:3;x2=-1:0.1:0;x3=0:0.01:0.3;y1=pe1.*x;y2=pe2.*x;plot(x,y1);axis([-3 3 -3 3])grid onhold onplot(x,y2,'r');hold on;y3=-1./pe1.*x2;y4=-1./pe2.*x3;plot(p1(1),p1(2),'<b');hold on;plot(p2(1),p2(2),'<b');hold on;plot(p3(1),p3(2),'ob');hold on;plot(p4(1),p4(2),'ob');hold on;plot(p5(1),p5(2),'*b');hold on;plot(p6(1),p6(2),'*b');hold on;plot(p7(1),p7(2),'sb');


hold on;plot(p8(1),p8(2),'sb');hold on;plot(x2,y3,'b');hold on;plot(x3,y4,'r');hold on;

p(1)=input('Introduzca el primer valor de p: ');p(2)=input('Introduzca el segundo valor de p: ');n(1)=hardlim(w1*p'+b1);

n(2)=hardlim(w2*p'+b2);

nplot(p(1),p(2),'*r');

Graficas.-Los siguientes conjuntos son los mismos para la veleta y el generador, los mismos valores en las mismas fronteras, solo que con diferentes nombres, ya que uno se posiciona sola y solo se establece bajo que parámetros esta, y el otro tiene que llegar a los parámetros.

Representación de los 5 conjuntos de orientación utilizados.

Representación los conjuntos difusos de la velocidad.

Representación de los sentidos utilizados.

Comparación de la superficie de control.

Obtenida con Fuzzy Logic del toolbox Superficie de control obtenida por el


MATLAB. programa realizado.

Cibergrafia.- http://ants.dif.um.es/staff/juanbot/ml/files/20022003/fuzzy.pdf http://www.gc.ssr.upm.es/inves/neural/ann2/concepts/taxonomy.htm http://es.wikipedia.org/wiki/Red_neuronal_artificial

Documents

Sistema de inferencia difusa y redes neuronales