Inteligencia Artificial Ing.

Mecatrnica

Gua de Laboratorio Programacin Red Perceptrn MATLAB

El Perceptrn Bsico.

1. Crear un archivo Matlab (archivo-m) con el nombre perc1.m que simule una compuerta
OR de dos entradas usando el Perceptrn bsico con Los pesos iniciales de las entradas 1 y
2 son 0.5 y 1.5 respectivamente y el peso del umbral es 1.5.

% EJEMPLO PERC1: COMPUERTA OR (UN PROBLEMA DE CLASIFICACIN SENCILLO)
%
% Se entrena 1 neurona de 2-entradas con funcin de activacin escaln % con la regla del
perceptrn para una clasificacin adecuada % 4 vectores de entrada en 2 regiones.

help perc1
clf reset
pausa = 2;
% DEFINICIN DEL PROBLEMA
%========================
% Definicin de cuatro vectores de 2-elementos de entrada.
P = [0 1 0 1;
0 0 1 1];
% Definicin de las cuatro salidas deseadas de 1-elemento.
T = [0 1 1 1];
% GRFICA DE LOS VECTORES A ENTRENAR
%===================================
disp('Presione cuaquier tecla para ver los vectores de entrada!')
pause, disp('')
V = [-2 2 -2 2];
% los valores mnimos y mximos de cada entrada son
PR = [-2 2 ; -2 2];
plotpv(P,T,V);
figura=gcf;
axis('equal')
title('Grfica de los vectores de entrada')
xlabel('Entrada 1')
ylabel('Entrada 2')
pause
% INICIALIZACIN 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);
% Inicializacin de pesos y umbral.
z = menu('Inicializar Pesos y Umbral A', ...
'Condiciones Iniciales en la gua del estudiante', ...
'Valores Aleatorios');
Inteligencia Artificial Ing. Mecatrnica

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
% GRFICA DE LA CLASIFICACIN INICIAL
%====================================
hold on
linea=plotpc(red.IW{1,1},red.b{1});
% ENTRENAMIENTO DE LA RED
%========================
% ENTRENAMIENTO DE LOS PARMETROS
disp_freq = 1;
max_epoch = 20;
% NOTA: El resto del cdigo 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 PRESENTACIN:
A = sim(red,P);
e = T-A;
for epoch=1:max_epoch
% FASE DE REVISIN:
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 PRESENTACIN:
A = sim(red,P);
e = T-A;
% PRESENTACIN EN PROGRESO
if rem(epoch,disp_freq) == 0
pause(pausa), disp('')
linea=plotpc(W,B,linea); drawnow
end
Inteligencia Artificial Ing. Mecatrnica

