INFORME N 01

EL PERCEPTRON
1. OBJETIVOS
Conocer el funcionamiento del preceptron simple
Identificar los parmetros que intervinieren en este
Conocer las funciones propias del MATLAB para el entrenamiento de la neuronas
2. MATERIALES
o
o

Software MATLAB
Gua de Laboratorio

3. FUNDAMENTO TEORICO
3.1. CONCEPTO
Sistema capaz de realizar tareas de clasificacin de forma automtica. A partir de un nmero
de ejemplos etiquetados, el sistema determina la ecuacin del hiperplano discriminante

3.2. ARQUITECTURA
Red monocapa con una o ms neuronas de salida conectadas a todas las entradas
{

3.3. RNA de una capa

Una neurona aislada dispone de poca potencia de clculo. Los nodos se conectan mediante la
sinapsis, las neuronas se agrupan formando una estructura llamada capa.
Los pesos pasan a ser matrices W (n x m), la salida de la red es un vector: Y=(y1, y2, ... , yn)T
Y=F(WX+b)
a1
y1
a2
y2
an
yn

3.4. RNA Multicapa

Capas en cascada se encuentra de capas: Entrada, Salida, Oculta, para esta red neuronal no
hay realimentacin => red feedforward. La Salida depende de entradas y pesos. Si hay
realimentacin => red recurrente

4. DESARROLLO
El programa que se desarroll en el software es el siguiente
%EJEMPLO PERCEPTRON.CLASIFICACION

MULTINEURONA.

% Se entrena 1 capa De 2-entradas con 2 neuronas con funcin de

activacin
% escaln
%
con la regla
del
perceptrn
para
una
clasificacin
adecuada
% 10 vectores
de
entrada en
4 regiones.
help per2
clf reset
pausa = 1;
%
DEFINICIN
DEL
PROBLEMA
% Definicin
da
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 LOE 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 generada son.
PR = [-2 2 ; -2 2];
plotpv(P,T,V);
grid on;
figura=gcf ;
axis('equal')
title('Grfica 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);%dimencion de la matriz
red=newp(PR,S); %crea el perceptron
%inicializacion de pesos y umbral.
Z = menu('Inicalizar Pesos y Umbral A', ...
'Condiciones Iniciales 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
%
GRFICA
DE
LA
CLASIFICACIN
INICIAL
%======== = ===== = === = =, = ==:==== = = ===== =
hold on
linea=plotpc(red.IW{1,1},red.b{1}); %grafica la linea de clasificacio
de la neurona
%
ENTRENAMIENTO
DE
LA RED
%ENTRENAMIENTO DE
LOS
PARMETROS
disp_freq = 1;
max_epoch = 100;
%el entrenamieto 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)
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('Wl __ 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.')
set(gcf, 'nextplot','replace')
end

5. RESULTADOS
Los resultados que obtienen de la simulacin del programa son los siguientes:

Los datos son separados linealmente mediante rectas, la cantidad de iteraciones que se
desarroll fueron 20.
6. CONCLUSIONES
La clasificacin de datos se realiza linealmente, estos dependen de los valores de
entrada
Los pesos que se ingresan al inicio son los que determinan la eficiencia de la red
Si se aumenta la cantidad de iteraciones se pueden conseguir mejores resultados
7. RECOMENDACIONES
Probar con distintos valores para comprobar la separacin lineal
Modificar los pesos iniciales de la entrada y comparar con los datos obtenidos
anteriormente
Ingresar datos que no sean linealmente separables para comprobar la eficiencia de la
funcin

INFORME N 02
ADELINE
1. OBJETIVOS
Conocer el funcionamiento de la red ADELINE
Identificar los parmetros que intervinieren en este
Conocer las funciones propias del MATLAB para el entrenamiento de la neuronas
2. MATERIALES
o
o

Software MATLAB
Gua de Laboratorio

3. FUNDAMENTO TEORICO
3.1. CONCEPTO
Estructura prcticamente idntica al perceptron, pero es un mecanismo fsico capaz de realizar
aprendizaje. Elemento combinador adaptativo lineal, que recibe todas las entradas, las suma
ponderadamente, y produce una salida

El perceptrn realiza tareas de clasificacin salida binaria. Si las salidas fueran nmeros reales,
estaramos ante un problema de regresin
Aproximar una funcin cualquiera F(x) definida por un conjunto de datos de entrada y su
salida real correspondiente, los ejemplos de entrenamiento son conjuntos de valores: (vector
de entrada, salida real)

Habr que buscar la funcin

4. DESARROLLO
El programa que se desarroll en el software es el siguiente
%EJEMPLO ADALI1ME1: ASOCIACIN DE PATRONES
%Parte I de la guia del estudiante Redes Neuronales
%Una red, que consiste de i entradas alimentadas a una sola neurona
lineal, se entrena con la regla de aprendizaje de
%Windrow-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 proporcin a sus efectos sobre el error de la red hasta que se
%encuentra un punto de mnimo error.
help adaline1
clf reset
tiempopausa = 0.01;
% DEFINICIN DEL PROBLEMA
%========================
%
Definicin de los dos vectores de entrada de 1 elemento.
P = [+1.0 -1.2];
%
Definicin de los dos vectores deseados de 1 elemento.
T = [+0.5 +1.0];
% GRFICA 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'); % Calculo de la Superficie
de error
disp('Presione cualquier tecla para ver la superficie de error. '),
disp (''),pause
plotes(Wrango,Brango,SE); % plotea la superficie de error
figura=gcf; %devuelve el valor de la cifra actual

subplot(1,2,1)
title('Grfica de la Superficie de Error')
xlabel('Peso W');
ylabel('-Umbral B');
zlabel('Error Cuadrado Medio');
subplot(1,2,2)
title('Grfico de Contorno del Error')
xlabel('Peso W');
ylabel('umbral B');
pause
% INICIALCIZACIN 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); %dimension de la matriz
% DISEO 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);
% Inicializacin de pesos y umbral.
z = menu('Inicializar Pesos y Umbral a:', ...
'Condiciones Iniciales en la guia del estudiante', ...
'Marcar Valores con el Ratn/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
% GRAFICA DE CONTORNO DE ERROR, CONDICIONES INICIALES SOLUCION
DISEADA.
figure(figura)
subplot(1,2,2)
axis('equal')
if z == 2
title('SELECIONE W y B AQU')
[red.IW{1,1},red.b{1}] = ginput(1);
title('Grfico de Contorno del Error')
end
% FASE.DE PRESENTACIN:
A=sim(red,P);
E=T-A;
SSE=sumsqr(E);
punto=plotep(red.IW{1,1},red.b{1},SSE);
pause2(tiempopausa);
%
ENTRENAMIENTO
DE
LA
RED
%
ENTRENAMIENTO
DE
LOS
PARMETROS
presenta_frec = 1;
max_iteracion = 200;
meta_error = 0.000000000000000000000000000000000000000000000000000001;

red.trainParam.goal = meta_error;
LP.lr=max_razon_aprendizaje;
% NOTA: El resto del cdigo de entrenamiento puede reemplazarse
por:
%[red, tr]=train(red,P,T);
%iteracion = length(tr.epoch)-1;
%SSE = tr.perf(length(tr.perf));
% PARMETROS DE LA RED
W = red.IW{1,1};
B = red.b{1};
%
REGISTRO
DEL
ENTRENAMIENTO
errores = [SSE];
for iteracion=1:max_iteracion
%
FASE
DE
REVISIN:
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 PRESENTACIN
A=sim(red,P);
E=T-A;
SSE = sumsqr(E);
%
REGISTRO DEL ENTRENAMIENTO
errores = [errores SSE];

% PRESENTACIN DEL PROGRESO

if rem(iteracion,presenta_frec) == 0
punto=plotep(W,B,SSE,punto);
pause2(tiempopausa);
drawnow
end
end
red.IW{1,1} = W;
red.b{1} = B;
% GRFICA DE CLASIFICACIN FINAL
punto=plotep(W,B,SSE,punto);
pause
set(gcf,'NextPlot','replace')
% GRFICA 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;
%
GRFICA
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 cuadratico medio fue %g.\n',meta_error);
fprintf('Error cuadratico medio final de %g.\n',SSE);
fprintf('La red entrenada opera: ');
if SSE < meta_error
disp('Adecuadamente. ')
else
disp('Inadecuadamente. ')
end

5. RESULTADOS
Los resultados que obtienen de la simulacin del programa son los siguientes:

El calculo del error en la superficie misma es la que se muestra en la siguiente figura

El grafico discreto de error respecto a la salida deseada se muestra acontinuacion

6. CONCLUSIONES
La clasificacin de datos se estima mediante el error que se muestra a la salida del
sistema y de acuerdo a este se va acondicionando el error
Los pesos que se ingresan al inicio son los que determinan la eficiencia de la red
Si se aumenta la cantidad de iteraciones se pueden conseguir mejores resultados
7. RECOMENDACIONES
Probar con distintos valores de tolerancia muy bajos.
Modificar los pesos iniciales de la entrada y comparar con los datos obtenidos
anteriormente.

INFORME N 03
BACKPROPAGATION
8. OBJETIVOS
Conocer el funcionamiento de la red BACKPROPAGATION
Identificar los parmetros que intervinieren en este sisitema
Conocer las funciones propias del MATLAB para el entrenamiento de la neuronas
9. MATERIALES
o
o

Software MATLAB
Gua de Laboratorio

10. FUNDAMENTO TEORICO

3.1. CONCEPTO
Es la generalizacin del algoritmo de Widrow-Hoff para redes multicapa con funciones de
transferencia no-lineales y diferenciable. Una red neuronal con una capa de sigmoides es
capaz de aproximar cualquier funcin con un nmero finito de discontinuidades, propiedad de
la generalizacin. La funcin de transferencia es no-lineal, la superficie de error tiene varios
mnimos locales.

P
R

n f a
C
C
b
a
a
n f
W
Wa
Wa
b
p
p
a
n
a
f

3.2. ALGORITMO BACKPROPAGATION

Descripcin:
Tras inicializar los pesos de forma aleatoria y con valores pequeos, seleccionamos el
primer par de entrenamiento.
Calculamos la salida de la red
Calculamos la diferencia entre la salida real de la red y la salida deseada, con lo que
obtenemos el vector de error
Ajustamos los pesos de la red de forma que se minimice el error

 Repetimos los tres pasos anteriores para cada par de entrenamiento hasta que el error
para todos los conjuntos de entrenamiento sea aceptable.
Descenso por la superficie del error
Clculo de derivadas del error respecto de los pesos y de las bias.

4. DESARROLLO
El programa que se desarroll en el software es el siguiente
%
EJEMPLO
BCKPROl:
RED
CON
SUPERFICIE
DE
ERROR NO
LINEAL
%
una
re consistente de una entrada alimentada a una sola
%
neurona
sigmoidal-logaritmica, se entrena con backpropagation
'-"
para
resolver
un
problema
de
dos
patrones.
%
La
red
sigue
el
gradiente descendente sobre
.la superficie de error
%
cuando
la neurona ajusta sus pesos
de entrada y umbral
%
para hallar
un
error mnimo.
help
bckpro1
clf
reset
tiempopausa = 0.2;
% DEFINICIN DEL PROBLEMA
% Define dos vectores de entrada de 1-elemento.
P = [-3.0 +2.0];
%
Define los des vectores
deseados de
1-elemento.
T = [+0.4 +0.3];
%
GRFICO
DE
ALAMBRE
DEL
ERROR
%=================
fprintf('Calculando la superficie de error, por favor
espere...\n\n');
Wrango = -4:.4:4;
Brango = -4:.4:4;
SE = errsurf(P,T,Wrango,Brango,'logsig');
disp('Presione cualquier tecla para ver la superficie de error. '), disp
(''),pause
plotes(Wrango,Brango,SE);
figura=gcf;
subplot(1,2,1)
title('Grfica de la Superficie de Error')
xlabel('Peso W');
ylabel('-Umbral B');
zlabel('Error Cuadrado Medio');
subplot(1,2,2)
title('Grfico de Contorno del Error')
xlabel('Peso W');
ylabel('umbral B');
pause
% INICIALIZACIN DE LA ARQUITECTURA DE LA RED
%======================================
% Encuentra el tamao del vector de entrada R, tamao de la capa S,
tamao del lote Q.
[R,Q1] = size(P); [S,Q] = size(T);
red = newff(minmax(P),S,{'logsig'});
% Inicalizacin de pesos y umbral.

z = menu( 'Inicializar Pesos y Umbral a: ', ...

'Condiciones en la Guia del Estudiante', ...
'Colocar valores con el Ratn/Teclas de desplazamiento', ...
'Valores Aleatorios');
disp ('')
if z == 1
red.IW{1,1} = [-2.1617]; red.b{1} = [-1.7862];
elseif z == 3
red.inputweights{1,1}.initFcn = 'rands';
red.biases{1}.initFcn = 'rands';
red=init(red);
end
% GRFICA DE CONTORNO DEL ERROR, CONDICIONES INICIALES, SOLUCIN
DISEADA
figure(figura)
subplot(1,2,2)
axis ('equal')
if z == 2
title ( 'SELECIONE W y B AQU')
[red.IW{1,1},red.b{1}] = ginput(1);
title('Grfico de
Contorno del Error')
end
%FASE DE PRESENTACIN:
A=sim(red,P);
E=T-A;
SSE=sumsqr(E);
punto=plotep(red.IW{1,1},red.b{1},SSE);
pause2(tiempopausa);
% entrenamiento de la red
% parametros de entrenamiento
presenta_frec = 1;
max_iteracion = 100;
meta_error = 0.001;
razon_aprendiz = 1;
red.trainParam.show = presenta_frec;
red.trainParam.goal = meta_error;
red.trainParam.epochs = max_iteracion;
red.trainParam.Ir = razon_aprendiz;
lr = razon_aprendiz;
% NOTA: El resto del cdigo de entrenamiento puede reemplazarse
% por:
% [red, trl=train(red,P,T);
% PARMETROS DE LA RED
W = red.IW{1,1};
B = red.b{1};
%
REGISTRO
DEL
ENTRENAMIENTO
errores = [SSE];
for iteracion=1 :max_iteracion
%
FASE
DE
REVISIN
if SSE < meta_error,
iteracion=iteracion-1;
break,
end
%
FASE
DE
APRENDIZAJE
D = A.*(1-A).*E;
dW = D*P'*lr;
dB = D*ones(Q,1)*lr;
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;
SSE = sumsqr(E);
% REGISTRO DEL ENTRENAMIENTO
errores = [errores SSE];
% PRESENTACIN DEL PROGRESO
if rem(iteracion,presenta_frec)== 0
punto=plotep(W,B,SSE,punto);
pause2(tiempopausa);
drawnow
end
end
red.IW{1,1} = W;
red.b{1} = B;
% GRFICA DE CLASIFICACIN FINAL
punto=plotep(W,B,SSE,punto);
pause
set(gcf,'NextPlot','replace')
% GRFICA 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;
% GRFICA 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 cuadrtico medio
fue %g.\n',meta_error);
fprintf('Error cuadratico medio final de %g.\n',SSE);
fprintf('La red entrenada opera: ');
if SSE < meta_error
disp('Adecuadamente.')
else
disp('Inadecuadamente')
end

5. RESULTADOS
Los resultados que obtienen de la simulacin del programa son los siguientes:

El calculo del error en la superficie misma es la que se muestra en la siguiente figura

El grafico de la aproximaxion al error deseado en la funcion se muestra en la figura anterior

6. CONCLUSIONES
La clasificacin de datos se estima mediante el error que se muestra a la salida del
sistema y de acuerdo a este se va acondicionando el error
Los pesos que se ingresan al inicio son los que determinan la eficiencia de la red
Si se aumenta la cantidad de iteraciones se pueden conseguir mejores resultados
7. RECOMENDACIONES
Probar con distintos valores de tolerancia muy bajos.
Modificar los pesos iniciales de la entrada y comparar con los datos obtenidos
anteriormente.