UNIVERSIDAD NACIONAL DEL CALLAO

FACULTAD DE INGENIERIA ELÉCTRICA Y ELECTRÓNICA

ESCUELA PROFESIONAL DE INGENIERÍA ELECTRÓNICA

CONTROL INTELIGENTE
LABORATORIO N°2
REDES NEURONALES ADALINE

 PROFESOR: Astocondor Villar, Jacob

 ALUMNOS:
Arteaga Aparicio, Alexander 1513240019
Chero Olazabal, Diego Alexander 1513210153
Ramírez Navarro, Jheral 1523220761
Tarazona Calixto, Hayrold Edison 1523210157

 GRUPO:
90G

2021
 REDES NEURONALES ADALINE
I. OBJETIVOS
 Comprender sólidamente el funcionamiento de las redes que utilizan la arquitectura ADALINE.
 Ser capaz de programar con éxito simulaciones de estas redes.

II. INTRODUCCION

III. MARCO TEORICO

REDES ADALINE Y MADALINE

Las redes ADALINE (ADAptive LINear Element) y MADALINE (Multiple ADALINE) fueron desarrolladas por
Bernie Widrow en la Universidad de Stanford poco después de que Rosenblatt desarrollara el
Perceptrón. Las arquitecturas de ADALINE y MADALINE son esencialmente las mismas que las del
Perceptron.

Ambas estructuras usan neuronas con funciones de transferencia escalón. La red ADALINE está limitada
a una única neurona de salida, mientras que MADALINE puede tener varias. La diferencia fundamental
respecto al Perceptron se refiere al mecanismo de aprendizaje. ADALINE y MADALINE utilizan la
denominada regla Delta de Hidrow-Hoff o regla del mínimo error cuadrado medio (LMS), basada en la
búsqueda del mínimo de una expresión del error entre la salida deseada y la salida lineal obtenida antes
de aplicarle la función de activación escalón (frente a la salida binaria utilizada en el caso del
Perceptron). Debido a esta nueva forma de evaluar el error, estas redes pueden procesar información
analógica, tanto de entrada como de salida, utilizando una función de activación lineal o sigmoidal.

IV. MATERIALES
 Un computador personal.
 Software matlab.

V. DESARROLLO

PARTE I. La red ADALINE Básica.

1. Encienda la computadora y dentro de Windows ejecute el programa MATLAB.

2. Cree un archivo-m con el nombre adaline1.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 = [+0.5 +1.0], el peso inicial de la entrada
es -0.9309, el peso de la entrada del umbral es -0.8931 y el error cuadrático medio debe ser menor o igual a
0.001.

Anote sus observaciones

% EJEMPLO ADALINE1: ASOCIACIÓN DE PATRONES

% Parte I de la guia del estudiante Redes Neuronales
%
% Una red, que consiste de 1 entrada alimentada a una sola
% neurona lineal, se entrena con la regla de aprendizaje
% de Widrow-Hoff para obtener el vector deseado correcto
% para cada uno de los dos vectores de entrada.
% La red aprende al ajustar los pesos y umbrales
% en proporción a sus efectos sobre el error de la red
% hasta que se encuentra un punto de mínimo error.
help adaline1
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 = [+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);
% 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,iteracion+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
Entrena 12 iteraciones
La meta del error cuadratico medio fue 0.001.
Error cuadratico medio final de 0.009503.
La red opera: Adecuadamente

PARTE II. Efecto del cambio de la taza de aprendizaje.

5. Cree un archivo-m con el nombre adaline2.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 = [+0.5 +1.0], 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. Anote sus
conclusiones.

% EJEMPLO ADALINE2: TAZA DE APRENDIZA MUY GRANDE

% Parte II de la guía del estudiante Redes Neuronales
%
% Una red, que consiste de 2 entradas alimentadas a una sola
% neurona lineal, se entrena con la regla de aprendizaje
% de Widrow-Hoff para obtener el vector deseado correcto
% para el único vector de entrada.
% La taza de aprendizaje se pone por arriba del valor estable
% máximo. El resultado es una red con problemas de aprendizaje.
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);
%
% 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,iteracion+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
PARTE III. Efecto de la selección de los datos de entrada.

6. Cree un archivo-m con el nombre adaline3.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.5, +3.0, -1.2], las salidas deseadas son T = [+0.5, +1.1, +3.0, -1.0], el
peso inicial de la entrada es -0.2330, el peso de la entrada del umbral es 0.0388 y el error cuadrático
medio debe ser menor o igual a 0.001.

Anote sus observaciones

