Actividad 8 - WordPress.com

UNIVERSIDAD DE FUERZAS ARMADAS “ESPE”
DEPARTAMENTO DE ELÉCTRICA Y ELECTRÓNICA
ASIGNATURA: CONTROL INTELIGENTE
Actividad No8. Aprendizaje del perceptrón multicapa mediante retropropagación del error
Fecha:
Nombre alumno:
NRC:
1.
Dibuje un perceptrón multicapa con 2 entradas, 2 neuronas escondidas y una neurona de
salida.
En el perceptrón de capa simple existen ciertos problemas que no pueden ser resueltos por éstos,
una compuerta XOR no puede ser implementada con un perceptrón de capa simple
Es necesario añadir a cada una de las entradas de éste, un par de perceptrones adicionales, que
apoyen en el proceso de aprendizaje de la red. Este nuevo par de perceptrone, se constituye en
una segunda capa de perceptrones
1
Net 1
a01
∑
ʃ
1
y1
a11
b0
x1
b1
a21
∑
a12
Net 2
1
∑
ʃ
Z
b2
x2
a21
ʃ
y2
a02
Figura 1. Estructura de una red neuronal multicapa.
2. Escriba las fórmulas de actualización de cada uno de los pesos de conexión entre las
neuronas de la capa oculta y la capa de salida. Utilice la nomenclatura del ejercicio 1.
Partiendo de los conceptos matemáticos empleados para implementar al perceptrón de capa simple,
y sabiendo que la función de activación es la función sigmoide.
(
(
(
)
)
)
(
(
Página 1
(
)
)
)
3. Escriba las fórmulas de actualización de cada uno de los pesos de conexión entre las
entradas y las neuronas de la capa oculta. Utilice la nomenclatura del ejercicio 1.
(
)
(
)
(
)
(
(
(
)
(
)
(
(
(
(
)
)(
)
)
)
(
)
(
)
)(
(
(
(
)
)
)
)
)
(
(
(
)
)
)
4. Escriba el programa para realizar el aprendizaje por retropropagación del error para
que la red neuronal del ejercicio 1 aprenda a partir de los patrones de entrenamiento de
una compuerta XOR. Considere un factor de aprendizaje de 0.1; alfa=4. Grafique la
curva de aprendizaje. Considere aprendizaje en línea (ejemplo por ejemplo).
Grafique las líneas de frontera de la red neuronal de acuerdo a lo realizado en la
actividad 7.
clc;clear all;
% entradas compuerta entradas XOR %
in1(1)=0;
in2(1)=0;
in1(2)=0;
in2(2)=1;
in1(3)=1;
in2(3)=0;
in1(4)=1;
in2(4)=1;
% Salidas buscadas en la compuerta XOR (targets)
targ = [0;1;1;0];
% Los pesos se incializan de forma aleatoria
a01=rand(1);a11=rand(1); a12=rand(1);a02=rand(1); a21=rand(1); a22=rand(1);
b0=rand(1); b1=rand(1); b2=rand(1);
% Coeficiente de aprendizaje
n = 0.25;
alfa=4;
Error_Epoca = zeros(50,1);
epocas=input('Numero de epocas ');
for j = 1 : epocas
Suma_Error = 0;
for i = 1:length(targ)
Página 2
%--------------------------------------------------------------------%
CAPA OCULTA
%--------------------------------------------------------------------%net1
net1 = a01*1 + a11*in1(i) + a21*in2(i);
y1 = 1./(1+exp(-alfa*net1));
% 2da Neurona - NET2
net2 = a02*1 + a22*in2(i) + a12*in1(i);
y2 = 1./(1+exp(-alfa*net2));
%--------------------------------------------------------------------%
CAPA SALIDA
%--------------------------------------------------------------------% Capa de salida
net = b0*1 + b1*y1 + b2*y2;
z = 1./(1+exp(-alfa*net));
% Calculo de error
error = 1/2*(targ(i)-z)^2;
Suma_Error = Suma_Error + error;
% Actualización de pesos capa salida
Db0 = n*(targ(i)-z)*alfa*z*(1-z);
Db1 = n*(targ(i)-z)*alfa*z*(1-z)*y1;
Db2 = n*(targ(i)-z)*alfa*z*(1-z)*y2;
% Actualización de pesos
Da01 = n*(targ(i)-z)*(alfa^2)*z*(1-z)*b1*y1*(1-y1);
Da11 = n*(targ(i)-z)*(alfa^2)*z*(1-z)*b1*y1*(1-y1)*in1(i);
Da12 = n*(targ(i)-z)*(alfa^2)*z*(1-z)*b2*y2*(1-y2)*in1(i);
Da02 = n*(targ(i)-z)*(alfa^2)*z*(1-z)*b2*y2*(1-y2);
Da21 = n*(targ(i)-z)*(alfa^2)*z*(1-z)*b1*y1*(1-y1)*in2(i);
Da22 = n*(targ(i)-z)*(alfa^2)*z*(1-z)*b1*y1*(1-y1)*in2(i);
b0 = b0 +
b1 = b1 +
b2 = b0 +
a01 = a01
a11 = a11
a12 = a12
a02 = a02
a21 = a21
a22 = a22
Db0;
Db1;
Db2;
+ Da01;
+ Da11;
+ Da12;
+ Da02;
+ Da21;
+ Da22;
end
Error_Epoca(j) = Suma_Error;
end
figure(1); plot(Error_Epoca); title('ERROR VS EPOCAS');
Página 3
[x y] = meshgrid(0:0.01:1.5,0:0.01:1.5);
net1 = a01*1 + a11*x + a21*y;
y1 = 1./(1+exp(-alfa*net1));
net2 = a02*1 + a22*x + a12*y;
y2 = 1./(1+exp(-alfa*net2));
net = b0*1 + b1*y1 + b2*y2;
z = 1./(1+exp(-alfa*net));
figure(2)
subplot(121);
mesh(x,y,z);
title('SALIDA DE LA RED NEURONAL');
subplot(122);
mesh(x,y,round(z)); title('LINEA DE FRONTERA');
A continuación se tienes la salidas del programa en la figura 2 de observa como el error va
disminuyendo según el número de épocas para este ejemplo ponemos 1000 épocas y el error se
redice casi a cero.
Figura 2. Gráfica de error vs épocas.
En la figura 3 se observa la salida de la red multicapa en forma de 3D donde el color rojo y azul
muestran que existieron cambias a la salida de red, es decir que, se puede considerar que este
método de usar más de una neurona es el adecuado para obtener una salida como la compuerta
xor.
Página 4
Figura 3. Gráfica de salida de la neurona.
5. Repita el numeral 4 pero con aprendizaje en paquete (“batch”). Grafique las líneas de
frontera de la red neuronal de acuerdo a lo realizado en la actividad 7.
Para el aprendizaje en paquete se han aumentado variables auxiliares para que la actualización
de los pesos sea al finalizar cada época.
for j = 1 : epocas
Suma_Error = 0;
ax_a01 = 0; ax_a11 = 0; ax_a12 = 0;ax_a02 = 0; ax_a21 = 0; ax_a22 = 0;
ax_b0 = 0; ax_b1 = 0; ax_b2 = 0;
for i = 1: length(targ)
%--------------------------------------------------------------------%
CAPA OCULTA
%--------------------------------------------------------------------%net1
net1 = a01*1 + a11*in1(i) + a21*in2(i);
y1 = 1./(1+exp(-alfa*net1));
% 2da Neurona - NET2
net2 = a02*1 + a22*in2(i) + a12*in1(i);
y2 = 1./(1+exp(-alfa*net2));
%--------------------------------------------------------------------%
CAPA SALIDA
%--------------------------------------------------------------------% Capa de salida
net = b0*1 + b1*y1 + b2*y2;
z = 1./(1+exp(-alfa*net));
% Calculo de error
error = 1/2*(targ(i)-z)^2;
Suma_Error = Suma_Error + error;
Página 5
% Actualización de pesos
Da01 = n*(targ(i)-z)*(alfa^2)*z*(1-z)*b1*y1*(1-y1);
Da11 = n*(targ(i)-z)*(alfa^2)*z*(1-z)*b1*y1*(1-y1)*in1(i);
Da12 = n*(targ(i)-z)*(alfa^2)*z*(1-z)*b2*y2*(1-y2)*in1(i);
Da02 = n*(targ(i)-z)*(alfa^2)*z*(1-z)*b2*y2*(1-y2);
Da21 = n*(targ(i)-z)*(alfa^2)*z*(1-z)*b1*y1*(1-y1)*in2(i);
Da22 = n*(targ(i)-z)*(alfa^2)*z*(1-z)*b1*y1*(1-y1)*in2(i);
% Actualización de pesos capa salida
Db0 = n*(targ(i)-z)*alfa*z*(1-z);
Db1 = n*(targ(i)-z)*alfa*z*(1-z)*y1;
Db2 = n*(targ(i)-z)*alfa*z*(1-z)*y2;
ax_a01
ax_a11
ax_a12
ax_a02
ax_a21
ax_a22
=
=
=
=
=
=
ax_a01
ax_a11
ax_a12
ax_a02
ax_a21
ax_a22
+
+
+
+
+
+
Da01;
Da11;
Da12;
Da02;
Da21;
Da22;
ax_b0 = ax_b0+Db0;
ax_b1 = ax_b1+Db1;
ax_b2 = ax_b2+Db2;
end
a01 = a01
a11 = a11
a12 = a12
a02 = a02
a21 = a21
a22 = a22
b0 = b0 +
b1 = b1 +
b2 = b2 +
+ ax_a01;
+ ax_a11;
+ ax_a12;
+ ax_a02;
+ ax_a21;
+ ax_a22;
ax_b0;
ax_b1;
ax_b2;
Error_Epoca(j) = Suma_Error;
end
En la figura 4 muestra el resultado de este nuevo algoritmo en el cual se observa que con menos
época se consigue eliminar el error con lo cual se puede decir que este algoritmo se torna
eficiente en comparación al anterior.
Página 6
Figura 4. Error vs Epocas.
En la figura 5 se conserva la respesta del nuevo algoritmo en la cual se mustra que cumple ya
que mustra los cambias que hay a las salida de la red neuronal multicapa.
Figura 5. Gráfica de salida de la neurona.
Yo Diego Soria afirmo que esta actividad es de mi autoría y establezco que para la elaboración
de la misma he seguido los lineamientos del Código de Ética de la Universidad de las Fuerzas
Armadas ESPE
Página 7