1_7_EPN_CLASIFICACION_MLP

Prof. Ing. Alexeis Companioni

Seminario de técnicas para el procesamiento de datos

Herramienta de apoyo: MatLab

“Quien no se resuelve a cultivar el hábito de pensar, se pierde el mayor placer de la vida”

Thomas A. Edison

Ing. Robin Alvarez Rueda, PhD, MSc.

TÉCNICAS DE ANÁLISIS: REDES NEURONALES

REDES NEURONALES:

RESUMEN HISTÓRICO:

• 1943: McCulloch y Pitts: Primer modelo de una red neuronal

• 1949: D. Hebb: Algoritmo matemático de aprendizaje.

• 1958: Rosenblat: Une las dos anteriores (PERCEPTRON)

• 1969: Minsky y Papert: demuestran que no se puede resolver el

problema de clasificación del XOR.

• 1975-1980: Fukushima: nuevos modelos (cognitrón y neocognitrón)

• 1982: Kohonen: Mapas autoorganizativos.

• 1986: Rumelhart: resuelve el problema del XOR.

• 1988: Broomhead y Lowe: Redes neuronales de base radial.

CLASIFICIÓN SEGÚN EL ALGORTIMO DE APRENDIZAJE:

1. SUPERVISADO: se conocen valores experimentales de entradas y salidas y por tanto se puede entrenar a la red.

1.1 El perceptrón

1.2 El perceptrón multicapa

1.3 Redes de funciones de base radial

1.4 Memorias asociativas bidireccionales

2. NO SUPERVISADO: no se conocen valores experimentales.

2.1 Mapas auto-organizativos

2.2 Redes de Hopfield

2.3 Redes de respuesta al impulso infinito.

DOS ESQUEMAS MATEMÁTICOS DE UNA NEURONA:

bias

Función de activación

Forma 1:

Forma 2:

FUNCIONES DE ACTIVACIÓN:

1. LINEAL:

function [y] = linear(x);% Función de activación linealy=x;

NO ES PARTE DE MATLAB

2. TANGENTE HIPERBÓLICA:

x=[-3:0.1:3];y=tanh(x);plot(x,y)title('Hyperbolic Tangent Activation Function')xlabel('x')

ylabel('tanh(x)')

3. Logística:% Función:function [y] = logistic(x);% Función logística:y=1./(1+exp(-x));

NO ES PARTE DE MATLAB

4. Función paso unitario

% Función:

function [y] = hardlim (x);

y=(x>=0);

Ejemplo: Evaluación de las funciones de activación en un vector de valores:

Evaluar cada una de las funciones anteriores desde

-5 hasta 5 en pasos de 0.1.

x=[-5:0.1:5];

y1=linear(x);plot(x,y1)title('Funcion de activacion lineal')xlabel('x')ylabel('Linel(x)')

y2=logistic(x);figureplot(x,y2)title('Logistic Activation Function')xlabel('x');ylabel('logistic(x)')

y3=tanh(x);figureplot(x,y3)title('Hyperbolic Tangent Activation Function')xlabel('x')ylabel('tanh(x)')

y4=hardlim(x);figureplot(x,y4);title('Thresh Activation Function')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

Resolución:

x=[2 4 6]';w=[0.5 -0.25 0.33];b=-0.8;y=tanh(w*x+b)

% y =% 0.8275

Función de activación

Esquema 1:

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

Forma 1:

Forma 2:

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

RESOLUCIÓN:

Forma 1:

x=[2 4 6]';w=[0.5 -0.25 0.33; 0.2 -0.75 -0.5];b=[0.4 -1.2]';y=tanh(w*x+b)

% y =% 0.9830

% -1.0000

Forma 2:

x=[ 1 2 4 6]'; w=[0.4 0.5 -0.25 0.33; -1.2 0.2 -0.75 -0.5];y=tanh(w*x)

% y =% 0.9830

% -1.0000

RED MILTICAPA ( EJEMPLO: 3 CAPAS)

Ejemplo: encontrar la salida de la red con una capa oculta:

Encuentre la salida de la MLP de tres entradas y de una sola capa oculta con funciones de activación tangente hiperbólica y dos neuronas de salida con funciones de activación lineales.

X = [2 4 6];

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

SU FUNCIÓN DE ACTIVACIÓN ES LA FUNCIÓN PASO UNITARIO:

Función paso unitario

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

separables ( Minsky 1969 )

• Entrenamiento supervisado

REGLA DE APRENDIZAJE DE HEBB

EJEMPLO 1:

1) Se tiene un sistema (cuyo modelo matemático es muy difícil de conocer) que tiene 2 variables de entrada (x1 y x2) y una variable de salida (y). Experimentalmente se encuentra que si x1= 1 y x2= -3, la salida es y = 1. Suponer: w1=0.3, w2=0.7 y b= -0.8:

a) Plantear la red de perceptrones

b) Entrenar la red hasta que la salida sea la deseada

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

if y==t % No hay cambio w=w; b=b;

elseif y==0 % Pues Target = 1 w = w+x' b = b+1else % y=1 Pues target=0. w = w-x' b = b-1end

% w = 1.3000 -2.3000% b = 0.2000

y=hardlim(w*x+b)

% y = 1 % ya convergió

ALGORITMO DE APRENDIZAJE DE

HEBB

EJEMPLO 2:

Se tiene un sistema (cuyo modelo matemático es muy difícil de conocer)

que tiene 2 variables de entrada (x1 y x2) y una variable de salida (y).

Experimentalmente se encuentra que:

- Si x1= 0 y x2= 1, la salida es y = 0;

- Si x1= 1 y x2= -1, la salida es y = 1;

Suponer: w1=- 0.1, w2=0.8 y b= -0.5:


b) Entrenar la red hasta que la salida sea la deseada

