Control Inteligente

Practica de Entrenamiento
Redes Neuronales
Ejercicio # 1

En el Matlab seguir los siguientes pasos para ir a:

HELP/DEMOS/TOOLBOX/NEURALNETWORKS/BACKPROPAGATION/STEEPEST DESCENT
BACKPRPAGATION/RUN THESE DEMO/CONTENTS:
10-13 INTERNATIONAL THOMPSON PUBLISHING
CAP 11/BACPROPAGATION CALCULATION.

Correr el DEMO hasta encontrar la convergencia anotando los valores de los

pesos, el bias, las salidas y los errores para cada iteración. Los resultados en una
TABLA enviar por correo electrónico al profesor.

>> demos
Control Inteligente
Control Inteligente

PASO 1: La red Neuronal Feedforward inicia su entrenamiento con los pesos y

bias iniciales que se muestran en la Figura. Presenta a la red la salida deseada:

π 
T = 1 + sin  P 
4 

Siendo la entrada P = 1 .
Control Inteligente

PASO 2: Luego la red simula la salida para las condiciones iniciales dadas en el
Paso 1.
Control Inteligente

PASO 3: Luego la red aplica el algoritmo Backpropagation y aplica la regla general

de actualización de pesos y bias dado por:

W = W + ∆W

Continúa entrenando hasta encontrar el error cero. Siendo los pesos y bias finales
los que se muestran en la siguiente Figura.
Control Inteligente

Ejercicio # 2

Correr cada uno de los programas en Matlab enviados en el segundo archivo,

reconociendo con ayuda del HELP cada una de las funciones y luego enviar al
profesor un comentario de la acción que realiza cada una de las funciones
utilizadas. Asimismo modificar la arquitectura de las redes neuronales para
observar su mejor desempeño.

Programa 1: Entrenamiento de una RNA para el mapeo de un conjunto de datos.

Ploteando la DATA Q=(P,T)

p=[0 1 2 3 4 5 6 7 8];
t=[0 0.84 0.91 0.14 -0.77 -0.96 -0.28 0.66 0.99];
figure
plot(p,t,'or')
title('Conjunto de Entrenamiento');
xlabel('P');
ylabel('T');
axis([-1 9 -2 2])

Creando la Red Objeto FF

net=newff(minmax(p),[10 1],{'tansig','purelin'},'trainlm');

Simulando la Red Objeto FF

a=sim(net,p);
figure
Control Inteligente

plot(p,t,'ro')
hold
plot(p,a,'x')
axis([-1 9 -2 2])

Entrenando la Red Objeto FF

net.trainParam.epochs=50;
net.trainParam.goal=1e-5;
net.trainParam.show=10;
net=train(net,p,t);
Control Inteligente

Simulando y Validando la Red Objeto FF

a=sim(net,p);
e=t-a;
figure
plot(p,t,'ro')
hold
plot(p,a,'x')
plot(p,e,'m')
legend('DATA','TRAIN','ERROR')
axis([-1 9 -2 2])

Programa 2: Entrenamiento de una RNA para el mapeo de una función seno.

Ploteando la DATA Q=(P,T)

T=2*pi;
p=0:1/T:T;
t=sin(p);
plot(p,t,'bo')
title('DATA: Q=\{P,T\}')
xlabel('P');
ylabel('T');
axis([0 T -1.2 1.2])
Control Inteligente

Creando la Red Objeto FF

net=newff(minmax(p),[4 1],{'tansig','purelin'},'trainlm');

Simulando la Red Objeto FF

a=sim(net,p);
figure
plot(p,t,'ro','MarkerSize',14,'LineWidth',2)
hold
plot(p,a,'x','MarkerSize',14,'LineWidth',2)
axis([0 T -1.2 1.2])
Control Inteligente

Entrenando la Red Objeto FF

net.trainParam.epochs=2500;
net.trainParam.goal=1e-5;
net.trainParam.show=100;
net=train(net,p,t);

Simulando y Validando la Red Objeto FF

a=sim(net,p);
e=t-a;
plot(p,t,'ro'), hold
plot(p,a,'x')
plot(p,e,'m')
legend('DATA','TRAIN','ERROR')
Control Inteligente

1
Programa 3: Entrenamiento de una RNA para el mapeo de la función f ( x) = del
x
libro de Simon Haykin.

Ploteando la DATA Q=(P,T)

% DATA
p_treino=1+99*rand(70,1)';
t_treino=1./p_treino;
plot(p_treino,t_treino,'ro')
title('Conjunto de Entrenamiento');
xlabel('P'); ylabel('T');

% DATA TEST
p_teste=1+99*rand(30,1)';
t_teste=1./p_teste;
% CREANDO LA RED OBJETO
net=newff(minmax(p_treino),[8 1],{'tansig','purelin'},'trainlm');
net.trainParam.epochs=800;
net.trainParam.goal=1e-8;
net.trainParam.show=100;
net=train(net,p_treino,t_treino);
Control Inteligente

% VALIDANDO DATA ENTRENADA