% EJEMPLO3: SOBREDETERMINADA
% Parte III de la guía del estudiante Redes Neuronales
%
% Una red, que consiste de 1 entrada alimentada a una sola
% neurona lineal, se entrena con la regla de aprendizaje
% de Widrow-Hoff para obtener el vector deseado correcto
% para cada uno de los cuatro vectores de entrada.
% La red está mas restringida (4 pares Entradas-Salidas deseadas)
% que sus 2 grados de libertad (peso y umbral). El
% resultado es que la solución de error mínimo tiene
% un error finito
help adaline3
clf reset
tiempopausa = 0.1;
% DEFINICIÓN DEL PROBLEMA
%========================
% Definición de los cuatro vectores de entrada de 1 elemento.
P = [+1.0 +1.5 +3.0 -1.2];
% Definición de los cuatro vectores deseaodos de 1 elemento asociados.
T = [+0.5 +1.1 +3.0 -1.0];
% GRÁFICA DE MALLA DEL ERROR
%===========================
disp('Calculado la superficie de error, por favor espere...'), disp('')
Wrango = -2:.2:2;
Brango = -2:.2:2;
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.9 * 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.2330]; red.b{1} = [0.0388];
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 = 40;
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,iteracion+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('Adecuadamente.')
end
7. Cree un archivo-m con el nombre adaline4.m que obtenga una salida deseada para cada uno de los
datos a la entrada usando la arquitectura ADALINE:

El dato de entrada es P = [+1.0], la salida deseada es T = [+0.5], el peso inicial de la entrada es de [-1.2330],
el peso de la entrada del umbral es [0.0388] y el error cuadrático medio debe ser menor o igual a 0.001.

Anote sus observaciones

% EJEMPLO4: SUBDETERMINADA
% Parte III de la guía del estudiante Redes Neuronales
%
% Una red, que consiste de 2 entradas alimentadas a una sola
% neurona lineal, se entrena con la regla de aprendizaje
% de Widrow-Hoff para obtener el vector deseado correcto
% para el único vector de entrada.
% La red tiene menos restricción (1 par Entrada-Salida
%deseada)
% que sus 2 grados de libertad (peso y umbral). El
% resultado es que hay un infinito número de soluciones
% de error cero
help adaline4
clf reset
tiempopausa = 0.1;
% DEFINICIÓN DEL PROBLEMA
%========================
% Definición de los cuatro vectores de entrada de 1 elemento.
P = [+1.0];
% Definición de los cuatro vectores deseados de 1 elemento asociados.
T = [+0.5];
% GRÁFICA DE MALLA DEL ERROR
%===========================
disp('Calculado la superficie de error, por favor espere...'), disp('')
Wrango = -2:.2:2;
Brango = -2:.2:2;
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.9 * 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} = [-1.2330]; red.b{1} = [0.0388];
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 = 50;
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,iteracion+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
PARTE IV. ADALINE de varias neuronas.

8. Cree un archivo-m con el nombre adaline4.m que obtenga las salidas deseadas para cada uno de los
datos a la entrada usando la arquitectura ADALINE:

Los datos de entrada son P = [+1.0, +1.5, +1.2, -0.3; -1.0, +2.0, +3.0, -0.5; +2.0, +1.0, -1.6, +0.9], las salidas
deseadas son T= [+0.5, +3.0, -2.2, +1.4; +1.1, -1.2, +1.7, -0.4; +3.0, +0.2, -1.8, -0.4; -1.0, +0.1, -1.0, +0.6], los
pesos iniciales son W0 = [+1.9978, -0.5959, -0.3517; +1.5543, +0.0531, +1.3660; -1.0672, +0.3645, -0.9227;
-0.7747, +1.3839, -0.3384], los pesos de los umbrales son B0 = [+0.0746;-0.0642;-0.4256;-0.6433]; y el error
cuadrático medio debe ser menor o igual a 0.001.

Anote sus observaciones

% EJEMPLO ADALINE5: ASOCIACIÓN DE PATRONES MULTI-NEURONA
% Parte IV de la guía del estudiante Redes Neuronales
%
% Una red, consistente de 3 entradas alimentadas a una capa de
% 4 neuronas lineales, se entrena con la regla de aprendizaje
% Widrow-Hoff para obtener el vector deseado correcto
% para cada uno de los 4 vectores de entrada.
% Una vez la red está entrenada, puede reproducir los
% vectores deseados bastante bien cuando se presentan
% los vectores de entradas.
help adaline5
tiempopausa = 0.1;
% DEFINICIÓN DEL PROBLEMA
%========================
% Definición de los cuatro vectores de entrada de 3 elementos.
P = [+1.0 +1.5 +1.2 -0.3
-1.0 +2.0 +3.0 -0.5
+2.0 +1.0 -1.6 +0.9];
% Definición de los cuatro vectores deseados de 4 elementos asociados.
T = [+0.5 +3.0 -2.2 +1.4
+1.1 -1.2 +1.7 -0.4
+3.0 +0.2 -1.8 -0.4
-1.0 +0.1 -1.0 +0.6];
% 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;
-2 2
-2 2]; %rango del elemento de entrada.
ID=[0]; %Vector de Retraso de Entrada.
max_razon_aprendizaje = 0.99 * 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', ...
'Valores Aleatorios');
disp('');
if z == 1
red.IW{1,1} = [+1.9978 -0.5959 -0.3517;
+1.5543 +0.0531 +1.3660;
-1.0672 +0.3645 -0.9227;
-0.7747 +1.3839 -0.3384];
red.b{1} = [+0.0746;-0.0642;-0.4256;-0.6433];
else
red.inputweights{1,1}.initFcn = 'rands';
red.biases{1}.initFcn = 'rands';
red=init(red);
end
% ERROR INICIAL
%==============
SSE = sumsqr(T-sim(red,P));
fprintf('Antes del entrenamiento, error cuadrático medio = %g\n\n',SSE);
pause(tiempopausa);
% ENTRENAMIENTO DE LA RED
%========================
% ENTRENAMIENTO DE LOS PARÁMETROS
max_iteracion = 400;
meta_error = 0.001;
red.trainParam.goal = meta_error;
red.trainParam.epochs = max_iteracion;
[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};
% 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