pesos1 = [pesos1 W(1,1)];
pesos2 = [pesos2 W(1,2)];
umbrales = [umbrales B];
end
% GRFICA DE CLASIFICACIN FINAL
%===============================
figure(figura)
plotpc(W,B,linea); drawnow
pause
clf reset
% GRFICA DE PESOS Y UMBRALES VS. EPOCH
%======================================
plot(0:epoch,pesos1,'-',0:epoch,pesos2,'--',0:epoch,umbrales,'-.');
axis square
title('Parmetros 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

2. Cuales son los valores finales de los pesos y el umbral.
W1 =______________, W2 =______________, = -B =______________.
3. Cambie el comportamiento de la red para que ahora se comporte como una compuerta
AND de dos entradas.
4. Cuales son los valores finales de los pesos y el umbral.
W1 =______________, W2 =______________, = -B =______________.

Clasificacin con mltiples neuronas.

5. Crear un archivo-m con el nombre perc2.m que clasifique 10 puntos de entrada dentro de
cuatro regiones usando una capa de dos entradas con dos neuronas: Los pesos y umbrales
iniciales de las entradas W0 = [-0.6926 0.6048; 0.1433 -0.9339] y B0 = [ 0.0689; -0.0030].
%
% EJEMPLO PERC2: CLASIFICACIN MULTI-NEURONA
%
% Se entrena 1 capa de 2-entradas con 2 neuronas con funcin de
activacin
Inteligencia Artificial Ing. Mecatrnica

% escaln
% con la regla del perceptrn para una clasificacin adecuada
% 10 vectores de entrada en 4 regiones.
help per2
clf reset
pausa = 2;
% DEFINICIN DEL PROBLEMA
%========================
% Definicin de diez vectores de 2-elementos de entrada.
P = [+0.1 +0.7 +0.8 +0.8 +1.0 +0.3 +0.0 -0.3 -0.5 -1.5; ...
+1.2 +1.8 +1.6 +0.6 +0.8 +0.5 +0.2 +0.8 -1.5 -1.3];
% Definicin de las diez salidas deseadas de 2-elementos.
T = [1 1 1 0 0 1 1 1 0 0;
0 0 0 0 0 1 1 1 1 1];
% GRFICA DE LOS VECTORES A ENTRENAR
%===================================
disp('Presione cuaquier tecla para ver los vectores de entrada!')
pause, disp('')
V = [-2 2 -2 2];
% los valores mnimos y mximos de cada entrada son
PR = [-2 2 ; -2 2];
plotpv(P,T,V);
figura=gcf;
axis('equal')
title('Grfica de los vectores de entrada')
xlabel('Entrada 1')
ylabel('Entrada 2')
pause
% INICIALIZACIN 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);
% Inicializacin de pesos y umbral.
z = menu('Inicializar Pesos y Umbral A', ...
'Condiciones Iniciales en la gua 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);
Inteligencia Artificial Ing. Mecatrnica

end
% GRFICA DE LA CLASIFICACIN INICIAL
%====================================
hold on
linea=plotpc(red.IW{1,1},red.b{1});
% ENTRENAMIENTO DE LA RED
%========================
% ENTRENAMIENTO DE LOS PARMETROS
disp_freq = 1;
max_epoch = 20;
% NOTA: El resto del cdigo 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 PRESENTACIN:
A = sim(red,P);
e = T-A;
for epoch=1:max_epoch
% FASE DE REVISIN:
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 PRESENTACIN:
A = sim(red,P);
e = T-A;
% PRESENTACIN 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
% GRFICA DE CLASIFICACIN FINAL
%===============================
figure(figura)
Inteligencia Artificial Ing. Mecatrnica

plotpc(W,B,linea); drawnow
pause
clf reset
% GRFICA DE PESOS Y UMBRALES VS. EPOCH
%======================================
plot(0:epoch,pesos1,'-',0:epoch,pesos2,'--',0:epoch,umbrales,':');
axis square
title('Parmetros 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.


Limitaciones del Perceptrn.

7. Cree un archivo-m que demuestre el efecto de un vector alejado en la convergencia del
perceptrn.

%
% EJEMPLO PERC3: EL EFECTO DE UN VECTOR ALEJADO
%
% Se entrena una neurona de 1 capa de 2-entradas con funcin de % activacin escaln
% con la regla del perceptrn para una clasificacin adecuada
% 5 vectores de entrada en 2 regiones.
% Debido a que uno de los vectores est alejado, el entrenamiento
% es a veces considerablemente lento.
help perc3
clf reset
pausa = 0.1;
% DEFINICIN DEL PROBLEMA
%========================
% Definicin de cinco vectores de 2-elementos de entrada.
P = [-0.5 -0.5 +0.3 -0.1 -80;
-0.5 +0.0 -0.5 +1.0 100];
Inteligencia Artificial Ing. Mecatrnica

% Definicin de las cinco salidas deseadas de 1-elemento.
T = [1 1 0 0 1];
% GRFICA DE LOS VECTORES A ENTRENAR
%===================================
disp('Presione cuaquier tecla para ver los vectores de entrada!')
pause, disp('')
V = [-100 2 -2 110];
% los valores minimos y maximos de cada entrada son
PR = [-100 2 ; -2 110];
plotpv(P,T,V);
figura=gcf;
axis('equal')
title('Grfica de los vectores de entrada')
xlabel('Entrada 1')
ylabel('Entrada 2')
pause
% INICIALIZACIN 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);
% Inicializacin de pesos y umbral.
z = menu('Inicializar Pesos y Umbral A', ...
'Condiciones Iniciales en la gua del estudiante', ...
'Valores Aleatorios');
disp('')
if z == 1
red.IW{1,1} = [-0.8997 -0.7783]; red.b{1} = [-0.0575];
else
red.inputweights{1,1}.initFcn = 'rands';
red.biases{1}.initFcn = 'rands';
red=init(red);
end
% GRFICA DE LA CLASIFICACIN INICIAL
%====================================
hold on
linea=plotpc(red.IW{1,1},red.b{1});
% ENTRENAMIENTO DE LA RED
%========================
% ENTRENAMIENTO DE LOS PARMETROS
disp_freq = 1;
max_epoch = 100;
% NOTA: El resto del cdigo de entrenamiento puede reemplazarse por:
%
% red.TrainParam.epochs = max_epoch;
% red=train(red,P,T);
% W=red.IW{1,1};
Inteligencia Artificial Ing. Mecatrnica

% 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 PRESENTACIN:
A = sim(red,P);
e = T-A;
for epoch=1:max_epoch
% FASE DE REVISIN:
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 PRESENTACIN:
A = sim(red,P);
e = T-A;
% PRESENTACIN 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
% GRFICA DE CLASIFICACIN FINAL
%===============================
figure(figura)
plotpc(W,B,linea); drawnow
pause
clf reset
% GRFICA DE PESOS Y UMBRALES VS. EPOCH
%======================================
plot(0:epoch,pesos1,'-',0:epoch,pesos2,'--',0:epoch,umbrales,':');
axis square
title('Parmetros vs. Iteraciones');
xlabel('Iteraciones');
ylabel('W1 ___ W2 _ _ B ...');
pause
% RESUMEN DE RESULTADOS
%======================
fprintf('\nVALORES FINALES DE LA RED:\n')
W
Inteligencia Artificial Ing. Mecatrnica

B
fprintf('Entrenada en %.0f iteraciones.\n',epoch)
fprintf('Red clasificada: ');
if all(sim(red,P) == T)
disp('Correctamente.')
else
disp('Incorrectamente.')
end
set(gcf,'NextPlot','replace')

8. Funcin de aprendizaje normalizada para evitar el efecto de vectores alejados.
9. Cree el siguiente archivo m y compruebe el efecto en el nmero de iteraciones necesarias
para entrenar la red.

% EJEMPLO PER3b: EL EFECTO DE UN VECTOR ALEJADO Y LA FUNCION DE
% APRENDIZAJE NORMALIZADA
%
% Se entrena una neurona de 1 capa de 2-entradas con funcin de
% activacin escaln
% con la regla del perceptrn normalizada para una clasificacin adecuada
% 5 vectores de entrada en 2 regiones.
% Debido al aprendizaje normalizado se evita un entrenamiento lento.
help per3
clf reset
pausa = 1;
% DEFINICIN DEL PROBLEMA
%========================
% Definicin de cinco vectores de 2-elementos de entrada.
P = [-0.5 -0.5 +0.3 -0.1 -80;
-0.5 +0.0 -0.5 +1.0 100];
% Definicin de las cinco salidas deseadas de 1-elemento.
T = [1 1 0 0 1];
% GRFICA DE LOS VECTORES A ENTRENAR
%===================================
disp('Presione cuaquier tecla para ver los vectores de entrada!')
pause, disp('')
V = [-100 2 -2 110];
% los valores minimos y maximos de cada entrada son
PR = [-100 2 ; -2 110];
plotpv(P,T,V);
figura=gcf;
axis('equal')
title('Grfica de los vectores de entrada')
xlabel('Entrada 1')
ylabel('Entrada 2')
pause
% INICIALIZACIN DE LA ARQUITECTURA DE LA RED
%============================================
Inteligencia Artificial Ing. Mecatrnica

% 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,'hardlim','learnpn'); %aprendizaje normalizado
% Inicializacin de pesos y umbral.
z = menu('Inicializar Pesos y Umbral A', ...
'Condiciones Iniciales en la gua del estudiante', ...
'Valores Aleatorios');
disp('')
if z == 1
red.IW{1,1} = [-0.8997 -0.7783]; red.b{1} = [-0.0575];
else
red.inputweights{1,1}.initFcn = 'rands';
red.biases{1}.initFcn = 'rands';
red=init(red);
end
% GRFICA DE LA CLASIFICACIN INICIAL
%====================================
hold on
linea=plotpc(red.IW{1,1},red.b{1}); drawnow;
% ENTRENAMIENTO DE LA RED
%========================
% ENTRENAMIENTO DE LOS PARMETROS
disp_freq = 1;
max_epoch = 20;
red.adaptParam.passes=1;
epoch = 0;
e = 1;
W = red.IW{1,1};
B = red.b{1};
while (sse(e) | epoch==max_epoch)
epoch=epoch+1;
[red,Y,e]=adapt(red,P,T); %entrenamiento con la funcion de
adaptacion.
W = red.IW{1,1};
B = red.b{1};
linea=plotpc(W,B,linea); drawnow;
end
% 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
Inteligencia Artificial Ing. Mecatrnica

