Académique Documents
Professionnel Documents
Culture Documents
Función de Forma 1:
activación
Forma 2:
bias
FUNCIONES DE ACTIVACIÓN:
1. LINEAL: 3. Logística:
% Función:
function [y] = linear(x); function [y] = logistic(x);
% Función de activación lineal % Función logística:
y=x; y=1./(1+exp(-x));
NO ES PARTE DE NO ES PARTE DE
MATLAB MATLAB
ylabel('tanh(x)')
Ejemplo: Evaluación de las funciones de activación en un vector de
valores:
x=[-5:0.1:5];
y3=tanh(x);
y1=linear(x); figure
plot(x,y1) plot(x,y3)
title('Funcion de activacion lineal') title('Hyperbolic Tangent Activation Function')
xlabel('x') xlabel('x')
ylabel('Linel(x)') ylabel('tanh(x)')
y2=logistic(x);
figure y4=hardlim(x);
plot(x,y2) figure
title('Logistic Activation Function') plot(x,y4);
xlabel('x'); title('Thresh Activation Function')
ylabel('logistic(x)') xlabel('x');
ylabel('thresh(x)')
Ejemplo: Encuentre la salida de la neurona para x = [2 4 6], pesos
w = [0.5 0.25 0.33] y bias = -0.8. Utilice los dos esquemas
Esquema 1:
Función de
activación
Resolución:
x=[2 4 6]';
w=[0.5 -0.25 0.33];
b=-0.8;
y=tanh(w*x+b)
%y=
% 0.8275
Esquema 2:
Resolución:
x=[1 2 4 6]';
b=-0.8;
w=[b 0.5 -0.25 0.33];
y=tanh(w*x)
%y=
% 0.8275
UNA CAPA DE VARIAS NEURONAS:
Forma 1:
Forma 2:
EJEMPLO: OBTENER LAS SALIDAS CON LOS DOS MÉTODOS
Pesos: W11= 0.5; W12= -0.25; W13= 0.33
W21= 0.2; W22= -0.75; W23= -0.25
Entradas: x1= 2; x2= 4; x3= 6
Bias: b1= 0.4; b2= -1.2; Función: Tanh
Forma 1:
Forma 2:
RESOLUCIÓN:
Forma 1: Forma 2:
W1 =
W2=
b1 =
b2 =
Resolución: forma 1
Implementación en matlab:
x=[2 4 6]';
w1=[0.2 -0.7 0.9; 2.3 1.4 -2.1; 10.2 -10.2 0.3];
w2=[0.5 -0.25 0.33; 0.2 -0.75 -0.5];
b1=[0.5 0.2 -0.8]';
b2=[0.4 -1.2]';
y=w2*tanh(w1*x+b1)+b2
%y=
% 0.8130
% 0.2314
Resolución: forma 2
Implementación en matlab:
x=[2 4 6]';
w1=[0.5 0.2 -0.7 0.9; 0.2 2.3 1.4 -2.1; -0.8 10.2 -10.2 0.3];
w2=[0.4 0.5 -0.25 0.33; -1.2 0.2 -0.75 -0.5];
y=w2*[1;tanh(w1*[1;x])]
%y=
% 0.8130
% 0.2314
EL PERCEPTRÓN DE ROSENBLAT:
MODELO + ALGORTIMO DE APRENDIZAJE
x=[-5:0.1:5];y=hardlim(x);
plot(x,y);title('Thresh Activation Function')
xlabel('x');ylabel('thresh(x)')
• Salida: solo 1 ó 0.
• Solo puede clasificar patrones linealmente
Solución: convergió al segundo ciclo: W11= 1.3; W12= -2.3; b = 0.2 (COMPROBAR)
Resolución del ejemplo 1:
x = [1 -3]';
b = [-0.8];
w = [.3 0.7];
t = [1];
y=hardlim(w*x+b)
%y= 0
% w = 1.3000 -2.3000
% b = 0.2000
y=hardlim(w*x+b)
%y= 1 % ya convergió
EJEMPLO 2:
x = [0 1; 1 -1] %x= 0 1
t=[0 1]; % 1 -1
w=[-0.1 .8]; b=[-.5];
y=hardlim(w*x+b) %y= 1 0
[inputs,patterns]=size(x);
[r,c]=size(x);
for i=1:patterns
ALGORITMO DE
if y(i)==t(i) % No change w=w; b=b; APRENDIZAJE DE
elseif y(i)==0 % Target = 1 HEBB
ENTRENAMIENTO
w = w+x(:,i)'
b = b+1
CICLOS DE
plot(x(1,:),x(2,:),'*')
axis([-1.5 1.5 -1.5 1.5]);hold on
X=[-1.5:.5:1.5];
Y=(-b-w(1)*X)./w(2);
plot(X,Y);hold;
title('Original Perceptron Decision Boundary')
y=hardlim(w*x+b)
[r,c]=size(x);
for i=1:patterns
if y(i)==t(i) % No change w=w;
b=b;
No se ve cómo va cambiando
elseif y(i)==0 % Target = 1 la ubicación de la recta de
w = w+x(:,i)'
b = b+1 clasificación. Para verlo,
else % y=1 target=0.
w = w-x(:,i)' cambiemos las entradas:
b = b-1
end
end
x = [0 1; 0 -1]
Para ver cómo va cambiando la ubicación de la recta de
clasificación. Use las entradas siguientes:
x = [0 1; 0 -1]
Resolución:
x = [0 1; 0 -1]
t=[0 1];
w=[-0.1 .8]; b=[-.5];
plot(x(1,:),x(2,:),'*')
axis([-1.5 1.5 -1.5 1.5]);hold on
X=[-1.5:.5:1.5];
Y=(-b-w(1)*X)./w(2);
plot(X,Y);hold;
title('Original Perceptron Decision Boundary')
y=hardlim(w*x+b) % y = 0 0
[r,c]=size(x);
for i=1:patterns
if y(i)==t(i) % No change w=w;
b=b;
for i=1:patterns
if y(i)==t(i) % No change w=w;
b=b;
y=hardlim(w*x+b) % y = 0 1 % ya convergió
plot(x(1,:),x(2,:),'*')
axis([-1.5 1.5 -1.5 1.5])
hold on
X=[-1.5:.5:1.5]; Y=(-b-w(1)*X)./w(2);
plot(X,Y)
hold
title('Perceptron Decision Boundary After Two Epochs')
Resumen de evolución de pesos y salidas:
x= 0 1
0 -1
Current plot released
y= 0 0
w = 0.9000 -0.2000
b = 0.5000
y= 1 1
w = 0.9000 -0.2000
b = -0.5000
y= 0 1
YA CONVERGIÓ
if j==20
fprintf('No solution found.\n')
else
fprintf('Solution found in %i epochs.\n',j)
end
RESULTADOS:
y= 0 0 1 0
y= 1 1 1 1
y= 0 0 0 0
y= 1 0 1 1
y= 0 0 1 1
y= 0 0 1 1 % YA CONVERGIÓ
plot(x(1,1:2),x(2,1:2),'*');hold on
plot(x(1,3:4),x(2,3:4),'+');hold on
axis([-1.5 1.5 -1.5 1.5]);hold on
X=[-1.5:.5:1.5];
Y=(-b-w(1)*X)./w(2);
plot(X,Y);hold;
title('Original Perceptron Decision Boundary')
for j=1:20
y=hardlim(w*x+b)
if all(t==y) break, end % Training complete.
w=w+(t-y)*x';
b=b+(t-y)*ones(length(x),1);
figure
plot(x(1,1:2),x(2,1:2),'*');hold on
plot(x(1,3:4),x(2,3:4),'+');hold on
axis([-1.5 1.5 -1.5 1.5]);hold on
X=[-1.5:.5:1.5];
Y=(-b-w(1)*X)./w(2);
plot(X,Y);hold;
title('Evolution Perceptron Decision Boundary')
end
if j==20
fprintf('No solution found.\n')
else
fprintf('Solution found in %i epochs.\n',j)
end
y=hardlim(w*x+b)
x = [0 -0.3 -0.4 0.3 0.2 0.3 0.4 0.2 0.3 0.8; -0.4 -0.2 1.3 -1.3 0.1 0.5 0.3 0.5 .2 0.4 ]
w=[-0.1 .8]; b=[-.5];
t=[0 0 0 0 0 1 1 1 1 1]; % SALIDAS DESEADAS
plot(x(1,1:5),x(2,1:5),'*');hold on
plot(x(1,5:10),x(2,5:10),'+');hold on
axis([-1.5 1.5 -1.5 1.5]);hold on
X=[-1.5:.5:1.5];
Y=(-b-w(1)*X)./w(2);
plot(X,Y);hold;
title('Original Perceptron Decision Boundary')
for j=1:30
y=hardlim(w*x+b)
if all(t==y) break, end % Training complete.
w=w+(t-y)*x';
b=b+(t-y)*ones(length(x),1);
end
if j==20
fprintf('No solution found.\n')
else
fprintf('Solution found in %i epochs.\n',j)
figure
plot(x(1,1:5),x(2,1:5),'*');hold on
plot(x(1,5:10),x(2,5:10),'+');hold on
axis([-1.5 1.5 -1.5 1.5]);hold on
X=[-1.5:.5:1.5];
Y=(-b-w(1)*X)./w(2);
plot(X,Y);hold;
title('FINAL Perceptron Decision Boundary')
end
y=hardlim(w*x+b)
DEBER 2:
plot(x(1,1),x(2,1),'*') t
hold on y = hardlim([w b]*[x ;ones(1,c)])
plot(x(1,2),x(2,2),'+')
plot(x(1,3:4),x(2,3:4),'o')
axis([-1.5 1.5 -1.5 1.5]) figure
X1=[-1.5:.5:1.5]; Y1=(-b(1)-w(1,1)*X1)./w(1,2); plot(x(1,1),x(2,1),'*')
plot(X1,Y1) hold on
X2=[-1.5:.5:1.5]; Y2=(-b(2)-w(2,1)*X2)./w(2,2);
plot(X2,Y2) plot(x(1,2),x(2,2),'+')
hold plot(x(1,3:4),x(2,3:4),'o')
title('Inicial Perceptron Decision Boundaries') axis([-1.5 1.5 -1.5 1.5])
for j=1:20 X1=[-1.5:.5:1.5]; Y1=(-b(1)-
[r,c]=size(x); w(1,1)*X1)./w(1,2);
y = hardlim([w b]*[x ;ones(1,c)]) plot(X1,Y1)
X2=[-1.5:.5:1.5]; Y2=(-b(2)-
if all(t==y) break, end % Training complete. w(2,1)*X2)./w(2,2);
w=w+(t-y)*x'; plot(X2,Y2)
b=b+(t-y)*ones(length(x),1);
hold
end
title('Perceptron Decision Boundaries')
text(-1,.5,'Clase1'); text(-.3,.5,'Clase2');
text(.5,.5,'Clase3');
Resultados::
t= 0 0 1 1
0 1 0 0
w = -0.1000 0.8000
0.2000 -0.9000
b = -0.5000
0.3000
y= 0 0 1 0
1 1 0 1
y= 1 1 1 1
0 0 0 0
y= 0 0 0 0
0 0 0 0
y= 1 0 1 1
1 1 1 0
y= 0 0 1 1
0 0 0 0
y= 0 0 1 1
0 1 0 0
Solution found in 6 epochs.
t= 0 0 1 1
0 1 0 0
y= 0 0 1 1
0 1 0 0
Por las características anteriormente mencionadas, podemos Lo que buscamos es saber cómo varía el error
considerar una sola neurona de salida y realizar el análisis con las variaciones de los pesos de las entradas,
como si estuviese aislada. Esto se puede apreciar en el o lo que es lo mismo:
siguiente gráfico que usaremos como guía:
% Ejemplo:
x=[-5:.1:5];
y=1./(1+exp(-x));
dy=y.*(1-y);
subplot(2,1,1)
plot(x,y)
title('Logistic Function')
subplot(2,1,2)
plot(x,dy)
title('Derivative of Logistic Function')
Ejercicio: encontrar la salida con todas las funciones de activación logisticas
Forma 1:
Forma 2: donde
Ejercicio: particularice para los siguientes datos:
x = [0.4;0.7];
w1 = [0.1 -0.2; 0.4 0.2];
w2 = [0.2 -0.5];
b1=[-0.5;-0.2];
b2=[-0.6];
X = [1;x]
W1 = [b1 w1]
W2 = [b2 w2]
output=logistic(W2*[1;logistic(W1*X)])
X=
1.0000
0.4000
0.7000
W1 =
-0.5000 0.1000 -0.2000
-0.2000 0.4000 0.2000
W2 =
-0.6000 0.2000 -0.5000
output =
0.3118
Ajuste de los pesos de salida:
X = [1;x]
W1 = [b1 w1]
W2 = [b2 w2]
output=logistic(W2*[1;logistic(W1*X)])
output=logistic(W2*[1;logistic(W1*X)])
% Out_err = -0.1983
% Vemos que para una iteración de entrenamiento,el error se redujo de 0.2118 a 0.1983.
Ajuste de pesos de la capa oculta: similar a lo anterior
Para comenzar a entender en qué consiste el problema que nos ocupa vamos a estudiar la
dependencia del error de salida de una neurona de una capa de los pesos de la capa anterior.
Y por tanto:
[numout,numhid]=size(W2)
new_W1 = W1+2*lr*output.*(1-output).*Out_err.*h.*(1-h).*W2(:,2:numhid)'*X'
% new_W1 = -0.5021 0.0992 -0.2015
% -0.1943 0.4023 0.2040
output = logistic(new_W2*[1;logistic(new_W1*X)])
% output = 0.2980
%
% La nueva salida es 0.298 la cual está más cerca a la salida deseada 0.1 (al inicio fue de 0.3118.
% La tasa de aprendizaje afecta a la rapidez y estabilidad del aprendizaje.
% Lo veremos después.
ENTRENEMIENTO POR LOTES: Evitan una posible caída en un mínimo local.
x = [0.4 0.8 1.3 -1.3;0.7 0.9 1.8 -0.9]; % La nueva suma del error cuadrático es:
t = [0.1 0.3 0.6 0.2];
lr = 0.5; e = t- logistic(new_W2*H);
[inputs,patterns] = size(x); SSE = sum(sum(e.^2))
[outputs,patterns] = size(t); % SSE = 0.1926
W1 = [0.1 -0.2 0.1; 0.4 0.2 0.9];
% Se ha reducido de 0.2963 a 0.1926 solo al cambiar los pesos de
W2 = [0.2 -0.5 0.1]; salida.
%e= -0.4035 -0.2065 0.0904 -0.2876 % delta1 = 0.0126 0.0065 -0.0028 0.0088
% -0.0019 -0.0008 0.0002 -0.0016
% La suma del error cuadrático es:
SSE = sum(sum(e.^2)) % Ahora calculamos el cambio en los pesos de la capa oculta:
del_W1 = 2*lr*delta1*X'
% SSE = 0.2963 new_W1 = W1+del_W1
lr=lr*1.1
lr=lr*0.5
%Objetivo del Error alcanzado en 116 ciclos. Vemos que no hay ninguna relación
Escalando valores de entrada:
if nargin == 1
%cálculo de la pendiente y el punto de corte:
del = max(x)-min(x);
slope = .8./del;
int = .1 - slope.*min(x);
end
if nargin == 1
stdval = std(y); % calculamos la desviación estándar
end
y = y ./ (ones(nrows,1)*stdval); % normalización
Ejemplo de escalado de los valores de entrada:
W1=0.5*randn(2,3)
W1 =
0.5825 0.0375 -0.3483
0.3134 0.1758 0.8481
Creación de una función en matlab:
Crearemos una función que tenga como argumentos de entrada:
Con estos parámetros, la MLP será entrenada y como resultado tendremos los pesos, biases
y los parámetros de escalado almacenados en el archivo weights.mat.
Función logistica: limita las salidas de las neuronas entre (0 , 1 ) (para la capa oculta)
Función lineal: permiten cualquier magnitud de salida (para la capa de salida)
%% PROGRAMA BPTRAIN:
%% Este PROGRAMA tiene una MLP con algoritmo de aprendizaje de retro-propagación entrenado en lote
%% Esta MLP tiene en la capa oculta neuronas con funciones de activación
%% logísticas y una capa de salida con funciones de activación lineales.
%% x: son las entradas
%% t: son las salidas deseadas (target outputs)
%% size(x) = (patterns,inputs)
%% size(t) = (patterns,outputs)
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
x=[0:1:10]; % Conjunto de entrenamiento
t=2*x - 0.21*x.^2; % SALIDAS DESEADAS
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
hidden = input('Cuántas neuronas desea en la capa oculta? ');
sc = input('Ingrese el método de escalado: zscore=z, linear=l, none=n ?[z,l,n]:','s');
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Parametros por defecto:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Permitir al usuario cambiar los parámetros por defecto:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
if choice == 'n'
RMS_Goal = input('Tolerancia en el error de salida (RMS): ');
maxcycles = input('Máximo número de ciclos de entrenamiento: ');
lr = input('La tasa inicial de aprendizaje: ');
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Extrayendo dimensiones de los datos de entrada:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
[inputs,patterns1]=size(x);
[outputs,patterns]=size(t);
if patterns1 ~= patterns
error('El número de elementos de entrada tieneque ser el mismo que el de salidas deseadas.')
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Escalado de las entradas:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
if sc == 'z'
[xn, xm, xs] = zscore(x);
elseif sc == 'l'
[xn, xm, xs] = scale(x);
else
xn=x;
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Inicialización de pesos a pequeños números randómicos:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Entrenamiento de la red usando el algoritmo de backpropagation:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Gráfica de la evolución del error en el entrenamiento:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
subplot(2,1,1);
semilogy(RMS);
title('Resultados en el entrenamiento por retro-propagación');
ylabel('Error RMS')
subplot(2,1,2);
plot(LR)
ylabel('Tasa de aprendizaje')
xlabel('Ciclos');
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Criterio de tolerancia no encontrado:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
cycles=length(RMS);
if cycles == maxcycles
fprintf('\n\n*** Entrenamiento BP completo, error no conseguido!')
fprintf('\n*** RMS = %e \n\n',min(RMS))
else
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Criterio de tolerancia encontrado:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
[inputs,patterns1]=size(x);
[outputs,patterns]=size(t);
[hidden,inputs1]=size(W1);
[outputs1,hidden1]=size(W2);
if outputs1 ~= outputs
error('W1 no encajan con el vector de salidas deseadas.')
end
if inputs1 ~= inputs+1
error(' W2 does no encajan con el vector de entrada.')
end
if hidden1 ~= hidden+1
error('W1 y W2 no coinciden.')
end
terms=outputs*patterns;
RMS=zeros(1,maxcycles);
LR=zeros(1,maxcycles);
X=[ones(1,patterns); x];
h=logistic(W1*X); % salida de la capa oculta
H=[ones(1,patterns);h];
output = linear(W2*H); % vector de salida
e = t-output; % error de salida
RMS(1) = sqrt(sum(sum(e.^2))/terms); % error RMS.
fprintf('Epoca = 1, lr = %f, RMS Error = %f\n',lr,RMS(1))
for i=2:maxcycles
delta2 = e;
del_W2 = lr*delta2*H';
delta1 = h.*(1-h).*(W2(:,2:hidden+1)'*delta2);
del_W1 = lr*delta1*X';
new_W1 = W1+del_W1; % Actualización de pesos de la capa oculta
new_W2 = W2+del_W2; % Actualización de pesos de la capa de salida.
new_h = logistic(new_W1*X);
new_H = [ones(1,patterns);new_h]; % Salida de la capa oculta
new_output = linear(new_W2*new_H); % vector de salida
new_e = t-new_output; % Error de salida
RMS(i) = sqrt(sum(sum(new_e.^2))/terms);% error RMS.
RMS=nonzeros(RMS);
LR=nonzeros(LR);
Hay 11 pares de entradas/salidas.
Ejemplo 1 de utilización:
Epoca = 1, lr = 0.100000, RMS Error = 2.643514
Epoca = 50, lr = 0.094125, RMS Error = 1.860973
Considere que los datos de un experimento son
Epoca = 100, lr = 0.097455, RMS Error = 1.836764
generados por la función:
Epoca = 150, lr = 0.100902, RMS Error = 1.766102
Epoca = 200, lr = 0.104472, RMS Error = 1.647973
Y = 2 x1 + 0.2 x12
Epoca = 250, lr = 0.108168, RMS Error = 1.494268
Epoca = 300, lr = 0.111994, RMS Error = 1.110747
Epoca = 350, lr = 0.052707, RMS Error = 0.617961
Epoca = 400, lr = 0.054572, RMS Error = 0.350254
Corremos el programa: Epoca = 450, lr = 0.056503, RMS Error = 0.246746
Epoca = 500, lr = 0.058501, RMS Error = 0.194099
Epoca = 550, lr = 0.060571, RMS Error = 0.160784
Cuántas neuronas desea en la capa oculta? 2 Epoca = 600, lr = 0.062714, RMS Error = 0.137435
Ingrese el método de escalado: zscore=z, linear=l, none=n ?[z,l,n]:l Epoca = 650, lr = 0.064932, RMS Error = 0.120749
Epoca = 700, lr = 0.067229, RMS Error = 0.108296
Los parámetros por defecto son:
*** Entrenamiento BP completado en 744 epocas!
Tolerancia en el error de salida (RMS) = .1 ***
Máximo número de ciclos de entrenamiento= 5000. *** RMS = 9.996243e-002
La tasa inicial de aprendizaje es = 0.1.
Está satisfecho con estos parámetros? [y,n]:y
Evolución de la tasa
de aprendizaje.
Pesos ya entrenados
Uso de la MLP ya entrenada para clasificar nuevas entradas a la red (conjunto de test):
Una vez que la red ha sido ya entrenada con el conjunto de en entrenamiento (que debe ser o
abarcar el rango de entradas lo más amplio posible), lo deseable es que esta nos entregue las
salidas correspondientes a nuevas entradas totalmente extrañas a la red.
La MLP es muy buena para interpolar resultados: es decir que acierta con mucha exactitud en
los resultados que están en el rango de los datos de entrenemiento.
La MLP es muy mala extrapoladora: fuera del rango de entrenamiento, dará muy malos
resultados.
Veamos en el ejemplo anterior:
El conjunto de entrenemiento fuero los puntos: x = [ 0: 1 : 10 ]
Veamos ahora el resultado de la MLP para los puntos x = [ 0: 0.1 : 10 ]
En nuevo archivo:
En este ejemplo, se entrena una MLP para reconocer las primeros 16 letras (A a la
P) del alfabeto. Estas están definidas en arreglos 5x7 los cuales están almacenados
en un vector de 35 elementos (barrido de arriba hacia abajo y de izquierda a
derecha):
A a la P representadas como vectores de 7x5 = 35 elementos:
X =
t representa las salidas deseadas (16 posibles letras):
t =
Particularización de la función de aprendizaje:
for i=1:maxcycles
h=logistic(W1*X);
function W1,W2,RMS]=bprop2(x,t,W1,W2,RMS_Goal,lr,maxcycles)
H=[ones(1,patterns);h]; % Hiden layer output
[inputs,patterns1]=size(x);
output = logistic(W2*H); % Output Vector
[outputs,patterns]=size(t);
[hidden,inputs1]=size(W1);
e = t-output; % Output Error
[outputs1,hidden1]=size(W2);
RMS(i) = sqrt(sum(sum(e.^2))/terms);% Root mean squared error.
if outputs1 ~= outputs
if RMS(i)<RMS_Goal; break;end
error('Weight dimension of W1 does not match the target vector.')
end
if RMS(i)<=RMS(max((i-1),1)) lr=lr*1.1; % Adaptive learning rate
else lr=lr*.1;
if inputs1 ~= inputs+1
end
error('Weight dimension of W2 does not match the input vector.')
end
delta2= output.*(1-output).*e;
del_W2= 2*lr* delta2*H';
if hidden1 ~= hidden+1
delta1 = h.*(1-h).*(W2(:,2:hidden+1)'*delta2);
error('Weight dimension of W1 and W2 does not coincide.')
del_W1 = 2*lr*delta1*X';
end
W1 = W1+del_W1; % Hidden layer weight update.
W2 = W2+del_W2; % Output layer weight update
terms=outputs*patterns;
RMS=zeros(1,maxcycles);
end
X=[ones(1,patterns); x];
RMS=nonzeros(RMS);
save pesos_1 W1 W2
Particularización de la función de aprendizaje:
load letters
W1=0.5*randn(10,36); % Initialize output layer weight matrix.
W2=0.5*randn(4,11); % Initialize hidden layer weight matrix.
[W1 W2 RMS]=bprop2_curso(x,t,W1,W2,.05,.1,5000);
semilogy(RMS);
title('Backpropagation Training');
xlabel('Cycles');
ylabel('Root Mean Squared Error')
Convergencia: la
MLP ya aprendió!
Verificación con las letras entrenadas:
load pesos_l;
output0 = logistic(W2*[1;logistic(W1*[1;x(:,1)])])'
output1 = logistic(W2*[1;logistic(W1*[1;x(:,2)])])'
output7 = logistic(W2*[1;logistic(W1*[1;x(:,8)])])'
output12 = logistic(W2*[1;logistic(W1*[1;x(:,13)])])'
% output0 =
% 0.0188 0.0595 0.0054 0.0443 % ES LA “A”
% output1 =
% 0.0239 0.0433 0.0607 0.9812 % ES LA “B”
% output7 =
% 0.0590 0.9872 0.9620 0.9536 % ES LA “H”
% output12 =
% 0.9775 0.9619 0.0531 0.0555 % ES LA “M”
Ahora usamos la MLP ya entrenada para clasificar nuevas entradas que lleguen, por
ejemplo:
a=[0 0 1 0 0 0 0 0 1 0 1 0 0 0 1 1 1 1 1 1 1 0 0 0 1 1 0 0 0 1 1 0 0 1 1]';
Uso de la red para clasificar la nueva entrada con los pesos ya entrenados:
OutputA = logistic(W2*[1;logistic(W1*[1;a])])'
% OutputA =
% 0.0165 0.1135 0.0297 0.0161 ---- % Se acerca a la “A”
Ejemplo 3: clasificación de las vocales
MÉTODOS:
a) Usando modelo AR y distancia euclideana.
b) Usando una MLP teniendo como entradas los coeficientes AR
Vocal o Vocal u
Método AR
clc, clear all; d(3)=((vocal(1)-i(1))^2+((vocal(2)-i(2))^2)+((vocal(3)-
load a;load e; load i;load o;load u;
u; i(3))^2)+((vocal(4)-i(4))^2)+((vocal(5)-i(5))^2)+
ai = analoginput('winsound'); % Entrada analógica (vocal(6)-i(6))^2+(vocal(7)-i(7))^2+(vocal(8)-
i(8))^2+(vocal(9)-i(9))^2+(vocal(10)-i(10))^2+
duration = 1; (vocal(11)-i(11))^2)^(0.5);
Fs=8000; d(4)=((vocal(1)-o(1))^2+((vocal(2)-o(2))^2)+((vocal(3)-
addchannel(ai, 1); o(3))^2)+((vocal(4)-o(4))^2)+((vocal(5)-o(5))^2)+
set(ai, 'SamplesPerTrigger', duration*Fs); (vocal(6)-o(6))^2+(vocal(7)-o(7))^2+(vocal(8)-
o(8))^2+(vocal(9)-o(9))^2+(vocal(10)-o(10))^2+
set(ai, 'SampleRate',Fs); (vocal(11)-o(11))^2)^(0.5);
start(ai); d(5)=((vocal(1)-u(1))^2+((vocal(2)-u(2))^2)+((vocal(3)-
disp('Hable ahora...') u(3))^2)+((vocal(4)-u(4))^2)+((vocal(5)-u(5))^2)+
nueva = getdata(ai); (vocal(6)-u(6))^2+(vocal(7)-u(7))^2+(vocal(8)-
while strcmp(ai.Running,'On'); u(8))^2+(vocal(9)-u(9))^2+(vocal(10)-u(10))^2+
(vocal(11)-u(11))^2)^(0.5);
end
for i=1:5
V=nueva';
D(i)=abs(d(i));
vocal=lpc(V,10);
end
minima=min(D)
if minima==D(1)
d(1)=((vocal(1)-a(1))^2+((vocal(2)-a(2))^2)+((vocal(3)-
a(3))^2)+((vocal(4)-a(4))^2)+((vocal(5)-a(5))^2)+ disp('usted dijo a')
(vocal(6)-a(6))^2+(vocal(7)-a(7))^2+(vocal(8)- elseif minima==D(2)
a(8))^2+(vocal(9)-a(9))^2+(vocal(10)-a(10))^2+ disp('usted dijo e')
(vocal(11)-a(11))^2)^(0.5); elseif minima==D(3)
d(2)=((vocal(1)-e(1))^2+((vocal(2)-e(2))^2)+((vocal(3)- disp('usted dijo i')
e(3))^2)+((vocal(4)-e(4))^2)+((vocal(5)-e(5))^2)+
(vocal(6)-e(6))^2+(vocal(7)-e(7))^2+(vocal(8)- elseif minima==D(4)
e(8))^2+(vocal(9)-e(9))^2+(vocal(10)-e(10))^2+ disp('usted dijo o')
(vocal(11)-e(11))^2)^(0.5); else minima==D(5)
disp('usted dijo u')
end
Ejemplo (Coeficientes AR):
Vocal dicha
DEBER: REALIZAR LA CLASIFICACIÓN:
b) Usando una MLP teniendo como entradas los
coeficientes AR.
PROBABILISTIC
NEURAL
NETWORKS:
PROBABILISTIC NEURAL NETWORKS:
- Es un clasificador Bayesiano pero metido dentro de una red neuronal.
- Sería una alternativa los sistemas difusos pues tiene una base teórica muy firme y
sólida.
- Una de sus aplicaciones es: “CLASIFICADOR DEL VECINO MÁS CERCANO”
Se desea clasificar el círculo según su grado de pertenencia a cada uno de los dos
conjuntos.
ctr=1;
for i=1:classes % For each classification.
d_sum=0; % Running sum of distances.
for j=1:cases(i) % For each case in a classification.
d_sum=dist(xtest,x(ctr,:))/a_sqr+d_sum; % Calculate each distance.
ctr=ctr+1; % Next case.
end
w_dist(i)=exp(-d_sum); % Exponential weighting.
end
PROBABILISTIC NEURAL NETWORKS:
Resolución:
% class = 2
% prob = 0.1025 0.3114
PROBABILISTIC NEURAL NETWORKS:
function [y]=gaussian(x,w,a)
[patterns,inputs]=size(x);
[inputs1,neurons]=size(w);
if inputs1 ~= inputs
error('Weight dimension does
not match the input vector.')
end
y=zeros(patterns,neurons);
for i=1:patterns
for j=1:neurons
d=norm(x(i)-w(:,j));
y(i,j)=exp(-(d.*d)/(a.^2));
end
end
Ejemplo de aproximación de funciones:
Resolución: fichero demo_rbf
x=[-10:1:10]';
y=.05*x.^3-.2*x.^2-3*x+20;
plot(x,y);
xlabel('Input');
ylabel('Output');
title('Funcion a ser aproximada')
% Capas ocultas.
a1=gaussian(x,w1,width);
% Pseudo inversa .
w2=inv(a1'*a1)*a1'*y;
% Test inputs.
test_x=[-15:.2:15]';
% Test outputs.
y_target=.05*test_x.^3-.2*test_x.^2-3*test_x+20;
% Salidas de la red.
yout=test_a1*w2;
figure
plot(test_x,[y_target yout]);
title('Red RBF: probando'); xlabel('Input'); ylabel('Output')
PROXIMA CLASE:
- REDES NEURONALES COMPETITIVAS
- MAPAS AUTOORGANIZATIVOS