Departamento de eléctrica y electrónica

Control inteligente
Nombre: Ronald Romero
NRC: 2758 Fecha: 04/05/2018
1
1. Graficar f ( ϰ )= −α ϰ y su derivada para α =1,2,4 , f ( ϰ ) se llama signoide y comparar
1+e
con la función signo.

En la Figura 1 se muestran las funciones signoide para α =1,2,4

Rojo α =1Verde α =2Azul α =4

Figura 1. Función Signoide

En la Figura 2, se observan las derivadas de la Función Signoide.
Rojo α =1Verde α =2Azul α =4
 Figura 2. Derivada de la Funcion Signoide

En las Figura 3, se observa la función signoide con su derivada

 Figura 3, Función signoide y su derivada

Por ultimo en la Figura 4, se observa la diferencia entre la función signo y la función

signoide.
 Figura 4, Función Signoide y Signo

Código de Matlab

syms x;
x=-3:0.1:3;
a=hardlim(x);

figure()
alfa=1;
y=1./(1+exp(-alfa*x));
y1=alfa.*y.*(1-y);
plot(x,y,'r')
hold on
plot(x,y1,'g')
hold on
plot(x,a,'b')
legend('Funcion','Derivada','Signo');
title('Alfa=1');
ylim([-0.05 1.05])
grid on

figure()
alfa=2;
 y=1./(1+exp(-alfa*x));
y1=alfa.*y.*(1-y);
plot(x,y,'r')
hold on
plot(x,y1,'g')
hold on
plot(x,a,'b')
legend('Funcion','Derivada','Signo');
title('Alfa=2');
ylim([-0.05 1.05])
grid on

figure()
alfa=2;
y=1./(1+exp(-alfa*x));
y1=alfa.*y.*(1-y);
plot(x,y,'r')
hold on
plot(x,y1,'g')
hold on
plot(x,a,'b')
legend('Funcion','Derivada','Signo');
title('Alfa=2');
ylim([-0.05 1.05])
grid on

2. Realizar el algoritmo de aprendizaje por descenso de gradiente para clasificación de

aviones (on line)

Para la clasificación de aviones se tiene como punto de partida la Tabla 1.

Tabla 1. Clasificación de aviones

Y se procede a realizar el algoritmo de reducción de gradiente en base a una neurona.

Vemos la evolución del error con respecto a las épocas en la Figura 5.

Figura 5. Error vs Epoca

Resultados.

Los resultados son satisfactorios con 150 épocas y factor de aprendizaje de 0.5

Código de Matlab
alfa=4;n=0.5; in0=1;
w0=rand;w1=rand;w2=rand;
p=[1 0.1;2 0.2;0.1 0.3;2 0.3;0.2 0.4;3 0.4;0.1 0.5;1.5 0.5;0.5 0.6;
1.6 0.7;];
 targ=[ 1 1 0 1 0 1 0 1 0 0];
errorv=[]; epocav=[];
for epoca=1:1:150 %EPOCAS
Error=0;
for i=1:1:10
in1=p(i,1);
in2=p(i,2);
net=w0*in0+w1*in1+w2*in2;
out=sigmoide(net,alfa);
e=targ(i)-out;
deltaw0=-n*e*(-1)*alfa*out*(1-out)*in0;
deltaw1=-n*e*(-1)*alfa*out*(1-out)*in1;
deltaw2=-n*e*(-1)*alfa*out*(1-out)*in2;
w0=w0+deltaw0;
w1=w1+deltaw1;
w2=w2+deltaw2;
Error=Error+(targ(i)-out)^2;
end
errorv=[errorv Error];
epocav=[epocav epoca];
plot(epocav,errorv)
grid on
title('Evolucion del error por época')
end

for i=1:10
in1=p(i,1);
in2=p(i,2);
out=hardlim(w0+w1*p(i,1)+w2*p(i,2));

if out==0
disp('Bomber')
end
if out==1
disp('Fighter')
end
end

3. Realizar el algoritmo de aprendizaje por descenso de gradiente para Xor