c) Mostrar gráficamente la evolución del problema linealmente separable por medio de una recta de clasificación.

Resolución del ejemplo 2:

x = [0 1; 1 -1]t=[0 1];w=[-0.1 .8]; b=[-.5];

y=hardlim(w*x+b)

% Debo hacer Hebb para cada salida y(i):

[inputs,patterns]=size(x);

[r,c]=size(x);

for i=1:patterns if y(i)==t(i) % No change w=w; b=b;

elseif y(i)==0 % Target = 1 w = w+x(:,i)' b = b+1 else % y=1 target=0. w = w-x(:,i)' b = b-1 endend

y=hardlim(w*x+b)

ALGORITMO DE APRENDIZAJE DE

HEBB

% x = 0 1% 1 -1

% y = 1 0

% w = -0.1000 -0.2000% b = -1.5000% % w = 0.9000 -1.2000% b = -0.5000 % y = 0 1 % YA CONVERGIÓ

CIC

LO

S D

E

EN

TR

EN

AM

IEN

TO


Problemas linealmente separables:

Teorema de convergencia del perceptrón: “mientras las entradas sean linealmente separables, el perceptrón encontrará la frontera de decisión”.

La frontera de decisión es siempre ortogonal a la matriz de pesos. Entonces estará formada por pares de puntos que cumplen la siguiente condición:

w*x+b = 0

De aquí, se puede deducir la ecuación de la recta que divide los dos planos:

- Para tres dimensiones, la ecuación definirá un plano

- Para más de tres dimensiones, la ecuación definirá un hiperplano

Resolución:x = [0 1; 1 -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 onX=[-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)

% Debo hacer hebb para cada salida y(i):[inputs,patterns]=size(x);

[r,c]=size(x);


elseif y(i)==0 % Target = 1 w = w+x(:,i)' b = b+1 else % y=1 target=0. w = w-x(:,i)' b = b-1 endendy=hardlim(w*x+b)

No se ve cómo va cambiando la ubicación de la recta de clasificación. Para verlo, cambiemos las entradas:

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 onX=[-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

% Debo hacer hebb para cada salida y(i):[inputs,patterns]=size(x);

[r,c]=size(x);


elseif y(i)==0 % Target = 1 w = w+x(:,i)' b = b+1 else % y=1 target=0. w = w-x(:,i)' b = b-1 endendy=hardlim(w*x+b) % y = 0 0 % aún no converge

Añadimos otro ciclo más:


elseif y(i)==0 % Target = 1 w = w+x(:,i)' b = b+1 else % y=1 target=0. w = w-x(:,i)' b = b-1 endend

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 onX=[-1.5:.5:1.5]; Y=(-b-w(1)*X)./w(2);plot(X,Y)holdtitle('Perceptron Decision Boundary After Two Epochs')

Resumen de evolución de pesos y salidas:

x = 0 1 0 -1Current plot released

y = 0 0

w = 0.9000 -0.2000

b = 0.5000

Current plot released

y = 1 1

w = 0.9000 -0.2000b = -0.5000


y = 0 1 YA CONVERGIÓ

PROBLEMA: DEBERÍA TENER UN PROGRAMA QUE EJECUTE VARIAS ÉPOCAS. VEAMOS EL SIGUIENTE EJEMPLO

EJEMPLO 3:


que tiene 2 variables de entrada (x1 y x2) y una variable de salida (y).


- Si x1= 0 y x2= -0.4, la salida es y = 0;

- Si x1= - 0.3 y x2= -0.2, la salida es y = 0;

- Si x1= 0.5 y x2= 1.3, la salida es y = 1;

- Si x1= 1 y x2= -1.3, la salida es y = 1;

Suponer: w1=0.1, w2=0.8 y b= -0.5:


b) Entrenar la red HASTA QUE SE HAYAN EJECUTADO 20 ÉPOCAS


RESOLUCIÓN:

x = [0 -0.3 0.5 1; -0.4 -0.2 1.3 -1.3]w=[-0.1 .8]; b=[-.5];t=[0 0 1 1]; % SALIDAS DESEADAS

plot(x(1,1:2),x(2,1:2),'*');hold onplot(x(1,3:4),x(2,3:4),'+');hold onaxis([-1.5 1.5 -1.5 1.5]);hold onX=[-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);end

if j==20 fprintf('No solution found.\n')else fprintf('Solution found in %i epochs.\n',j)end

y=hardlim(w*x+b)

figure

plot(x(1,1:2),x(2,1:2),'*');hold onplot(x(1,3:4),x(2,3:4),'+');hold onaxis([-1.5 1.5 -1.5 1.5]);hold onX=[-1.5:.5:1.5];Y=(-b-w(1)*X)./w(2);plot(X,Y);hold;title('FINAL Perceptron Decision Boundary')

RESULTADOS:

x = 0 -0.3000 0.5000 1.0000 -0.4000 -0.2000 1.3000 -1.3000


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

Solution found in 5 epochs.

y = 0 0 1 1 % YA CONVERGIÓ


EJERCICIO 1:

Realice el ejercicio anterior con 5 puntos pertenecientes a un lado de la recta de clasificación y otros 5 puntos en el otro lado. Asegúrese que sea un problema linealmente separable.

- Si es necesario, aumente el número de épocas en el lazo.

- Ponga la evolución gráfica en un movie para ver cómo ha ido variando la posición de la recta de clasificación

- Ahora, mueva uno de los puntos de forma que ya no sea un problema linealmente separable y observe qué pasa si sigue aumentando el número de épocas.

- También ponga la evolución gráfica en un movie para ver cómo ha ido variando la posición de la recta de clasificación

DEBER 1:

Repita el ejercicio anterior pero con datos en 3D.

Evolución: x = [0 -0.3 0.5 1; -0.4 -0.2 1.3 -1.3]w=[-0.1 .8]; b=[-.5];t=[0 0 1 1]; % SALIDAS DESEADAS

plot(x(1,1:2),x(2,1:2),'*');hold onplot(x(1,3:4),x(2,3:4),'+');hold onaxis([-1.5 1.5 -1.5 1.5]);hold onX=[-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


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 onplot(x(1,5:10),x(2,5:10),'+');hold onaxis([-1.5 1.5 -1.5 1.5]);hold onX=[-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);endif 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') endy=hardlim(w*x+b)

DEBER 2:

REALICE EL EJERCICIO 1 EN UN MICROCONTROLADOR PIC 16F877A O EN CUALQUIER OTRO QUE DESEE.

- Los datos deberán ser enviados desde una interfaz desde el PC realizado en visual basic en donde también deberá ser vista la gráfica con los puntos a clasificar.

- La época actual y las salidas de la red deberán ser vistas en un LCD 4x16: poner un delay para poder verlas despacio.

- Al final, poner en el LCD el número de época a la cual convergió la red o decir que es un problema no linealmente separable

EJEMPLO 3:


que tiene 2 variables de entrada (x1 y x2) y dos variables de salida (Y1 y Y2).


- Si x1= 0 y x2= -0.4, las salidas son y1 = 0, y2= 0;

- Si x1= - 0.3 y x2= -0.2, las salidas son y1 = 0, y2= 1;

- Si x1= 0.5 y x2= 1.3, las salidas son y1 = 1, y2=0;

- Si x1= 1 y x2= -1.3, las salidas son y1 = 1, y2=0;

Suponer: w = [-0.1 0.8; 0.2 -0.9] y b= [-0.5; 0.3]:


b) Entrenar la red HASTA QUE SE HAYAN EJECUTADO 20 ÉPOCAS


Resolución::

x=[0 -.3 .5 1;-.4 -.2 1.3 -1.3] % Input vectorst=[0 0 1 1; 0 1 0 0] % Target vectorsw=[-0.1 0.8; 0.2 -0.9] b=[-0.5;0.3] % Weights and biases

plot(x(1,1),x(2,1),'*') hold on 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])X1=[-1.5:.5:1.5]; Y1=(-b(1)-w(1,1)*X1)./w(1,2);plot(X1,Y1)X2=[-1.5:.5:1.5]; Y2=(-b(2)-w(2,1)*X2)./w(2,2);plot(X2,Y2)holdtitle('Inicial Perceptron Decision Boundaries')

