UNIVERSIDAD CATOLICA DE SANTA MARIA
Facultad de Ciencias e Ingenieras Fsicas y Formales
Escuela Profesional de Ingeniera Mecnica, Mecnica
Elctrica y Mecatrnica.
PROCESOS INTELIGENTES
Jefe de Practicas: Ing. MESTAS RAMOS, Sergio Orlando
PRACTICA NRO 10: EL PERCEPTRON BASICO
Alumno:
Llerena Mendoza Alonso Jose
Semestre: IX
Grupo: 02
2017
EL PERCEPTRON BASICO
I. OBJETIVO GENERAL
Utilizar Matlab para modelar una neurona artificial y la
arquitectura de una red neuronal artificial.
Manejar Matlab y la caja de herramientas de redes neuronales
artificiales para resolver un problema de ingeniera desde esta
perspectiva.
Comprender slidamente el funcionamiento de las redes que
utilizan el perceptrn.
Ser capaz de programar con xito simulaciones de estas redes.
II. MATERIALES Y EQUIPOS
Computador.
Sistema Operativo Windows XP, Windows 7, Windows 8.
MatLab.
III. PROCEDIMIENTO
1. Cree un archivo m con el nombre per1.m que simule una
compuerta OR de dos entradas usando el perceptrn:
Los pesos iniciales de las entras 1 y 2 son 0.5 y 1.5 respectivamente,
el peso de la entrada lumbral es 1.5.
clf reset
pausa = 2;
%DEFINICION DEL PROBLEMA
%=======================
%Definicion de cuatro vectores de 2-elementos de entrada
P = [0 1 0 1; 0 0 1 1];
%Definicion de las cuatro salidas deseadas de 1-elemento
T = [0 1 1 1];
%GRAFICA DE LOS VECTORES A ENTRENAR
%=======================
disp('presione cualquier tecla para ver los vectores de
entrada')
pause, disp('')
V = [-2 2 -2 2];
PR = [-2 2; -2 2];
plotpv(P,T,V);
figura=gcf;
axis('equal')
title('grafica de los vectores de entrada')
xlabel('Entrada 1')
xlabel('Entrada 2')
pause
%INICIALIZACION DE LA ARQUITECTURA DE LA RED
%=============================================
%Encuentre el tamao del vector de entrada R, el tamao de
la capa S,
%el tamao del lote Q
[R,Q] = size(P); [S,Q]=size (T);
red=newp(PR,S);
%INICIALIZACION DE PESOS Y UMBRAL
z = menu('inicializar Pesos y umbral A',...
'condiciones inciales en la guia del estudiante',...
'valores aleatorios');
disp('')
if z == 1
red.IW{1,1}=[0.5 1.5]; red.b{1}=[1.5];
else
red.inputweights{1,1}.initFcn = 'rands';
red.biases{1}.initFcn = 'rands';
red=init(red);
end
%GRAFICA DE LA CLASIFICACION INICIAL
%===================================
hold on
linea = plotpc(red.IW{1,1},red.b{1});
%ENTRENAMIENTO DE LA RED
%=======================
%ENTRENAMIENTO DE LOS PARAMETROS
disp_freq = 1;
max_epoch = 20;
%NOTA:El resto del codigo de entrenamiento puede
reemplazarse por:
%red.TrainParam.epochs=max_epoch;
%red=train(red,P,T);
%W=red.IW{1,1};
%B=red.b{1};
W = red.IW{1,1};
B = red.b{1};
pesos1 = [W(1,1)];
pesos2 = [W(1,2)];
umbrales = [B];
%FASE DE REPRESENTACION:
A = sim(red,P);
e = T-A;
for epoch=1:max_epoch
%FASE DE REVISION
if all(e==0), epoch=epoch-1; break, end
%FASE DE APRENDIZAJE
dW = learnp(W,P,[],[],[],[],e,[],[],[],[],[]);
dB = learnp(B,ones(1,Q),[],[],[],[],e,[],[],[],[],[]);
W = W + dW; B = B + dB;
red.IW{1,1}=W;
red.b{1}=[B];
%FASE DE REPRESENTACION
A = sim(red,P);
e = T-A,
%PRESENTACION EN PROGRESO
if rem(epoch,disp_freq) == 0
pause(pause), disp('')
linea=plotpc(W,B,linea); drawnow
end
pesos1=[pesos1 W(1,1)];
pesos2=[pesos2 W(1,2)];
umbrales=[umbrales B];
end
% GRAFICA DE CLASIFICACION FINAL
%===============================
figure(figura)
plotpc(W,B,linea); drawnow
pause
clf reset
%GRAFICA DE PESOS Y UMBRALES VS. EPOCH
%=====================================
plot(0:epoch,pesos1,'-',0:epoch,pesos2,'--
',0:epoch,umbrales,'-.');
axis square
title('parametros vs. iteraciones');
xlabel('iteraciones');
ylabel('W1____W2 _ _ _B -.-.-.')
pause;
%RESUMEN DE RESULTADOS
%=====================
fprintf('valores finales de la red:\n')
fprintf('entrenada en %.0f iteraciones.\n',epoch);
fprintf('red clasificada:');
if all(sim(red,P) == T)
disp('correctamente.')
else
disp('incorrectamente.')
end
Valores aleatorios
Valores de la guia
1. Cules son los valores finales de los pesos y el umbral?
W1= 0.5 W2 = 1.5 =B = -0.5
2. Cambie el comportamiento de la red para que ahora se comporte
como una compuerta AND de dos entradas.
clf reset
pausa = 2;
%DEFINICION DEL PROBLEMA
%=======================
%Definicion de cuatro vectores de 2-elementos de entrada
P = [0 1 0 1; 0 0 1 1];
%Definicion de las cuatro salidas deseadas de 1-elemento
T = [0 1 1 1];
%GRAFICA DE LOS VECTORES A ENTRENAR
%=======================
disp('presione cualquier tecla para ver los vectores de entrada')
pause, disp('')
V = [-2 2 -2 2];
PR = [-2 2; -2 2];
plotpv(P,T,V);
figura=gcf;
axis('equal')
title('grafica de los vectores de entrada')
xlabel('Entrada 1')
xlabel('Entrada 2')
pause
%INICIALIZACION DE LA ARQUITECTURA DE LA RED
%=============================================
%Encuentre el tamao del vector de entrada R, el tamao de la capa S,
%el tamao del lote Q
[R,Q] = size(P); [S,Q]=size (T);
red=newp(PR,S);
%INICIALIZACION DE PESOS Y UMBRAL
z = menu('inicializar Pesos y umbral A',...
'condiciones inciales en la guia del estudiante',...
'valores aleatorios');
disp('')
if z == 1
red.IW{1,1}=[0.5 1.5]; red.b{1}=[1.5];
else
red.inputweights{1,1}.initFcn = 'rands';
red.biases{1}.initFcn = 'rands';
red=init(red);
end
%GRAFICA DE LA CLASIFICACION INICIAL
%===================================
hold on
linea = plotpc(red.IW{1,1},red.b{1});
%ENTRENAMIENTO DE LA RED
%=======================
%ENTRENAMIENTO DE LOS PARAMETROS
disp_freq = 1;
max_epoch = 20;
%NOTA:El resto del codigo de entrenamiento puede reemplazarse por:
%
%red.TrainParam.epochs=max_epoch;
%red=train(red,P,T);
%W=red.IW{1,1};
%B=red.b{1};
W = red.IW{1,1};
B = red.b{1};
pesos1 = [W(1,1)];
pesos2 = [W(1,2)];
umbrales = [B];
%FASE DE REPRESENTACION:
A = sim(red,P);
e = T-A;
for epoch=1:max_epoch
%FASE DE REVISION
if all(e==0), epoch=epoch-1; break, end
%FASE DE APRENDIZAJE
dW = learnp(W,P,[],[],[],[],e,[],[],[],[],[]);
dB = learnp(B,ones(1,Q),[],[],[],[],e,[],[],[],[],[]);
W = W + dW; B = B + dB;
red.IW{1,1}=W;
red.b{1}=[B];
%FASE DE REPRESENTACION
A = sim(red,P);
e = T-A,
%PRESENTACION EN PROGRESO
if rem(epoch,disp_freq) == 0
pause(pause), disp('')
linea=plotpc(W,B,linea); drawnow
end
pesos1=[pesos1 W(1,1)];
pesos2=[pesos2 W(1,2)];
umbrales=[umbrales B];
end
% GRAFICA DE CLASIFICACION FINAL
%===============================
figure(figura)
plotpc(W,B,linea); drawnow
pause
clf reset
%GRAFICA DE PESOS Y UMBRALES VS. EPOCH
%=====================================
plot(0:epoch,pesos1,'-',0:epoch,pesos2,'--',0:epoch,umbrales,'-.');
axis square
title('parametros vs. iteraciones');
xlabel('iteraciones');
ylabel('W1____W2 _ _ _B -.-.-.')
pause;
%RESUMEN DE RESULTADOS
%=====================
fprintf('valores finales de la red:\n')
W
B
fprintf('entrenada en %.0f iteraciones.\n',epoch);
fprintf('red clasificada:');
if all(sim(red,P) == T)
disp('correctamente.')
else
disp('incorrectamente.')
end
Valores aleatorios
4.-Cules son los valores finales de los pesos y el umbral?
W1= 1.5 W2= 1.5 = B= -2.5
5.-Cree un archivo m con el nombre per2.m que clasifique 10 puntos de
entrada dentro de cuatro regiones usando una capa de dos entradas de
neuronas:
Los pesos y umbrales iniciales de las entradas W0 = [-0.6926 0.6048; 0.1433
0.9339] y B0 = [0.0689; -0.0030].
clf reset
pausa = 2;
%DEFINICION DEL PROBLEMA
%=======================
%Definicion de diez vectores de 2 - elementos de entrada.
P = [+0.1 +0.7 +0.8 +0.8 +1;...
+1.2 +1.8 +1.6 +0.6 +0.8];
%Definicion de las 10 salidas deseadas 2 - elementos.
T = [1 1 1 0 0 ;
1 1 1 0 0 ];
%GRAFICA DE LOS VEECTORES A ENTRENAR
%===================================
disp('Presione cualquier tecla para ver los vectores de entrada')
pause, disp('')
V = [-2 2 -2 2];
%Los valores minimos y maximos de entrada son.
PR = [-2 2 ; -2 2];
plotpv(P,T,V);
figura=gcf;
axis('equal')
title('Grafica de los vectores de entrada')
xlabel('Entrada 1')
ylabel('Entrada 2')
pause
%INICIALIZACION DE LA ARQUITECTURA DE LA RED
%===========================================
%Encuentra el tamao del vector de entrada R, el tamao de la capa S,
%el tamao del lote Q
[R,Q] = size(P); [S,Q] = size (T);
red=newp(PR,S);
%inicializacion de pesos y umbral.
z = menu('Inicializar pesos y umbra A',...
'condiciones inciales en la guia del estudiante',...
'valores aleatorios');
disp('')
if z == 1
red.IW{1,1} = [-0.6926 0.6048; 0.1433 -0.9339];
red.b{1} =[0.0689 ; -0.0030];
else
red.inputweights{1,1}.initFcn = 'rands';
red.biases{1}.initFcn = 'rands';
red=init(red);
end
%GRAFICA DE LA CLASIFICACION INICIAL
%===================================
hold on
linea=plotpc(red.IW{1,1},red.b{1});
%ENTRENAMIENTO DE LA RED
%=======================
%ENTRENAMIENTO DE LOS PARAMETROS
disp_freq = 1;
max_epoch = 20;
%NOTA: el resto del codigo de entrenamiento puede reemplazarse por:
%
%red.TrainParam.epochs=mas_epoch;
%red=train(red,P,T);
%W=red.IW{1,1};
%B=red.b{1}
W = red.IW{1,1};
B = red.b{1};
pesos1 = [W(1,1)];
pesos2 = [W(1,2)];
umbrales = [B];
%FASE DE PRESENTACION:
A = sim(red,P);
e = T-A;
for epoch=1:max_epoch
%FASE DE REVISION:
if all(e==0), epoch=epoch-1; break, end
%FASE DE APRENDIZAJE:
dW = learnp(W,P,[],[],[],[],e,[],[],[],[],[]);
dB = learnp(B,ones(1,Q),[],[],[],[],e,[],[],[],[],[]);
W = W + dW; B = B + dB;
red.IW{1,1}=W;
red.b{1}=[B];
%FASE DE PRESENTACION:
A = sim(red,P);
e = T-A,
% PRESENTACION EN PROGRESO
if rem(epoch,disp_freq) == 0
pause(pausa), disp('')
linea=plotpc(W,B,linea); drawnow
end
pesos1 = [pesos1 W(1,1)];
pesos2 = [pesos2 W(1,2)];
umbrales = [umbrales B];
end
% GRAFICA DE CLASIFICACION FINAL
%==================================
figure(figura)
plotpc(W,B,linea); drawnow
pause
clf reset
%GRAFICA DE LOS PASOS Y LOS UMBRALES VS EPOCH
%============================================
plot(0:epoch,pesos1,'-',0:epoch,pesos2,'--',0:epoch,umbrales,':');
axis square
title('Parametros vs. Iteraciones');
xlabel('Iteraciones');
ylabel('W1 ___ W2 _ _ B ...');
pause
% RESUMEN DE RESULTADOS
%======================
fprintf('\nVALORES FINALES DE LA RED:\n')
W
B
fprintf('ENTRENADA EN %.0f iteraciones.\n',epoch)
fprintf('Red clasificada: ');
if all(sim(red,P) == T)
disp('Correctamente.')
else
disp('Incorrectamente.')
end
6.-Cree un archivo m para lograr una compuerta OR de 5 entradas.
clf reset
pausa = 2;
%DEFINICION DEL PROBLEMA
%=======================
%Definicion de diez vectores de 2 - elementos de entrada.
P = [+0.1 +0.7 +0.8 +0.8 +1;...
+1.2 +1.8 +1.6 +0.6 +0.8];
%Definicion de las 10 salidas deseadas 2 - elementos.
T = [1 1 1 0 0 ;
1 1 1 0 0 ];
%GRAFICA DE LOS VEECTORES A ENTRENAR
%===================================
disp('Presione cualquier tecla para ver los vectores de entrada')
pause, disp('')
V = [-2 2 -2 2];
%Los valores minimos y maximos de entrada son.
PR = [-2 2 ; -2 2];
plotpv(P,T,V);
figura=gcf;
axis('equal')
title('Grafica de los vectores de entrada')
xlabel('Entrada 1')
ylabel('Entrada 2')
pause
%INICIALIZACION DE LA ARQUITECTURA DE LA RED
%===========================================
%Encuentra el tamao del vector de entrada R, el tamao de la capa S,
%el tamao del lote Q
[R,Q] = size(P); [S,Q] = size (T);
red=newp(PR,S);
%inicializacion de pesos y umbral.
z = menu('Inicializar pesos y umbra A',...
'condiciones inciales en la guia del estudiante',...
'valores aleatorios');
disp('')
if z == 1
red.IW{1,1} = [-0.6926 0.6048; 0.1433 -0.9339];
red.b{1} =[0.0689 ; -0.0030];
else
red.inputweights{1,1}.initFcn = 'rands';
red.biases{1}.initFcn = 'rands';
red=init(red);
end
%GRAFICA DE LA CLASIFICACION INICIAL
%===================================
hold on
linea=plotpc(red.IW{1,1},red.b{1});
%ENTRENAMIENTO DE LA RED
%=======================
%ENTRENAMIENTO DE LOS PARAMETROS
disp_freq = 1;
max_epoch = 20;
%NOTA: el resto del codigo de entrenamiento puede reemplazarse por:
%
%red.TrainParam.epochs=mas_epoch;
%red=train(red,P,T);
%W=red.IW{1,1};
%B=red.b{1}
W = red.IW{1,1};
B = red.b{1};
pesos1 = [W(1,1)];
pesos2 = [W(1,2)];
umbrales = [B];
%FASE DE PRESENTACION:
A = sim(red,P);
e = T-A;
for epoch=1:max_epoch
%FASE DE REVISION:
if all(e==0), epoch=epoch-1; break, end
%FASE DE APRENDIZAJE:
dW = learnp(W,P,[],[],[],[],e,[],[],[],[],[]);
dB = learnp(B,ones(1,Q),[],[],[],[],e,[],[],[],[],[]);
W = W + dW; B = B + dB;
red.IW{1,1}=W;
red.b{1}=[B];
%FASE DE PRESENTACION:
A = sim(red,P);
e = T-A,
% PRESENTACION EN PROGRESO
if rem(epoch,disp_freq) == 0
pause(pausa), disp('')
linea=plotpc(W,B,linea); drawnow
end
pesos1 = [pesos1 W(1,1)];
pesos2 = [pesos2 W(1,2)];
umbrales = [umbrales B];
end
% GRAFICA DE CLASIFICACION FINAL
%==================================
figure(figura)
plotpc(W,B,linea); drawnow
pause
clf reset
%GRAFICA DE LOS PASOS Y LOS UMBRALES VS EPOCH
%============================================
plot(0:epoch,pesos1,'-',0:epoch,pesos2,'--',0:epoch,umbrales,':');
axis square
title('Parametros vs. Iteraciones');
xlabel('Iteraciones');
ylabel('W1 ___ W2 _ _ B ...');
pause
% RESUMEN DE RESULTADOS
%======================
fprintf('\nVALORES FINALES DE LA RED:\n')
W
B
fprintf('ENTRENADA EN %.0f iteraciones.\n',epoch)
fprintf('Red clasificada: ');
if all(sim(red,P) == T)
disp('Correctamente.')
else
disp('Incorrectamente.')
end
IV. CONCLUSIONES Y RECOMENDACIONES
o Un perceptrn simple puede contener varias neuronas, pero stas
deben estar agrupadas en una sola capa y tener la misma funcin de
activacin
o El Perceptrn Multicapa no extrapola bien, es decir, si la red se
entrena mal o de manera insuficiente, las salidas pueden ser
imprecisas.
o La neurona perceptrn solo servir si los valores pueden ser
linealmente separables, sea por un plano o una recta.