Utilizaremos el método on line con ecuación:

1
E= e2
2
Y e=targ−out

Procedemos a realizar el algoritmo de descenso de gradiente con tres neuronas para

resolver la función Xor.
 Las funciones de salidas de cada neurona utilizando la función signoide corresponden
a:

out 1=sigmoide (net 1)

out 2=sigmoide(net 2)
out=sigmoide(net )

Para realizar el algoritmo en Matlab extraemos las ecuaciones de la red neuronal.

net 1=¿ 1∗w 1+ ¿2∗w 3+ b 0

net 2=¿ 1∗w 2+ ¿ 2∗w 4+ b 1
net=out 1∗w5+ out 2∗w 6+ b 2

Para el cálculo de los pesos aplicamos la regla de la cadena.

−η∗∂ E
∗∂ e
∂e
∗∂ out
∂ out
∗∂ net
∂net
∗∂ out 1
∂ out 1
∗∂ net 1
−η∗∂ E ∂ net 1
∆ b 0= =
∂b0 ∂b 0
Remplazamos valores y obtenemos las ecuaciones de los pesos y sesgos
∆ b 0=−η∗( targ−out )∗−1∗(α∗out ( 1−out ) )∗W 5∗( α∗out 1 ( 1−out 1 ) )∗1

Y así para todos los pesos y sesgos.

Las ecuaciones encontradas se aplican en Matlab:

clear all
clc
n=0.5;
in0=1;
alfa=4;
b0=rand;b1=rand;b2=rand;w1=rand;w2=rand;w3=rand;w4=rand;w5=rand;w6=ra
nd;
p=[0 0;0 1;1 0;1 1];
targ=[ 0 1 1 0];
errorv=[]; epocav=[];
for epoca=1:1:500 %EPOCAS
Error=0;
for i=1:1:4
in1=p(i,1);
in2=p(i,2);
net1=in1*w1+in2*w3+b0;
net2=in1*w2+in2*w4+b1;
out1=sigmoide(net1,alfa);
out2=sigmoide(net2,alfa);
net=out1*w5+out2*w6+b2;
out=sigmoide(net,alfa);
e=targ(i)-out;

deltab0=-n*e*(-
1)*sigmoide_prima(net,alfa)*w5*sigmoide_prima(net1,alfa)*1;
deltab1=-n*e*(-
1)*sigmoide_prima(net,alfa)*w5*alfa*sigmoide_prima(net1,alfa)*1;
deltab2=-n*e*(-1)*alfa*out*(1-out)*1;

deltaw1=-n*e*(-
1)*sigmoide_prima(net,alfa)*w5*sigmoide_prima(net1,alfa)*in1;
deltaw2=-n*e*(-
1)*sigmoide_prima(net,alfa)*w6*sigmoide_prima(net2,alfa)*in1;
deltaw3=-n*e*(-
1)*sigmoide_prima(net,alfa)*w5*sigmoide_prima(net1,alfa)*in2;
deltaw4=-n*e*(-
1)*sigmoide_prima(net,alfa)*w6*sigmoide_prima(net2,alfa)*in2;
deltaw5=-n*e*(-1)*sigmoide_prima(net,alfa)*out1;
deltaw6=-n*e*(-1)*sigmoide_prima(net,alfa)*out2;

b0=b0+deltab0;
b1=b1+deltab1;
b2=b2+deltab2;
w1=w1+deltaw1;
w2=w2+deltaw2;
w3=w3+deltaw3;
w4=w4+deltaw4;
w5=w5+deltaw5;
w6=w6+deltaw6;

Error=Error+(targ(i)-out)^2;
end
errorv=[errorv Error];
epocav=[epocav epoca];
plot(epocav,errorv)
grid on
title('Evolucion del error por época')

end
La Figura 6, muestra la evolución del error por época de la función xor.
 Figura 6. Error por época

El algoritmo presentado anteriormente no siempre converge, se realizaron varias

interacciones para obtener el resultado presentado en la Figura 6.

Resultados obtenidos