for j=1:20 [r,c]=size(x); y = hardlim([w b]*[x ;ones(1,c)]) if all(t==y) break, end % Training complete. w=w+(t-y)*x'; b=b+(t-y)*ones(length(x),1);end


ty = hardlim([w b]*[x ;ones(1,c)])

figureplot(x(1,1),x(2,1),'*') hold on 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])X1=[-1.5:.5:1.5]; Y1=(-b(1)-w(1,1)*X1)./w(1,2);plot(X1,Y1)X2=[-1.5:.5:1.5]; Y2=(-b(2)-w(2,1)*X2)./w(2,2);plot(X2,Y2)holdtitle('Perceptron Decision Boundaries')text(-1,.5,'Clase1'); text(-.3,.5,'Clase2');

text(.5,.5,'Clase3');

Resultados::

x = 0 -0.3000 0.5000 1.0000 -0.4000 -0.2000 1.3000 -1.3000

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 0Solution found in 6 epochs.

t = 0 0 1 1 0 1 0 0

y = 0 0 1 1 0 1 0 0


EJERCICIO:

Realice el ejercicio anterior con 5 puntos pertenecientes a 4 clases. Asegúrese que sea un problema linealmente separable.

- Si es necesario, aumente el número de épocas en el lazo.

- Genere un gráfico por cada actualización de pesos para ver cómo ha ido variando la posición de la recta de clasificación.

- Ahora, mueva uno de los puntos de forma que ya no sea un problema linealmente separable y observe qué pasa si sigue aumentando el número de épocas.

- También genere un gráfico por cada actualización de pesos para ver cómo ha ido variando la posición de la recta de clasificación.

MLP: Multi Layer Perceptron

- Así se denomina a un red que tenga una o más capas ocultas.

- Normalmente todas las neuronas de la capa oculta usan funciones de activación sigmoidales (función logistic).

- En la salida pueden ir las siguientes funciones de activación:

a) sigmoidal (logistica): limitada entre (0 y 1)

b) tangente hiperbólica: limitada entre (-1 y 1)

c) lineal: no tiene límites

- Se ha probado que una MLP con una sola capa oculta (con funciones de activación sigmoidales) es capaz de aproximar cualquier función continua con cualquier grado de xactitud y por ello se la ha denominado “aproximador universal”.

- Lo que no dice es cuántas neuronas son necesarias y el incremento de ellas no necesariamente reduce el número de épocas de entrenamiento.

Problema: cómo hacemos que se actualicen los pesos y biases de cada una de las capas de neuronas?

Este algoritmo se denomina Backpropagation, o de retropropagación, por el hecho de que se lleve a cabo desde la salida hacia la entrada.

Se puede dividir en dos partes:• Ajuste de los pesos de salida.• Ajuste de los pesos de la capa oculta.

SOLUCIÓN: ALGORITMO DE RETROPROPAGACIÓN:

AJUSTE DE LOS PESOS DE SALIDA:

La primera de las dos partes en que hemos dividido el problema es simplemente la variación del error con el valor de salida a, y conociendo la definición del error (error cuadrático medio) es trivial llegar al resultado final:

Por las características anteriormente mencionadas, podemos considerar una sola neurona de salida y realizar el análisis como si estuviese aislada. Esto se puede apreciar en el siguiente gráfico que usaremos como guía:

