UNIVERSIDAD CATOLICA SANTA MARIA

FACULTAD DE CIENCIAS E INGENIERÍAS

FÍSICAS Y FORMALES
ESCUELA PROFESIONAL DE INGENIERIA MECÁNICA, MECÁNICA
ELÉCTRICA Y MECATRÓNICA







CURSO:

Procesos Inteligentes
ALUMNO(S):

PAREDES CARPIO, WLADIMIR

DOCENTE:

MESTAS RAMOS, SERGIO ORLANDO

SEMESTRE: X GRUPO: 01

AREQUIPA – PERÚ

2021
 REDES ADALINE
1. OBJETIVO GENERAL:

- Utilizar Matlab para poder 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 ingeniería desde esta perspectiva.
- Comprender sólidamente el funcionamiento de las redes ADALINE.
- Ser capaz de programar con éxito simulaciones de estas redes.

2. MATERIALES Y EQUIPOS:

- Computador
- Sistema operativo Windows cualquier versión
- Matlab

3. PROCEDIMIENTO:

RED ADALINE BASICA

Cree un archivo-m con el nombre de adeline1.m que obtenga una salida deseada para
cada uno de los datos a la entrada usando la arquitectura ADALINE:
Los datos de entrada son P = [+1.0 -1.2], las salidas son T = [+1.0 +0.5], el peso inicial
de la entrada es -0.9309, el peso de la entrada del umbral es -08931 y el error
cuadrático medio debe ser menor o igual a 0.001.