disp('Incorrectamente.')
end
set(gcf,'NextPlot','replace')

Perceptrn de 2 capas.

10. Escribir un archivo-m que simule una compuerta XOR de dos capas usando el perceptrn
de dos capas:

%
% EXAMPLE PERC4: CLASIFICACIN MULTI-CAPA
%
% Se entrenan tres neurona de 3 capas de 2-entradas con funcin de
% activacin escaln
% con la regla del perceptrn para una clasificacin adecuada
% 4 vectores de entrada en 3 regiones.

help perc4
clf reset
pausa = 1;
% DEFINICIN DEL PROBLEMA
%========================
% Definicin de cuatro vectores de 2-elementos de entrada.
P = [0 1 0 1;
0 0 1 1];
% Definicin de las cuatro salidas deseadas de 2-elementos de la primera
capa.
T1 = [0 1 1 1;
0 0 0 1];
% Definicin de las cuatro salidas deseadas de 1-elemento de la segunda
capa.
T2 = [0 1 1 0];
% GRFICA DE LOS VECTORES A ENTRENAR
%===================================
V = [-2 2 -2 2];
% los valores mnimos y mximos de cada entrada son
PR = [-2 2 ; -2 2];
plotpv(P,T2,V);
figura=gcf;
axis('equal')
title('Grfica de los vectores de entrada')
xlabel('Entrada 1')
ylabel('Entrada 2')
% INICIALIZACIN 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.
Inteligencia Artificial Ing. Mecatrnica