Lo que buscamos es saber cómo varía el error con las variaciones de los pesos de las entradas, o lo que es lo mismo:

E = error cometido = salida obtenida - salida deseada.

Por otra parte el segundo problema podemos dividirlo en otros dos:

De lo que concluimos que f ha de ser derivable.

Uniendo todos los pasos anteriores llegamos a la expresión final:

% 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.7000W1 = -0.5000 0.1000 -0.2000 -0.2000 0.4000 0.2000W2 = -0.6000 0.2000 -0.5000output = 0.3118

Ajuste de los pesos de salida:

new_W2_2 = W2+ 2*lr*[1;logistic(W1*X)]'*output.*(1-output).*(t-logistic(W2*[1;logistic(W1*X)]))

Ajuste de los pesos de salida:

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];t = [0.1];lr = 0.5;

X = [1;x]W1 = [b1 w1]W2 = [b2 w2]output=logistic(W2*[1;logistic(W1*X)])

h = logistic(W1*X); % Salida de la capa oculta.H = [1;h]; % para trabajar con la forma 2.Out_err = t-logistic(W2*[1;logistic(W1*X)])

output=logistic(W2*[1;logistic(W1*X)])

new_W2 = W2+ 2*lr*[1;logistic(W1*X)]'*output.*(1-output).*Out_err

% new_W2 = -0.6455 0.1839 -0.5239

Out_err = t-logistic(new_W2*[1;logistic(W1*X)]) % Nuevo error de salida

% 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.

Buscamos la variación del error con los pesos de la capa anterior.

Separaremos el problema en pequeños pasos que simplifiquen la operación:

Por lo que el problema consiste en hallar:

Calculémoslas por pasos:

De esta manera podemos calcular los pesos de la siguiente fase de a partir de los de la fase anterior con la variación contraria al error, es decir:

Y por tanto:

Para el resto de las capas se aplicaría la misma regla recursivamente hasta la entrada, momento en el cual se vuelve a aplicar otra entrada de entrenamiento y nuevamente se propaga el error hacia atrás.

Observación:

El entrenamiento de una neurona no afecta al entrenamiento que se haya realizado anteriormente con otras neuronas, es decir podemos considerar a cada neurona como un problema independiente. Para ello y teniendo en cuenta que partimos de una situación en que conocemos la salida deseada, tenemos que comenzar a entrenar desde la salida hacia la entrada.

Ejercicio: actualizar los pesos W1

Ejercicio: actualizar los pesos W1

% Añadimos el siguiente código al anterior:

% Actualización de los pesos W1:

[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];t = [0.1 0.3 0.6 0.2];lr = 0.5;[inputs,patterns] = size(x);[outputs,patterns] = size(t);W1 = [0.1 -0.2 0.1; 0.4 0.2 0.9];

W2 = [0.2 -0.5 0.1];

X = [ones(1,patterns); x];h = logistic(W1*X);H = [ones(1,patterns);h];e = t-logistic(W2*H)

% e = -0.4035 -0.2065 0.0904 -0.2876

% La suma del error cuadrático es:SSE = sum(sum(e.^2))

% SSE = 0.2963

output = logistic(W2*H)delta2 = output.*(1-output).*e

% output = 0.5035 0.5065 0.5096 0.4876% delta2 = -0.1009 -0.0516 0.0226 -0.0719

del_W2 = 2*lr* delta2*H'new_W2 = W2+ del_W2

% del_W2 = -0.2017 -0.1082 -0.1208% new_W2 = -0.0017 -0.6082 -0.0208

% La nueva suma del error cuadrático es:

e = t- logistic(new_W2*H);SSE = sum(sum(e.^2)) % SSE = 0.1926

% Se ha reducido de 0.2963 a 0.1926 solo al cambiar los pesos de salida.

% Actualización de los pesos de la capa oculta. % Note que no podemos usar la forma 2:[numout,numhidb] = size(W2);delta1 = h.*(1-h).*(W2(:,2:numhidb)'*delta2)

% delta1 = 0.0126 0.0065 -0.0028 0.0088% -0.0019 -0.0008 0.0002 -0.0016

% Ahora calculamos el cambio en los pesos de la capa oculta:del_W1 = 2*lr*delta1*X'new_W1 = W1+del_W1

% del_W1 = 0.0250 -0.0049 0.0016% -0.0041 0.0009 -0.0003% new_W1 = 0.1250 -0.2049 0.1016% 0.3959 0.2009 0.8997

h = logistic(new_W1*X);H = [ones(1,patterns);h];e = t-logistic(new_W2*H);SSE = sum(sum(e.^2))

% SSE = 0.1917

% El nuevo SSE es 0.1917 que es inferior a SSE de 0.1926

Tasa de aprendizaje adaptativo:

Si el error decrementó, entonces incremente la tasa de aprendizaje:

lr=lr*1.1

Si el error incrementó, entonces decremente la tasa de aprendizaje:

lr=lr*0.5

Solo actualice los pesos si el error decrementó.

Escogiendo:

- Un número de neuronas ocultas

Realizando el entrenamiento hasta cumplir con: - Número máximo de iteraciones o épocas - SSE mínimo

% Escogiendo un número de neuronas ocultas, SSE min ó Max ciclos.

x = [0.4 0.8 1.3 -1.3;0.7 0.9 1.8 -0.9];t = [0.1 0.3 0.6 0.2];[inputs,patterns] = size(x);[outputs,patterns] = size(t);hidden=6;W1=0.1*ones(hidden,inputs+1);W2=0.1*ones(outputs,hidden+1);maxcycles=200;SSE_Goal=0.1;lr=0.5;SSE=zeros(1,maxcycles);X=[ones(1,patterns); x];for i=1:maxcycles h = logistic(W1*X); H=[ones(1,patterns);h]; e=t-logistic(W2*H); SSE(i)= sum(sum(e.^2)); if SSE(i)<SSE_Goal; break;end output = logistic(W2*H); delta2= output.*(1-output).*e; del_W2= 2*lr* delta2*H'; W2 = W2+ del_W2; delta1 = h.*(1-h).*(W2(:,2:hidden+1)'*delta2); del_W1 = 2*lr*delta1*X'; W1 = W1+del_W1;end;clfsemilogy(nonzeros(SSE));title('Backpropagation Training');xlabel('Cycles');ylabel('Sum of Squared Error')if i<200;fprintf('Error goal reached in %i cycles.',i);end