Una red, consistente de 3 entradas alimentadas a una capa de 4 neuronas lineales, se entrena con la regla
de aprendizaje Widrow-Hoff para obtener el vector deseado correcto para cada uno de los 4 vectores de
entrada.

Una vez la red está entrenada, puede reproducir los vectores deseados bastante bien cuando se presentan
los vectores de entradas.

Antes del entrenamiento, error cuadrático medio = 144.463

VALORES DE LA RED ENTRENADA:

W=

-2.3709 2.2168 3.0878

2.1435 -1.7787 -2.0272

2.0469 -1.2342 0.0733

-1.6771 0.9672 0.9825

B=

-1.0224

1.1987

-0.4530

-0.3103

Entrenada en 198 iteraciones. La meta del error cuadrático medio fue 0.001.

Error cuadrático medio final de 0.000989955.

La red entrenada opera: Adecuadamente.

PARTE V. Aplicación en predicción de señales.

9. Cree el siguiente archivo de guión y compruebe la aplicación.
% EJEMPLO ADALINE6: CAPA LINEAL ADAPTATIVA
% Parte V de la guía del estudiante Redes Neuronales
%
% Usando una capa lineal, se logra adaptarla de modo que
% dada una señal se pueda predecir una segunda señal.
help adaline6
% DEFINICIÓN DEL PROBLEMA
%========================
% Definición del tiempo de esta simulacion.
tiempo = 1:0.01:2.5;
% Definición de la señal en el interva de tiempo.
X = sin(sin(tiempo).*tiempo*10);
P = con2seq(X);
% T es una señal derivada de P la cual se desplaza a laizquierda
% se multiplica por 2 y se suma a ella misma.
T = con2seq(2*[0 X(1:(end-1))] + X);
% GRAFICA DE LAS DOS SEÑALES
plot(tiempo,cat(2,P{:}),tiempo,cat(2,T{:}),'--')
title('Señales de Entrada y Salida')
xlabel('Tiempo')
ylabel('Entrada \_\_\_ Salida \_ \_')
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=[-3 3]; %rango del elemento de entrada.
% La red lineal debe tener un retraso de modo que aprenda
la correlacion entre P y T.
ID=[0 1]; %Vector de ningun retraso en una entrada y un
retraso en la otra entrada.
max_razon_aprendizaje = 0.1;
red = newlin(PR,S,ID,max_razon_aprendizaje);
% ENTRENAMIENTO DE LA RED
%========================
% Se filtra la señal adaptativamente.
% En t = 2 la red ha aprendido la relacion entre la entrada
% y la salida deseada y el error cae cerca de cero.
plot(tiempo,cat(2,T{:}),'r');
hold on;
plot([1 2.5],[0 0],'k');
title('Señales de Salida, Salida Deseada y Error');
xlabel('Tiempo'); ylabel('Salida-azul Deseada-rojaError-verde');
YN=0; EN=0; TiempoN=tiempo(1);
for i=2:length(P);
TiempoO=TiempoN;
TiempoN=tiempo(i);
YO=YN;
EO=EN;
[red,Y,E,Pf]=adapt(red,P{i},T{i});
YN=Y(1);
EN=E(1);
plot([TiempoO TiempoN],[YO YN],'b',[TiempoO
TiempoN],[EO EN],'g');
drawnow;
end;
hold off;
% PARÁMETROS DE LA RED
W = red.IW{1,1};
B = red.b{1};
% RESUMEN DE RESULTADOS
%======================
fprintf('\nVALORES DE LA RED ENTRENADA:\n')
W
B

VI. CONCLUSIONES

VII. BIBLIOGRAFIA

 Redes Neuronales Artificiales. Fundamentos, modelos y aplicaciones, José Ramón Hilera González,
Víctor José Martínez Hernando. Biblioteca UDB.
 Redes neuronales. Algoritmos, aplicaciones y técnicas de programación. James A. Freeman, David M.
Skapura. Biblioteca UDB.