Vous êtes sur la page 1sur 117

“Quien no se resuelve a cultivar el hábito de

pensar, se pierde el mayor placer de la vida”


Thomas A. Edison

Seminario de técnicas para el


procesamiento de datos
Herramienta de apoyo: MatLab

Ing. Robin Alvarez Rueda, PhD, MSc.

Prof. Ing. Alexeis Companioni


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:

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

4. Función paso unitario


2. TANGENTE HIPERBÓLICA:
% Función:
x=[-3:0.1:3];
y=tanh(x); function [y] = hardlim (x);
plot(x,y) y=(x>=0);
title('Hyperbolic Tangent
Activation Function')
xlabel('x')

ylabel('tanh(x)')
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];
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:

x=[2 4 6]'; x=[ 1 2 4 6]';


w=[0.5 -0.25 0.33; 0.2 -0.75 -0.5]; w=[0.4 0.5 -0.25 0.33; -1.2 0.2 -0.75 -0.5];
b=[0.4 -1.2]'; y=tanh(w*x)
y=tanh(w*x+b)
%y=
%y= % 0.9830
% 0.9830
% -1.0000
% -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 )


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' ALGORITMO DE
b = b+1
else % y=1 Pues target=0. APRENDIZAJE DE
w = w-x'
b = b-1 HEBB
end

% w = 1.3000 -2.3000
% b = 0.2000

y=hardlim(w*x+b)

%y= 1 % ya convergió
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:


a) Plantear la red de perceptrones
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] %x= 0 1
t=[0 1]; % 1 -1
w=[-0.1 .8]; b=[-.5];

y=hardlim(w*x+b) %y= 1 0

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

[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

else % y=1 target=0. % w = -0.1000 -0.2000


w = w-x(:,i)' % b = -1.5000
b = b-1 %
end % w = 0.9000 -1.2000
end % b = -0.5000

y=hardlim(w*x+b) %y= 0 1 % YA CONVERGIÓ


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

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

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

% 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
end
end
Añadimos otro ciclo más:

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
end
end

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

Current plot released

y= 1 1

w = 0.9000 -0.2000
b = -0.5000

Current plot released

y= 0 1
YA CONVERGIÓ

PROBLEMA: DEBERÍA TENER UN PROGRAMA QUE EJECUTE VARIAS


ÉPOCAS. VEAMOS EL SIGUIENTE EJEMPLO
EJEMPLO 3:

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


a) Plantear la red de perceptrones
b) Entrenar la red HASTA QUE SE HAYAN EJECUTADO 20 ÉPOCAS
c) Mostrar gráficamente la evolución del problema linealmente separable por
medio de una recta de clasificación.
RESOLUCIÓN:
x = [0 -0.3 0.5 1; -0.4 -0.2 1.3 -1.3]
w=[-0.1 .8]; b=[-.5]; y=hardlim(w*x+b)
t=[0 0 1 1]; % SALIDAS DESEADAS
figure
plot(x(1,1:2),x(2,1:2),'*');hold on
plot(x(1,3:4),x(2,3:4),'+');hold on plot(x(1,1:2),x(2,1:2),'*');hold on
axis([-1.5 1.5 -1.5 1.5]);hold on plot(x(1,3:4),x(2,3:4),'+');hold on
X=[-1.5:.5:1.5]; axis([-1.5 1.5 -1.5 1.5]);hold on
Y=(-b-w(1)*X)./w(2); X=[-1.5:.5:1.5];
plot(X,Y);hold; Y=(-b-w(1)*X)./w(2);
title('Original Perceptron Decision Boundary') plot(X,Y);hold;
title('FINAL 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
RESULTADOS:

x= 0 -0.3000 0.5000 1.0000


-0.4000 -0.2000 1.3000 -1.3000

Current plot released

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Ó

Current plot released


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

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:

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


que tiene 2 variables de entrada (x1 y x2) y dos variables de salida (Y1 y Y2).
Experimentalmente se encuentra que:
- 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]:


a) Plantear la red de perceptrones
b) Entrenar la red HASTA QUE SE HAYAN EJECUTADO 20 ÉPOCAS
c) Mostrar gráficamente la evolución del problema linealmente separable por
medio de una recta de clasificación.
Resolución::
x=[0 -.3 .5 1;-.4 -.2 1.3 -1.3] % Input vectors if j==20
t=[0 0 1 1; 0 1 0 0] % Target vectors fprintf('No solution found.\n')
w=[-0.1 0.8; 0.2 -0.9] else
b=[-0.5;0.3] % Weights and biases fprintf('Solution found in %i epochs.\n',j)
end

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

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

t= 0 0 1 1
0 1 0 0