%Objetivo del Error alcanzado en 116 ciclos.

Numero de neuronas ocultas Ciclos de entrenamiento

1 106

2 95

3 97

4 102

5 109

6 116

Vemos que no hay ninguna relación

Escalando valores de entrada:

Problema: si las entradas no son de valores apropiados, se puede producir saturación de las funciones sigmoidales. Entonces es necesario escalar las entradas.Ha dos métodos:- a) escalado lineal- b) z-score: normalización estadística

Escalado lineal:

function [y,slope,int]= scale(x,slope,int)% [x,m,b]=scale(x,m,b)% % Para funciones sigmoidales: escalado entre 0.1 and 0.9% y = m*x + b% x = data% m = slope% b = y intercept%[nrows,ncols]=size(x);

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

% Las nuevas entradas ya escaladas:y = (ones(nrows,1)*slope).*x + ones(nrows,1)*int;

Escalado con normalización:

function [y,meanval,stdval] = zscore(x, meanaval,stdval)%% [y,mean,std] = zscore(x, mean_in,std_in)% Mean center the data and scale to unit variance.% If number of inputs is one, calculate the mean and standard deviation.% If the number if inputs is three, use the calculated mean and SD.%[nrows,ncols]=size(x);if nargin == 1 meanval = mean(x); % cálculo del valor medio (cuidado: ver tendencia central)end

y = x - ones(nrows,1)*meanval; % quitamos la tendencia central

if nargin == 1 stdval = std(y); % calculamos la desviación estándar endy = y ./ (ones(nrows,1)*stdval); % normalización

Ejemplo de escalado de los valores de entrada:

x=[1 2;30 21;-1 -10;8 34][y,slope, int]=scale(x)[y,meanval,stdval]=zscore(x) x = 1 2 30 21 -1 -10 8 34y = 0.1516 0.3182 0.9000 0.6636 0.1000 0.1000 0.3323 0.9000slope = 0.0258 0.0182int = 0.1258 0.2818y = -0.5986 -0.4983 1.4436 0.4727 -0.7394 -1.1115 -0.1056 1.1370meanval = 9.5000 11.7500stdval = 14.2009 19.5683

Si la MLP es entrenada con valores escalados, si entran nuevos valores a la red, estos deberán ser normalizados con los mismos parámetros del inicio.

Inicialización de pesos:

Deben ser pesos pequeños:

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:

- Datos de entrenamiento (x, t): x = entradas, t = salidas deseadas Variable Descripción Filas Columnas x datos de entrada Num. de entradas Num. de patrones t salidas deseadas Num. de salidas Num. de patrones

- Número de neuronas de la capa oculta.- Tipo de escalado a utilizar.- El error a obtener como meta.- Máximo número de ciclos o épocas de entrenemiento.

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 entrenamientot=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: %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

fprintf('\n\nLos parámetros por defecto son:\n\n');fprintf('Tolerancia en el error de salida (RMS) = .1\n'); RMS_Goal = .1; fprintf('Máximo número de ciclos de entrenamiento= 5000.\n'); maxcycles = 5000;fprintf('La tasa inicial de aprendizaje es = 0.1.\n'); lr = 0.1;

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Permitir al usuario cambiar los parámetros por defecto:%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

choice = input('Está satisfecho con estos parámetros? [y,n]:','s');

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

fprintf('\nEsta red tiene:\n\n');fprintf(' %0.f neuronas de entrada\n',inputs);fprintf(' %0.f neuronas en la capa oculta\n',hidden);fprintf(' %0.f neuronas de salida\n\n',outputs);fprintf('Hay %0.f pares de entradas/salidas.\n\n',patterns);

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Escalado de las entradas:%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

if sc == 'z'[xn, xm, xs] = zscore(x);

elseif sc == 'l'[xn, xm, xs] = scale(x);

elsexn=x;

end

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Inicialización de pesos a pequeños números randómicos:%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

W1=0.5*randn(hidden,inputs+1); % Initialize output layer weight matrix.W2=0.5*randn(outputs,hidden+1); % Initialize hidden layer weight matrix.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Entrenamiento de la red usando el algoritmo de backpropagation:%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

[W1 W2 RMS LR]=backprop_curso(xn,t,W1,W2,RMS_Goal,lr,maxcycles);

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 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:%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

fprintf('\n*** Entrenamiento BP completado en %0.f epocas! ***',cycles)fprintf('\n*** RMS = %e \n\n',min(RMS))

end

save WEIGHTS W1 W2 xm xs sc RMS LR

function [W1,W2,RMS,LR]=backprop_curso (x,t,W1,W2,RMS_Goal,lr,maxcycles)% BACKPROP_CURSO Entrena una red MLP de dos capas (logistic/Linear) % [W1,W2,RMS,LR]=backprop_curso(x,t,W1,W2,RMS_Goal,lr,maxcycles)%% The MLP tiene: capa oculta: funciones de activación logisticas% capa de salida: funciones de activación lineales.%% x : matriz de datos de las entradas.% t : matriz de salidas deseadas.% W1 : Matriz de pesos de la capa oculta.% W2 : Matris de pesos de la capa de salida.% RMS_Goal : Root Mean Squared Error meta.% lr : Tasa de aprendizaje.% maxcycles : Maximo número de iteraciones de entrenamiento.% LR : Histórico de la tasa de aprendizaje durante el entrenamiento.% RMS : Histórico del RMS durante el entrenemiento.%% Ver bptrain_curso para el entrenemiento.