y_treino=sim(net,p_treino);
y_teste=sim(net,p_teste);
% PLOTEO
figure
subplot(211)
plot(p_treino,t_treino,'mo')
hold
plot(p_treino,y_treino,'bx')
title('ENTRENAMIENTO')
subplot(212)
plot(p_teste,t_teste,'mo')
hold
plot(p_teste,y_teste,'bx')
title('VALIDANDO EL ENTRENAMIENTO')
Control Inteligente

Ejercicio # 3

Hacer un programa computacional (similar al que utilizo en las practicas de

laboratorio) para entrenar una red neuronal Feedforward usando el algoritmo
Backpropagation de una capa oculta para realizar el mapeo de la siguiente función
no lineal. Use las funciones del Toolbox de Redes Neuronales de Matlab.

3 
f ( x1 , x 2 ) = sin( x1 ) cos x 2 
4 

Para x1 = x 2 = (− 3.5 : 0.2 : 3.5)

Usaremos la siguiente topología de red Feedforward de estructura (1 − 5 − 1) .

P a

+1

+1

Las funciones de activación en la capa oculta es sigmoide logística, mientras que

en la capa de salida usaremos la función de activación lineal purelin.

El objetivo es encontrar los pesos y bias para la red:

W11  b11 
W  b 
 21   21 
W1 = W31 , b1 = b31 , W2 = [W11 W12 W13 W14 W15 ], b2 = [b2 ]
   
W41  b41 
W51  b51 
Control Inteligente

CASO I: Usando un Batch Training TRAINGD

Es un caso poco satisfactorio ya que la red no generaliza, es decir no aprende. Posibles causas,
manejo no adecuado de la red y problemas con los mínimos locales.

CASO II: Usando un Batch Training TRAINLM

Es un caso muy satisfactorio ya que la red ha generalizado correctamente, es decir aprendió.

Esto es debido a que el Batch Training TRAINLM es una función con mejor performance.
Control Inteligente

TEST de Validación

La siguiente figura nos muestra la evolución del error para un número de 9 épocas.

Código MATLAB
% Ingresamos la función no lineal con su rango de operación
P=-3.5:0.2:3.5;
T=sin(P).*cos((3/4)*P);
% Diseño de la red con 5 neuronas ocultas
net=newff(minmax(P),[5 1],{'tansig' 'purelin'},'trainlm');
Y=sim(net,P);
net.trainParam.epochs=2000;
net.trainParam.goal=1e-5;
net.trainParam.show=100;
net=train(net,P,T);
Y=sim(net,P);
W1=net.iw{1,1}
b1=net.b{1}
W2=net.lw{2,1}
b2=net.b{2}
% Ploteo de los datos de la función no lineal
subplot(211)
plot(P,T,'+')
title('Conjunto de Entrenamiento: TRAINLM');
xlabel('P');
ylabel('T');
Control Inteligente

subplot(212)
t=-3.5:0.2:3.5;
plot(t,Y,'m-.')
hold
plot(P,T,'+')
title('Progresión de la Señal de Entrenamiento')
legend('DATA','TRAIN')

Estado Final de la Red Feedforward

Control Inteligente

Ejercicio # 4

Usando el algoritmo BP, encontrar los nuevos pesos cuando la RNA de la figura
tiene una entrada (1,1) y salida deseada es 0.75 . Adoptar un factor de aprendizaje
α = 0.2 y una función de transferencia identidad para todas las neuronas.

+1
b01
W11 +1
1 V11 b03
W12
+1 a T=0.75
b02
- +
W21
V12
1
W22 e

Considerando los pesos y bias finales como:

 2 − 1  2
W =  , b1 = 2, V = [2 2], b2 = 2
− 1 2   

Entrenamiento para una época

P=[1;1];
T=[0.75];
w_i=[2 -1;-1 2];
v_i=[2 2];
w1=w_i(1,:);
w2=w_i(2,:);
ws=v_i;
b1=2;
b2=2;
bs=2;
alpha=0.2;
y1 =logsig(w1*P(:,1)+b1) ;
y2 =logsig(w2*P(:,1)+b2) ;
ys =purelin(ws*[y1 y2]'+bs);
ds =T(1)-ys;
d =ds*ws;
d1 =d(1);
d2 =d(2);
w1 =w1+alpha*d1*(1-y1^2)*P(:,1)';
w2 =w2+alpha*d2*(1-y2^2)*P(:,1)';
ws =ws+alpha*ds*(1)*[y1 y2];
b1 =b1+alpha*d1*(1-y1^2);
b2 =b2+alpha*d2*(1-y2^2);
bs =bs+alpha*ds*(1);
E =T-ys;
err=mse(E);
Control Inteligente

Corrida del Programa para la Red Entrenada

Epocas
1
Epocas
2
Epocas
3
Epocas
4
Epocas
5
Epocas
6
Epocas
7
Epocas
8
Epocas
9
Epocas
10

Pesos y Bias Finales

W=

1.7070 -1.2930
-1.2930 1.7070

B=

1.7070
1.7070

V=

0.3129 0.3129

bs =

0.1938
Control Inteligente

Err =

25.6066
4.5940
0.9377
0.2052
0.0462
0.0105
0.0024
0.0005
0.0001
0.0000

Ploteo del Error