y= 0 0 1 1
0 1 0 0

Current plot released


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?
SOLUCIÓN: ALGORITMO DE RETROPROPAGACIÓN:

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.
AJUSTE DE LOS PESOS DE SALIDA:

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:

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 otra parte el segundo problema podemos


dividirlo en otros dos:

E = error cometido = salida obtenida - salida deseada.


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

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

X = [ones(1,patterns); x]; % Actualización de los pesos de la capa oculta.


h = logistic(W1*X); % Note que no podemos usar la forma 2:
H = [ones(1,patterns);h]; [numout,numhidb] = size(W2);
e = t-logistic(W2*H) delta1 = h.*(1-h).*(W2(:,2:numhidb)'*delta2)

%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

output = logistic(W2*H) % del_W1 = 0.0250 -0.0049 0.0016


delta2 = output.*(1-output).*e % -0.0041 0.0009 -0.0003
% new_W1 = 0.1250 -0.2049 0.1016
% output = 0.5035 0.5065 0.5096 0.4876 % 0.3959 0.2009 0.8997
% delta2 = -0.1009 -0.0516 0.0226 -0.0719
h = logistic(new_W1*X);
del_W2 = 2*lr* delta2*H' H = [ones(1,patterns);h];
new_W2 = W2+ del_W2 e = t-logistic(new_W2*H);
SSE = sum(sum(e.^2))
% del_W2 = -0.2017 -0.1082 -0.1208
% new_W2 = -0.0017 -0.6082 -0.0208 % 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)); Numero de neuronas ocultas Ciclos de entrenamiento
if SSE(i)<SSE_Goal; break;end
output = logistic(W2*H); 1 106
delta2= output.*(1-output).*e;
del_W2= 2*lr* delta2*H'; 2 95
W2 = W2+ del_W2;
delta1 = h.*(1-h).*(W2(:,2:hidden+1)'*delta2); 3 97
del_W1 = 2*lr*delta1*X';
W1 = W1+del_W1; 4 102
end;clf
semilogy(nonzeros(SSE)); 5 109
title('Backpropagation Training');
xlabel('Cycles');ylabel('Sum of Squared Error') 6 116
if i<200;fprintf('Error goal reached in %i cycles.',i);end

%Objetivo del Error alcanzado en 116 ciclos. 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
end
y = 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) Si la MLP es entrenada con valores
[y,meanval,stdval]=zscore(x) escalados, si entran nuevos valores a
x=
1 2 la red, estos deberán ser
30 21 normalizados con los mismos
-1 -10
8 34 parámetros del inicio.
y=
0.1516 0.3182
0.9000 0.6636
0.1000 0.1000
0.3323 0.9000
slope = 0.0258 0.0182
int = 0.1258 0.2818
y=
-0.5986 -0.4983
1.4436 0.4727
-0.7394 -1.1115
-0.1056 1.1370
meanval = 9.5000 11.7500
stdval = 14.2009 19.5683
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 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:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

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);
else
xn=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 ~= 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.

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

Esta red tiene: Bastaron 744 épocas para


1 neuronas de entrada conseguir el error RMS de 0.1
2 neuronas en la capa oculta
1 neuronas de salida
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 ENTRENADOS


x=[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 RED
plot(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:

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:

% programa para clasificar las letras A a la P:

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

a) Procedimiento usando modelo AR y distancia euclideana:

1. Grabar unas 10 veces cada una de las vocales


2. Extraer los modelos AR de orden 10
3. 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.
VOCALES: SERIES TEMPORALES Y ESPECTROS DE POTENCIA

Vocal a Vocal e Vocal i

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”

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


PROBABILISTIC NEURAL NETWORKS:

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.
PROBABILISTIC NEURAL NETWORKS:

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.
PROBABILISTIC NEURAL NETWORKS:

Grado de pertenencia a cada una de las dos clases:


EJEMPLO:

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

close all; clear all;clc


x=[-3 -2;-3 -3;-2 -2;-2 -3;3 2;3 3;2 2;2 3]; % Datos de entrenamiento
y=[1 1 1 1 2 2 2 2]'; % Salidas deseadas
xtest=[-.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;
PROBABILISTIC NEURAL NETWORKS:
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 cases


for 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.
end
PROBABILISTIC NEURAL NETWORKS:

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
PROBABILISTIC NEURAL NETWORKS:

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
Función gaussiana:

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

% Ancho de la funcion de base radial


width=6;

% Centro de los campos receptivos


w1=[-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;

figure
plot(test_x,[y_target yout]);
title('Red RBF: probando'); xlabel('Input'); ylabel('Output')
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

Vous aimerez peut-être aussi