[inputs,patterns1]=size(x);[outputs,patterns]=size(t);[hidden,inputs1]=size(W1);[outputs1,hidden1]=size(W2);

if outputs1 ~= outputserror('W1 no encajan con el vector de salidas deseadas.')

end

if inputs1 ~= inputs+1error(' W2 does no encajan con el vector de entrada.')

end

if hidden1 ~= hidden+1error('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 ocultaH=[ones(1,patterns);h];output = linear(W2*H); % vector de salidae = t-output; % error de salidaRMS(1) = sqrt(sum(sum(e.^2))/terms); % error RMS.fprintf('Epoca = 1, lr = %f, RMS Error = %f\n',lr,RMS(1))

for i=2:maxcyclesdelta2 = 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 ocultanew_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 ocultanew_output = linear(new_W2*new_H); % vector de salidanew_e = t-new_output; % Error de salidaRMS(i) = sqrt(sum(sum(new_e.^2))/terms);% error RMS.

if RMS(i)<RMS(i-1) % Incremente la tasa de aprendizaje.W1 = new_W1; % Error decrementó, entonces actualice los pesos.W2 = new_W2;e=new_e;

h=new_h;H=new_H;lr=lr*1.1;

else lr=lr*.5; % Decremente la tasa de aprendizaje.end

LR(i)=lr; % Almacenar la evolución de la tasa de aprendizaje.if RMS(i)<RMS_Goal; break;end % Criterio de error encontrado.if rem(i,50)==0, fprintf('Epoca = %i, lr = %f, RMS Error = %f\n',i,LR(i),RMS(i)),end

end

RMS=nonzeros(RMS);LR=nonzeros(LR);

Ejemplo 1 de utilización:

Considere que los datos de un experimento son generados por la función:

Y = 2 x1 + 0.2 x12

Corremos el programa:

Cuántas neuronas desea en la capa oculta? 2Ingrese el método de escalado: zscore=z, linear=l, none=n ?[z,l,n]:l

Los parámetros por defecto son:

Tolerancia en el error de salida (RMS) = .1Máximo número de ciclos de entrenamiento= 5000.La tasa inicial de aprendizaje es = 0.1.Está satisfecho con estos parámetros? [y,n]:y

Esta red tiene:

1 neuronas de entrada 2 neuronas en la capa oculta 1 neuronas de salida

Hay 11 pares de entradas/salidas.

Epoca = 1, lr = 0.100000, RMS Error = 2.643514Epoca = 50, lr = 0.094125, RMS Error = 1.860973Epoca = 100, lr = 0.097455, RMS Error = 1.836764Epoca = 150, lr = 0.100902, RMS Error = 1.766102Epoca = 200, lr = 0.104472, RMS Error = 1.647973Epoca = 250, lr = 0.108168, RMS Error = 1.494268Epoca = 300, lr = 0.111994, RMS Error = 1.110747Epoca = 350, lr = 0.052707, RMS Error = 0.617961Epoca = 400, lr = 0.054572, RMS Error = 0.350254Epoca = 450, lr = 0.056503, RMS Error = 0.246746Epoca = 500, lr = 0.058501, RMS Error = 0.194099Epoca = 550, lr = 0.060571, RMS Error = 0.160784Epoca = 600, lr = 0.062714, RMS Error = 0.137435Epoca = 650, lr = 0.064932, RMS Error = 0.120749Epoca = 700, lr = 0.067229, RMS Error = 0.108296

*** Entrenamiento BP completado en 744 epocas! ****** RMS = 9.996243e-002

Bastaron 744 épocas para conseguir el error RMS de 0.1

Resultados generados:

Evolución del RMS

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:

close all; clear all;clc

load WEIGHTS % CARGAMOS LOS PESOS YA ENTRENADOSx=[0:.1:10];t=2*x - 0.21*x.^2;output = W2*[ones(size(x));logistic(W1*[ones(size(x));x])]; % OBTENEMOS LA SALIDA DE LA REDplot(x,t,'g:',x,output,'r')title('Verificación de la capacidad de interpolación')xlabel('Entrada')ylabel('Salida') legend('resultado real', 'resultado de la MLP')

Ejemplo 2: MLP aplicada a clasificación de patrones

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:

function W1,W2,RMS]=bprop2(x,t,W1,W2,RMS_Goal,lr,maxcycles)[inputs,patterns1]=size(x);[outputs,patterns]=size(t);[hidden,inputs1]=size(W1);[outputs1,hidden1]=size(W2);

if outputs1 ~= outputs error('Weight dimension of W1 does not match the target vector.')end

if inputs1 ~= inputs+1 error('Weight dimension of W2 does not match the input vector.')end

if hidden1 ~= hidden+1 error('Weight dimension of W1 and W2 does not coincide.')end

terms=outputs*patterns;RMS=zeros(1,maxcycles);X=[ones(1,patterns); x];

for i=1:maxcycles h=logistic(W1*X); H=[ones(1,patterns);h]; % Hiden layer output output = logistic(W2*H); % Output Vector

e = t-output; % Output Error RMS(i) = sqrt(sum(sum(e.^2))/terms);% Root mean squared error.

if RMS(i)<RMS_Goal; break;end

if RMS(i)<=RMS(max((i-1),1)) lr=lr*1.1; % Adaptive learning rate. else lr=lr*.1; end