[R1,Q1] = size(P); [S1,Q1] = size(T1);
[R2,Q2] = size(T1); [S2,Q2] = size(T2);
red1=newp(PR,S1);
red2=newp(PR,S2);
% Inicializacin de pesos y umbral.
red1.IW{1,1}= [1 1;
1 1];
red2.IW{1,1} = [1 -1.5];
red1.b{1} = [ 0.5;
1.5];
red2.b{1} = [0.5];
% ENTRENAMIENTO DE LA RED
%========================
% ENTRENAMIENTO DE LOS PARMETROS
disp_freq = 1;
max_epoch = 20;
W1 = red1.IW{1,1};
W2 = red2.IW{1,1};
B1 = red1.b{1};
B2 = red2.b{1};
% FASE DE PRESENTACIN:
A1 = sim(red1,P);
A2 = sim(red2,double(A1));
e1 = T1-A1;
e2 = T2-A2;
for epoch=1:max_epoch
% FASE DE REVISIN:
if all(e1 == 0) & all(e2 == 0), , epoch=epoch-1; break, end
% FASE DE APRENDIZAJE:
dW1 = learnp(W1,P,[],[],[],[],e1,[],[],[]);
dB1 = learnp(B1,ones(1,Q1),[],[],[],[],e1,[],[],[]);
dW2 = learnp(W2,A1,[],[],[],[],e2,[],[],[]);
dB2 = learnp(B2,ones(1,Q2),[],[],[],[],e2,[],[],[]);
W1 = W1 + dW1; B1 = B1 + dB1;
W2 = W2 + dW2; B2 = B2 + dB2;
red1.IW{1,1}=W1;
red1.b{1}=[B1];
red2.IW{1,1}=W2;
red2.b{1}=[B2];
A1 = sim(red1,P);
A2 = sim(red2,double(A1));
e1 = T1-A1;
e2 = T2-A2;
end
% RESUMEN DE RESULTADOS
%======================
fprintf('\nVALORES FINALES DE LA RED:\n')
W=[W1;W2]
Inteligencia Artificial Ing. Mecatrnica

B=[B1;B2]
fprintf('Entrenada en %.0f iteraciones.\n',epoch)
fprintf('Red clasificada: ');
if all(sim(red1,P) == T1)& all(sim(red2,double(A1)) == T2)
disp('Correctamente.')
else
disp('Incorrectamente.')
end
set(gcf,'NextPlot','replace')

11. Salga de los programas y apague la computadora.