CÓDIGO:
%Ejemplo ADALINE1:ASOCIACIÓN DE PATRONES
%Autor: Paredes Carpio, Wladimir
clear all;close all;clc;
clf reset
tiempopausa = 0.01;
% DEFINICIÓN DEL PROBLEMA
%========================
% Definición de los dos vectores de entrada de 1 elemento.
P = [+1.0 -1.2];
% Definición de los dos vectores deseados de 1 elemento.
T = [+1.0 +0.5];
% GRÁFICA DE MALLA DEL ERROR
%===========================
disp('Calculado la superficie de error, por favor espere...'),
disp('')
Wrango = -1:.1:1;
Brango = -1:.1:1;
SE = errsurf(P,T,Wrango,Brango,'purelin');
disp('Presione cualquier tecla para ver la superficie de error.'),
disp(''), pause
plotes(Wrango,Brango,SE);
figura=gcf;
subplot(1,2,1)
title('Gráfica de la Superficie de Error');
xlabel('Peso W');
ylabel('-Umbral B');
zlabel('Error Cuadrado Medio');
subplot(1,2,2)
title('Gráfico de Contorno del Error');
xlabel('Peso W');
ylabel('Umbral B');
pause
% INICIALIZACIÓN DE LA ARQUITECTURA DE LA RED
%============================================
% Encuentra el tamaño del vector de entrada R, el tamaño de la capa
S, el tamaño del lote Q.
[R,Q] = size(P); [S,Q] = size(T);
% DISEÑO DE LA RED
%=================
PR=[-2 2]; %rango del elemento de entrada.
ID=[0]; %Vector de Retraso de Entrada.
max_razon_aprendizaje = 0.4 * maxlinlr(P,'bias');
red=newlin(PR,S,ID,max_razon_aprendizaje);
% Inicialización de pesos y umbral.
z = menu('Inicializar Pesos y Umbral a:','Condiciones Iniciales en
la guía del estudiante','Marcar Valores con el Ratón/Teclas de
Desplazamiento sobre el graf. de contorno','Valores Aleatorios');
disp('');
if z == 1
red.IW{1,1} = [-0.9309];
red.b{1} = [-0.8931];
elseif z == 3
red.inputweights{1,1}.initFcn = 'rands';
red.biases{1}.initFcn = 'rands';
red=init(red);
end
% GRÁFICA DE CONTORNO DEL ERROR, CONDICIONES INICIALES, SOLUCIÓN
DISEÑADA
%==================================================================
======
figure(figura)
subplot(1,2,2)
axis('equal')
if z == 2
title('SELECIONE W y B AQUI')
[red.IW{1,1},red.b{1}] = ginput(1);
title('Gráfico de Contorno del Error')
end
% FASE DE PRESENTACIÓN:
A=sim(red,P);
E=T-A;
SSE=sumsqr(E);
punto=plotep(red.IW{1,1},red.b{1},SSE);
pause(tiempopausa);
% ENTRENAMIENTO DE LA RED
%========================
% ENTRENAMIENTO DE LOS PARÁMETROS
presenta_frec = 1;
max_iteracion = 200;
meta_error = 0.001;
red.trainParam.goal = meta_error;
LP.lr = max_razon_aprendizaje;
% NOTA: El resto del código de entrenamiento puede reemplazarse
por:
%
% [red, tr]=train(red,P,T);
% iteracion = length(tr.epoch)-1;
% SSE = tr.perf(length(tr.perf));
%
% PARÁMETROS DE LA RED
W = red.IW{1,1};
B = red.b{1};
% REGISTRO DEL ENTRENAMIENTO
errores = [SSE];
for iteracion=1:max_iteracion
% FASE DE REVISIÓN:
if SSE < meta_error, iteracion=iteracion-1;
break,
end
LW = W; LB = B;
% FASE DE APRENDIZAJE:
dW = learnwh(W,P,[],[],[],[],E,[],[],[],LP,[]);
dB = learnwh(B,ones(1,Q),[],[],[],[],E,[],[],[],LP,[]);
W = W + dW; B = B + dB;
red.IW{1,1}=W;
red.b{1}=B;
% FASE DE PRESENTACIÓN
A=sim(red,P); E = T-A;
SSE = sumsqr(E);
% REGISTRO DEL ENTRENAMIENTO
errores = [errores SSE];
% PRESENTACIÓN DEL PROGRESO
if rem(iteracion,presenta_frec) == 0
punto=plotep(W,B,SSE,punto);
pause(tiempopausa);
drawnow
end
end
red.IW{1,1} = W;
red.b{1} = B;
% GRÁFICA DE CLASIFICACIÓN FINAL
%===============================
punto=plotep(W,B,SSE,punto);
pause
set(gcf,'NextPlot','replace')
% GRÁFICA DE LA CURVA DE ERROR
%=============================
semilogy(0:iteracion,errores,0:iteracion,meta_error*ones(1,iteracio
n+1));
title('Error de la Red')
xlabel('iteraciones')
ylabel('error cuadrado medio')
pause;
% GRÁFICA DE LOS ERRORES ASOCIADOS A CADA VECTOR DE SALIDA
%=========================================================
bar(T-A);
title('Error de cada vector de salida');
xlabel('Salida');
ylabel('error de cada salida');
pause
% RESUMEN DE RESULTADOS
%======================
fprintf('\nVALORES DE LA RED ENTRENADA:\n')
W
B
fprintf('Entrenada en %.0f iteraciones.\n',iteracion)
fprintf('La meta del error cuadrático medio fue%g.\n',meta_error);
fprintf('Error cuadrático medio final de %g.\n',SSE);
fprintf('La red entrenada opera: ');
if SSE < meta_error
disp('Adecuadamente.')
else
disp('Inadecuadamente.')
end

INTERFAS
Calculado la superficie de error, por favor espere...
Presione cualquier tecla para ver la superficie de error.

VALORES DE LA RED ENTRENADA:

W =
0.2205
B =
0.7569

Entrenada en 13 iteraciones.
La meta del error cuadrático medio fue0.001.
Error cuadrático medio final de 0.000572775.
La red entrenada opera: Adecuadamente.
CAMBIO DE LA TAZA DE APRENDIZAJE

Cree un archivo-m con el nombre de adeline2.m que obtenga una salida deseada para
cada uno de los datos a la entrada usando la arquitectura ADALINE:
Los datos de entrada son P = [+1.0 -1.2], las salidas deseadas son T = [+1.0 +0.5], el
peso inicial de la entrada es 1.6960, el peso de la entrada del umbral es -1.0052 y el
error cuadrático medio debe ser menor o igual a 0.001. Corra el programa para una
razón de aprendizaje de 0.9, 1.7 y 2.5 veces la máxima.

CÓDIGO:
% EJEMPLO ADALINE2: TAZA DE APRENDIZA MUY GRANDE
%Autor: Paredes Carpio, Wladimir
% máximo.El resultado es una red con problemas de aprendizaje.
clear all;close all;clc;
%help adaline2
clf reset
tiempopausa = 0.3;
% DEFINICIÓN DEL PROBLEMA
%========================
% Definición de los dos vectores de entrada de 1 elemento.
P = [+1.0 -1.2];
% Definición de los dos vectores deseados de 1 elemento.
T = [+0.5 +1.0];
% GRÁFICA DE MALLA DEL ERROR
%===========================
disp('Calculado la superficie de error, por favor espere...'),
disp('')
Wrango = -1:.1:1;
Brango = -1:.1:1;
SE = errsurf(P,T,Wrango,Brango,'purelin');
disp('Presione cualquier tecla para ver la superficie de error.'),
disp(''), pause
plotes(Wrango,Brango,SE);
figura=gcf;
subplot(1,2,1)
title('Gráfica de la Superficie de Error')
xlabel('Peso W');
ylabel('-Umbral B');
zlabel('Error Cuadrado Medio');
subplot(1,2,2)
title('Gráfico de Contorno del Error');
xlabel('Peso W');
ylabel('Umbral B');
pause
% INICIALIZACIÓN DE LA ARQUITECTURA DE LA RED
%============================================
% Encuentra el tamaño del vector de entrada R, el tamaño de la capa
S, el tamaño del lote Q.
[R,Q] = size(P); [S,Q] = size(T);
%
PR=[-2 2]; %rango del elemento de entrada.
ID=[0]; %Vector de Retraso de Entrada.
max_razon_aprendizaje = 0.4 * maxlinlr(P,'bias');
red=newlin(PR,S,ID,max_razon_aprendizaje);
% Inicialización de pesos y umbral.
z1 = menu('Inicializar Pesos y Umbral a:','Condiciones Iniciales en
la guía del estudiante','Marcar Valores con el Ratón/Teclas de
Desplazamiento sobre el graf. de contorno','Valores Aleatorios');
disp('');
if z1 == 1
red.IW{1,1} = [1.6960];
red.b{1} = [-1.0052];
elseif z1 == 3
red.inputweights{1,1}.initFcn = 'rands';
red.biases{1}.initFcn = 'rands';
red=init(red);
end
z2 = menu('Usar una taza de aprendizaje de:','0.9 * maxlinlr','1.7
* maxlinlr','2.5 * maxlinlr');
disp('')
% GRÁFICA DE CONTORNO DEL ERROR, CONDICIONES INICIALES, SOLUCIÓN
DISEÑADA
%=================================================================
figure(figura)
subplot(1,2,2)
axis('equal')
if z1 == 2
title('SELECIONE W y B AQUI')
[red.IW{1,1},red.b{1}] = ginput(1);
title('Gráfico de Contorno del Error')
end
% ENTRENAMIENTO DE LA RED
%========================
% ENTRENAMIENTO DE LOS PARÁMETROS
presenta_frec = 1;
max_iteracion = 30;
meta_error = 0.001;
red.trainParam.goal = meta_error;
if z2 == 1
% DISEÑO DE LA RED
%=================
PR=[-2 2]; %rango del elemento de entrada.
ID=[0]; %Vector de Retraso de Entrada.
max_razon_aprendizaje = 0.9 * maxlinlr(P,'bias');
red=newlin(PR,S,ID,max_razon_aprendizaje);
elseif z2 == 2
% DISEÑO DE LA RED
%=================
PR=[-2 2]; %rango del elemento de entrada.
ID=[0]; %Vector de Retraso de Entrada.
max_razon_aprendizaje = 1.7 * maxlinlr(P,'bias');
red=newlin(PR,S,ID,max_razon_aprendizaje);
else
% DISEÑO DE LA RED
%=================
PR=[-2 2]; %rango del elemento de entrada.
ID=[0]; %Vector de Retraso de Entrada.
max_razon_aprendizaje = 2.5 * maxlinlr(P,'bias');
red=newlin(PR,S,ID,max_razon_aprendizaje);
end
LP.lr = max_razon_aprendizaje;
% FASE DE PRESENTACIÓN:
A=sim(red,P); E=T-A;
SSE=sumsqr(E); punto=plotep(red.IW{1,1},red.b{1},SSE);
pause(tiempopausa);
% NOTA: El resto del código de entrenamiento puede reemplazarse
por:
% [red, tr]=train(red,P,T);
% iteracion = length(tr.epoch)-1;
% SSE = tr.perf(length(tr.perf));
%
% PARÁMETROS DE LA RED
W = red.IW{1,1};
B = red.b{1};
% REGISTRO DEL ENTRENAMIENTO
errores = [SSE];
for iteracion=1:max_iteracion
% FASE DE REVISIÓN:
if SSE < meta_error, iteracion=iteracion-1; break, end
LW = W; LB = B;
% FASE DE APRENDIZAJE:
dW = learnwh(W,P,[],[],[],[],E,[],[],[],LP,[]);
dB = learnwh(B,ones(1,Q),[],[],[],[],E,[],[],[],LP,[]);
W = W + dW; B = B + dB;
red.IW{1,1}=W;
red.b{1}=B;
% FASE DE PRESENTACIÓN
A=sim(red,P); E = T-A;
SSE = sumsqr(E);
% REGISTRO DEL ENTRENAMIENTO
errores = [errores SSE];
% PRESENTACIÓN DEL PROGRESO
if rem(iteracion,presenta_frec) == 0
punto=plotep(W,B,SSE,punto);
pause(tiempopausa);
drawnow
end
end
red.IW{1,1} = W;
red.b{1} = B;
% GRÁFICA DE CLASIFICACIÓN FINAL
%===============================
punto=plotep(W,B,SSE,punto);
pause
set(gcf,'NextPlot','replace')
% GRÁFICA DE LA CURVA DE ERROR
%=============================
semilogy(0:iteracion,errores,0:iteracion,meta_error*ones(1,iteracio
n+1));
title('Error de la Red')
xlabel('iteraciones')
ylabel('error cuadrado medio')
pause;
% GRÁFICA DE LOS ERRORES ASOCIADOS A CADA VECTOR DE SALIDA
%=========================================================
bar(T-A);
title('Error de cada vector de salida')
xlabel('Salida')
ylabel('error de cada salida')
pause
% RESUMEN DE RESULTADOS
%======================
fprintf('\nVALORES DE LA RED ENTRENADA:\n')
W
B
fprintf('Entrenada en %.0f iteraciones.\n',iteracion)
fprintf('La meta del error cuadrático medio fue%g.\n',meta_error);
fprintf('Error cuadrático medio final de %g.\n',SSE);
fprintf('La red entrenada opera: ');
if SSE < meta_error disp('Adecuadamente.')
else disp('Inadecuadamente.')
end

RESULTADOS:

Calculado la superficie de error, por favor espere...

Presione cualquier tecla para ver la superficie de error.

VALORES DE LA RED ENTRENADA:

W=

-0.2334
B=

0.7101

Entrenada en 3 iteraciones.
La meta del error cuadrático medio fue0.001.
Error cuadrático medio final de 0.000639509.
La red entrenada opera: Adecuadamente.

Calculado la superficie de error, por favor espere...

Presione cualquier tecla para ver la superficie de error.

VALORES DE LA RED ENTRENADA:

W=
-0.2451
B=
0.7342
Entrenada en 9 iteraciones.
La meta del error cuadrático medio fue0.001.
Error cuadrático medio final de 0.00091789.
La red entrenada opera: Adecuadamente.
Calculado la superficie de error, por favor espere...
Presione cualquier tecla para ver la superficie de error.

VALORES DE LA RED ENTRENADA:

W=
8.4394e+04
B=
-3.2627e+04

Entrenada en 30 iteraciones.
La meta del error cuadrático medio fue0.001.
Error cuadrático medio final de 2.0609e+10.
La red entrenada opera: Inadecuadamente.
4. CONCLUSIONES:

- Gracias a las redes neuronales podemos observar su forma de operar.

- Podemos realizar códigos en Matlab sobre redes neuronales y ver el
comportamiento de sí misma.
- Gracias a las arquitecturas ADALINE podemos obtener resultados de entradas de
pesos y umbrales con poco error.
- Dependiendo de las condiciones iniciales la red se puede comportar
adecuadamente como no adecuada.