delta2= output.*(1-output).*e; del_W2= 2*lr* delta2*H'; delta1 = h.*(1-h).*(W2(:,2:hidden+1)'*delta2); del_W1 = 2*lr*delta1*X'; W1 = W1+del_W1; % Hidden layer weight update. W2 = W2+del_W2; % Output layer weight update

end

RMS=nonzeros(RMS);

save pesos_1 W1 W2

Particularización de la función de aprendizaje:

% programa para clasificar las letras A a la P:

load lettersW1=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

a) Procedimiento usando modelo AR y distancia euclideana:

1. Grabar unas 10 veces cada una de las vocales2. Extraer los modelos AR de orden 103. Realizar un promedio de cada uno de los coeficientes para cada una de las

vocales. Estos vectores serán los que representen a cada una de las vocales.4. Clasificar la nueva vocal por medio de la distancia Euclideana: la mínima

distancia a una de los vectores promedio, será la que gane la clasificación.

MÉTODOS:

a) Usando modelo AR y distancia euclideana.

b) Usando una MLP teniendo como entradas los coeficientes AR

Vocal a

Vocal uVocal o

Vocal iVocal e

VOCALES: SERIES TEMPORALES Y ESPECTROS DE POTENCIA

Método ARMétodo ARclc, clear all;clc, clear all;load a;load e; load i;load o;load uload a;load e; load i;load o;load u;;ai = analoginput('winsound'); % Entrada analógicaai = analoginput('winsound'); % Entrada analógicaduration = 1;duration = 1;Fs=8000;Fs=8000;addchannel(ai, 1);addchannel(ai, 1);set(ai, 'SamplesPerTrigger', duration*Fs);set(ai, 'SamplesPerTrigger', duration*Fs);set(ai, 'SampleRate',Fs);set(ai, 'SampleRate',Fs);start(ai);start(ai);disp('Hable ahora...')disp('Hable ahora...')nueva = getdata(ai);nueva = getdata(ai);while strcmp(ai.Running,'On'); while strcmp(ai.Running,'On'); endendV=nueva';V=nueva';vocal=lpc(V,10);vocal=lpc(V,10);

d(1)=((vocal(1)-a(1))^2+((vocal(2)-a(2))^2)+((vocal(3)-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)+a(3))^2)+((vocal(4)-a(4))^2)+((vocal(5)-a(5))^2)+(vocal(6)-a(6))^2+(vocal(7)-a(7))^2+(vocal(8)-(vocal(6)-a(6))^2+(vocal(7)-a(7))^2+(vocal(8)-a(8))^2+(vocal(9)-a(9))^2+(vocal(10)-a(10))^2+a(8))^2+(vocal(9)-a(9))^2+(vocal(10)-a(10))^2+(vocal(11)-a(11))^2)^(0.5);(vocal(11)-a(11))^2)^(0.5);

d(2)=((vocal(1)-e(1))^2+((vocal(2)-e(2))^2)+((vocal(3)-d(2)=((vocal(1)-e(1))^2+((vocal(2)-e(2))^2)+((vocal(3)-e(3))^2)+((vocal(4)-e(4))^2)+((vocal(5)-e(5))^2)+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)-(vocal(6)-e(6))^2+(vocal(7)-e(7))^2+(vocal(8)-e(8))^2+(vocal(9)-e(9))^2+(vocal(10)-e(10))^2+e(8))^2+(vocal(9)-e(9))^2+(vocal(10)-e(10))^2+(vocal(11)-e(11))^2)^(0.5);(vocal(11)-e(11))^2)^(0.5);

d(3)=((vocal(1)-i(1))^2+((vocal(2)-i(2))^2)+((vocal(3)-d(3)=((vocal(1)-i(1))^2+((vocal(2)-i(2))^2)+((vocal(3)-i(3))^2)+((vocal(4)-i(4))^2)+((vocal(5)-i(5))^2)+i(3))^2)+((vocal(4)-i(4))^2)+((vocal(5)-i(5))^2)+(vocal(6)-i(6))^2+(vocal(7)-i(7))^2+(vocal(8)-(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+i(8))^2+(vocal(9)-i(9))^2+(vocal(10)-i(10))^2+(vocal(11)-i(11))^2)^(0.5);(vocal(11)-i(11))^2)^(0.5);

d(4)=((vocal(1)-o(1))^2+((vocal(2)-o(2))^2)+((vocal(3)-d(4)=((vocal(1)-o(1))^2+((vocal(2)-o(2))^2)+((vocal(3)-o(3))^2)+((vocal(4)-o(4))^2)+((vocal(5)-o(5))^2)+o(3))^2)+((vocal(4)-o(4))^2)+((vocal(5)-o(5))^2)+(vocal(6)-o(6))^2+(vocal(7)-o(7))^2+(vocal(8)-(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+o(8))^2+(vocal(9)-o(9))^2+(vocal(10)-o(10))^2+(vocal(11)-o(11))^2)^(0.5);(vocal(11)-o(11))^2)^(0.5);

d(5)=((vocal(1)-u(1))^2+((vocal(2)-u(2))^2)+((vocal(3)-d(5)=((vocal(1)-u(1))^2+((vocal(2)-u(2))^2)+((vocal(3)-u(3))^2)+((vocal(4)-u(4))^2)+((vocal(5)-u(5))^2)+u(3))^2)+((vocal(4)-u(4))^2)+((vocal(5)-u(5))^2)+(vocal(6)-u(6))^2+(vocal(7)-u(7))^2+(vocal(8)-(vocal(6)-u(6))^2+(vocal(7)-u(7))^2+(vocal(8)-u(8))^2+(vocal(9)-u(9))^2+(vocal(10)-u(10))^2+u(8))^2+(vocal(9)-u(9))^2+(vocal(10)-u(10))^2+(vocal(11)-u(11))^2)^(0.5);(vocal(11)-u(11))^2)^(0.5);

for i=1:5for i=1:5 D(i)=abs(d(i));D(i)=abs(d(i)); endend minima=min(D)minima=min(D) if minima==D(1)if minima==D(1) disp('usted dijo a')disp('usted dijo a') elseif minima==D(2)elseif minima==D(2) disp('usted dijo e')disp('usted dijo e') elseif minima==D(3)elseif minima==D(3) disp('usted dijo i')disp('usted dijo i') elseif minima==D(4)elseif minima==D(4) disp('usted dijo o')disp('usted dijo o') else minima==D(5)else minima==D(5) disp('usted dijo u')disp('usted dijo u') endend

Ejemplo (Coeficientes AR):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”

Problema de clasificación: A cuál de los dos conjuntos pertenece?


La principal ventaja de la PNN frente a la MLP es su velocidad de aprendizaje pues sus pesos no son entrenados a través de un proceso iterativo.

Una segunda ventaja es que la PNN tiene una base teórica muy firme.

Ya que se basa en una teoría estadística, necesita de un número muy grande de datos conocidos.

Entonces la PNN debería ser utilizada solo en los casos en que se disponga de un gran número de casos.

Se necesita calcular las dispersiones de todos los conjuntos.


Un estimador de la Función de Densidad de Probabilidad, si se tratase de una distribución normal, sería:

N: número de caso en la clase.xi es un específico caso en la clase.x es la entrada es el parámetro de dispersión

Esta función es usada para calcular el grado de pertenencia de un xi a cada clase.


Grado de pertenencia a cada una de las dos clases:

EJEMPLO:

close all; clear all;clcx=[-3 -2;-3 -3;-2 -2;-2 -3;3 2;3 3;2 2;2 3]; % Datos de entrenamientoy=[1 1 1 1 2 2 2 2]'; % Salidas deseadasxtest=[-.5 1.5]; % Vector a ser clasificado.plot(x(:,1),x(:,2),'*');hold;plot(xtest(1),xtest(2),'o');title(‘Conjuntos de datos y elemento a ser clasificado por una PNN')axis([-4 4 -4 4]); xlabel('Input1');ylabel('Input2');hold off;

Se desea clasificar el círculo según su grado de pertenencia a cada uno de los dos conjuntos.


function [class,w_dist]=pnn (x,y,classes,xtest,a);%PNN Probabilistic Neural Network% PNN(x,y,classes,xtest,a)% PNN constructs a Probabilistic Neural Network and classifies an input vector: xtest.% x : input trainig vector% y : vector of the classification number {1 2 2 3 3 etc.}% classes : number of classification possibilities% xtest : vetor to be classified% a : width parameter, sigma% class : class that xtest was classified as% w_dist : vector of membership to each class[patterns,inputs]=size(x);[patterns,outputs]=size(y);

cases=zeros(classes,1); % Vector containing the number of casesfor i=1:classes % in each clasification. ind=find(y==i); cases(i)=length(ind);end

a_sqr=(inputs*a).^2; % Reduces effect of the number of inputs on sigma[y,ind]=sort(y); % Sort by classification.x=x(ind,:); % Rearrange x to match y's order.

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.endclass=find(w_dist==max(w_dist)); % Find highest probability of classification.


Resolución:

a=3; % a is the width parameter: sigma.classes=2; % x has two classifications.[class,prob]=pnn(x,y,classes,xtest,a) % Classify the test input: testx.

% class = 2

% prob = 0.1025 0.3114


Repita lo mismo pero para otros puntos: vea cómo va cambiando el grado de pertenencia a las dos clases en función de que el punto de test se va acercando a uno de ellos.

OBS: Al aumentar el número de puntos de datos de las dos clases, se mejora el intervalo de confianza del resultado. Al tener pocos datos, sí obtendremos un resultado del grado de pertenencia pero su grado de confianza será bastante bajo.

Recordando:

Regresión:

- Polinomial

- Modelos AR, MA y ARMA

- Gaussiana (RBF) (se verá luego de redes neuronales)

- Sp-lines

RED NEURONAL CON

FUNCIONES DE BASE RADIAL

(REGRESIÓN GAUSSIANA)

• FUNCIONES UBICADAS EN EL CENTRO DE LOS CAMPOS RECEPTIVOS.

• LOS CAMPOS RECEPTIVOS SON AREAS EN EL ESPACIO DE ENTRADAS QUE

ACTIVAN LA NEURONA LOCAL

function [y]=gaussian(x,w,a)

[patterns,inputs]=size(x);[inputs1,neurons]=size(w);

if inputs1 ~= inputserror('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)); endend

Función gaussiana:

Ejemplo de aproximación de funciones:

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')

% Ancho de la funcion de base radialwidth=6;

% Centro de los campos receptivosw1=[-8 -5 -2 0 2 5 8];

% Numero de campos receptivos.num_w1=length(w1);

% 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;

% Cpas ocultas de salida.test_a1=gaussian(test_x,w1,width);

% Salidas de la red.yout=test_a1*w2;

figureplot(test_x,[y_target yout]);title('Red RBF: probando'); xlabel('Input'); ylabel('Output')

Resolución: fichero demo_rbf

PROXIMA CLASE:

- REDES NEURONALES COMPETITIVAS

- MAPAS AUTOORGANIZATIVOS

- RED NEURAL PROBABILISTICA

- REGRESIÓN GENERALIZADA CON RED NEURONAL

- SISTEMAS DE CONTROL Y REDES NEURONALES

DINÁMICAS

- LÓGICA DIFUSA Y REDES NEURODIFUSAS

1_7_EPN_CLASIFICACION_MLP

Documents

Transcript of 1_7_EPN_CLASIFICACION_MLP