Análisis Perceptrón

CTEDRA DE CONTROL INTELIGENTE
ANLISIS DE CONVERGENCIA DEL PERCEPTRN DE DOS CAPAS, USANDO COMO

MTODO DE APRENDIZAJE AL DESCENSO DE GRADIENTE
Realizado por David Espinosa y Diego Guffante
1. Objetivos
Usar al perceptrn de dos capas con descenso de gradientes como mtodo de
aprendizaje, verificar la convergencia de dicho algoritmo.
2. Introduccin
Partiendo de un algoritmo funcional del perceptrn de doble capa, que usa al descenso de
gradiente como mtodo de aprendizaje, se puede resolver un problema que no sea linealmente
separable. En publicaciones anteriores se escogi un ejemplo clsico, tal como la compuerta XOR.
No obstante, como un algoritmo iterativo puede eventualmente darse el caso de que la serie
escogida simplemente no converja, provocando errores elevados, o bucles infinitos.
En la presente publicacin se comparar entre diferentes repeticiones del experimento, para
mtodos ya aprendidos, as como nuevos mtodos.
3. Desarrollo
3.1. Para el algoritmo anteriormente realizado (Perceptrn de dos capas) modifique el
programa de manera que los valores iniciales (pesos) se originen de forma aleatoria.
Usar la funcin rand de MATLAB, y verificar la convergencia del algoritmo.
El problema propuesto (en funcin de una compuerta XOR), es:
En la ciudad de Quito, se estn realizando consultas a las parejas jvenes, con menos de 5 aos de
matrimonio. Con esta encuesta, se determinar si la pareja debe o no recibir una charla familiar. Las parejas
escogidas para recibir dicha charla sern aquellas en las que existe problemas debido a que el hombre piensa
diferente a la mujer. Por el contrario aquellas parejas en las que el pensamiento del hombre y la mujer es
similar no recibirn dicha conferencia. El ejemplo descrito guarda similitud con la siguiente tabla:
IN1
0
0
1
1
Donde la salida puede interpretarse as:
1
0
la pareja DEBE recibir la charla

la pareja NO DEBE recibir la charla.
IN2
0
1
0
1
TARGET
0
1
1
0
El algoritmo que se propone se indica a continuacin:

clc;clear all;
% entradas compuerta XOR (x1 y x2)
input = [0 0; 0 1; 1 0; 1 1];
% Salidas buscadas en la compuerta XOR (targets)
target = [0;1;1;0];
% Inicializando los thetas (W7, W8 y W9)
theta = [-1 -1 -1];
% Coeficiente de aprendizaje
n = 0.7;
alfa=1;
% Los pesos se inicializan de forma ALEATORIA
% Asegurando que sean diferentes aleatorios para diferentes sesiones de
% MATLAB [ rand('state',sum(100*clock)) ]
rand('state',sum(100*clock));
pesos = 5*(-1 +2.*rand(3,3));
u=1;error=0;errorbuscado=0.05;
while(u==1)
out = zeros(4,1);
numIn = length (input(:,1));
for j = 1:numIn
%-----------------------------------------------------------------------%
CAPA OCULTA
%-----------------------------------------------------------------------net1 = theta(1,1)*pesos(1,1)+ input(j,1)*pesos(1,2)+
input(j,2)*pesos(1,3);
%pesos(1,1)=-W7
%pesos(1,2)=W1
%pesos(1,3)=W4
x2(1) = (1/(1+exp(-alfa*net1))); %sigmoide(net1)
net2 =
theta(1,2)*pesos(2,1)+input(j,1)*pesos(2,2)+input(j,2)*pesos(2,3);
%pesos(2,1)=-W8
%pesos(2,2)=W4
%pesos(2,3)=W2
%-----------------------------------------------------------------------%
CAPA SALIDA
%-----------------------------------------------------------------------net3 = alfa*alfa*theta(1,3)*pesos(3,1)+
x2(1)*pesos(3,2)+x2(2)*pesos(3,3);
%pesos(1,3)=-W9
%pesos(2,3)=W5
%pesos(3,3)=W6
out(j) =(1/(1+exp(-alfa*net3))); %sigmoide(net3)=salida red
neuronal
% Ajuste de los incrementos para la capa de salida (net3)
% delta(wi) = xi*delta,
% delta = (1-salida actual)*(target - salida actual)
delta3_1 = alfa*alfa*out(j)*(1-out(j))*(target(j)-out(j));
% Ajuste de los incrementos para las capas ocultas

% El incremento final se obtiene al multiplicar deltas entre capas
% ocultas, y capa de salida (ver derivadas parciales)
delta2_1 = x2(1)*(1-x2(1))*pesos(3,2)*delta3_1;
% Sumar cambios de pesos a los pesos originales
% Y usar los nuevos pesos en una nueva iteracin
% delta weight = n*x*delta
for k = 1:3
if k == 1 % Casos de theta
pesos(1,k) = pesos(1,k) + n*theta(1,1)*delta2_1;
else % Cuando k=2 o 3, Casos de entradas a las neuronas
pesos(1,k) = pesos(1,k) + n*input(j,1)*delta2_1;
pesos(3,k) = pesos(3,k) + n*x2(k-1)*delta3_1;
end
end
end
% Verificacin de cumplimiento de la red neuronal: comparamos el
target
% con el output
for(m=1:4)
error=error+abs(target(m)-out(m))
end
% Clculo del error
if(error<errorbuscado)
u=0;
break;
else
error=0;
end
end
pesos
target
out
En este caso, la parte del programa
Es la que debera cumplir con la solicitud del presente literal. Ahora se comparar la convergencia
entre uno y otro experimento. Se usar un error de 0.1. Para el primer experimento se obtuvo el
siguiente resultado:
Para el segundo experimento se obtuvo el siguiente resultado:
Para el tercer experimento se obtuvo el siguiente resultado:
Recopilando la informacin:
# Experimento
Converge?
# epocas
1
Si
3846
2
Si
7663
3
SI
4317
Observndose que para tres experimentos, el algoritmo parece converger.
3.2. Modifique el programa anterior de tal manera que la tasa de aprendizaje evolucione
con las pocas y verifique la convergencia.
El programa propuesto es
clc;clear all;
input = [0 0; 0 1; 1 0; 1 1];
target = [0;1;1;0];
theta = [-1 -1 -1];
n0 = 10;n=10;
alfa=1;
% Los pesos se incializan de forma ALEATORIA
pesos = 1*(-1 +2.*rand(3,3));
u=1;error=0;errorbuscado=0.1;epoca=0;
while(u==1)
out = zeros(4,1);
epoca=epoca+1;
for j = 1:numIn
%-----------------------------------------------------------------------%
CAPA OCULTA
%pesos(1,1)=-W7
%pesos(1,2)=W1
%pesos(1,3)=W4
net2 =
%pesos(2,1)=-W8
%pesos(2,2)=W4
%pesos(2,3)=W2
%-----------------------------------------------------------------------%
CAPA SALIDA
x2(1)*pesos(3,2)+x2(2)*pesos(3,3);
%pesos(1,3)=-W9
%pesos(2,3)=W5
%pesos(3,3)=W6
neuronal

for k = 1:3
end
end
end
target
% con el output
for(m=1:4)
error=error+abs(target(m)-out(m));
end
x(epoca)=epoca;
y(epoca)=error;
% Clculo del error
u=0;
break;
else
error=0;
n=n0/(1+(epoca/10000))
end
end
target
out
epoca
plot(x,y)
La lnea:
n=n0/(1+(epoca/10000))
Es la que hace que la tasa de aprendizaje vare con la poca. Para una prueba:
En efecto se observa que se reduce el nmero de pocas a 313, lo que es aproximadamente la

dcima parte de las pocas para el mtodo anterior.
3.3. Compare la convergencia entre on-line y batch-training.

Hasta ahora, se ha realizado la actualizacin de pesos, con respecto a los deltas, para cada uno de
los patrones de entranamiento. Este mtodo se conoce como ON-LINE. El mtodo de BATCHTRAINING, propone calcular el incremento delta para todos los patrones de entrenamiento de una
sola vez, y actualizar cada uno de los pesos despus. El cdigo en MATLAB para BATCH-TRAINING
que se propone, es el siguiente:
MTODO DE BATCH TRAINING

clc;clear all;
input = [0 0; 0 1; 1 0; 1 1];
target = [0;1;1;0];
theta = [-1 -1 -1];
n0 = 10;n=10;
alfa=1;
pesos = 1*(-1 +2.*rand(3,3));
u=1;error=0;errorbuscado=0.1;epoca=0;i=1;
deltas=zeros(3,length(input(:,1)))
delta3_1=0;delta2_1=0;delta2_2=0;
while(u==1)
out = zeros(4,1);
epoca=epoca+1;
for j = 1:numIn
%-----------------------------------------------------------------------%
CAPA OCULTA
%pesos(1,1)=-W7
%pesos(1,2)=W1
%pesos(1,3)=W4
net2 =
%pesos(2,1)=-W8
%pesos(2,2)=W4
%pesos(2,3)=W2
%-----------------------------------------------------------------------%
CAPA SALIDA
x2(1)*pesos(3,2)+x2(2)*pesos(3,3);
%pesos(1,3)=-W9
%pesos(2,3)=W5
%pesos(3,3)=W6
neuronal
%Pesos usados para el siguiente patrn de entrenamiento
for k = 1:3
pesos(1,k) = pesos(1,k) +
else % Cuando k=2 o 3, Casos
end
n*theta(1,1)*delta2_1;
de entradas a las neuronas
n*input(j,1)*delta2_1;
n*x2(k-1)*delta3_1;
end
end
%ACTUALIZACIN DE PESOS FINALES FUERA DEL BUCLE
for k = 1:3
end
end
n*x2(k-1)*delta3_1;
% Verificacin de cumplimiento de la red neuronal: comparamos el target

% con el output
for(m=1:4)
end
x(epoca)=epoca;
y(epoca)=error;
% Clculo del error
u=0;
break;
else
error=0;
n=n0/(1+(epoca/10000));
end
end
target
out
epoca
plot(x,y)
Se observa que la evolucin es evidente, en cuanto al nmero de pocas. Ahora se indica al

programa original.
MTODO DE ON LINE
clc;clear all;
input = [0 0; 0 1; 1 0; 1 1];
target = [0;1;1;0];
theta = [-1 -1 -1];
n0 = 10;n=10;
alfa=1;
pesos = 1*(-1 +2.*rand(3,3));
u=1;error=0;errorbuscado=0.1;epoca=0;i=1;
deltas=zeros(3,length(input(:,1)))
delta3_1=0;delta2_1=0;delta2_2=0;
while(u==1)
out = zeros(4,1);
epoca=epoca+1;
for j = 1:numIn
%-----------------------------------------------------------------------%
CAPA OCULTA
%pesos(1,1)=-W7
%pesos(1,2)=W1
%pesos(1,3)=W4
net2 =
%pesos(2,1)=-W8
%pesos(2,2)=W4
%pesos(2,3)=W2
%-----------------------------------------------------------------------%
CAPA SALIDA
x2(1)*pesos(3,2)+x2(2)*pesos(3,3);
%pesos(1,3)=-W9
%pesos(2,3)=W5
%pesos(3,3)=W6
neuronal
for k = 1:3
end
end
n*x2(k-1)*delta3_1;
end
target
% con el output
for(m=1:4)
end
x(epoca)=epoca;
y(epoca)=error;
% Clculo del error
u=0;
break;
else
error=0;
n=n0/(1+(epoca/10000));
end
end
target
out
epoca
plot(x,y)
El resultado se lo ha obtenido en pginas anteriores.
Siendo las evoluciones comparables, en cuanto al nmero de pocas.
3.4. Compare la convergencia del algoritmo con otro que use una funcin de transferencia
alternativa.
Cambiaremos la funcin sigma, por la funcin sugerida:
Es necesario considerar que dado que esta funcin es diferente a la funcin sigmoide, y
obviamente, su derivada tambin es diferente, ser necesario modificar algunos parmetros en el
programa original. El programa modificado que se propone es:
clc;clear all;
input = [0 0; 0 1; 1 0; 1 1];
target = [0;1;1;0];
theta = [-1 -1 -1];
n0 = 10;n = 0.2;alfa = 1;
pesos = 1*(-1 +2.*rand(3,3));
u=1;error=0;errorbuscado=0.2;epoca=0;
while(u==1)
out = zeros(4,1);
epoca=epoca+1;
for j = 1:numIn
%-----------------------------------------------------------------------%
CAPA OCULTA
%pesos(1,1)=-W7
%pesos(1,2)=W1
%pesos(1,3)=W4
%
x2(1) = tanh(net1);
%nueva funcin de activacin
net2 =
%pesos(2,1)=-W8
%pesos(2,2)=W4
%pesos(2,3)=W2
%
x2(2) = tanh(net2);
%-----------------------------------------------------------------------%
CAPA SALIDA
%-----------------------------------------------------------------------net3 = theta(1,3)*pesos(3,1)+ x2(1)*pesos(3,2)+x2(2)*pesos(3,3);
%pesos(1,3)=-W9
%pesos(2,3)=W5
%pesos(3,3)=W6
%
neuronal
out(j)=tanh(net3);
%
%

delta3_1 = out(j)*(1-out(j))*(target(j)-out(j));
delta3_1 = (1-out(j)^2)*(target(j)-out(j));
delta2_1 = (1-x2(1)^2)*pesos(3,2)*delta3_1;
delta2_2 = (1-x2(2)^2)*pesos(3,3)*delta3_1;
for k = 1:3
end
end
end
target
% con el output
for(m=1:4)
end
x(epoca)=epoca;
y(epoca)=error;
% Clculo del error
u=0;
break;
else
error=0;
%n=n0/(1+(epoca/10000));
end
end
target
out
epoca
plot(x,y)
Se han dejado comentadas las lneas que usaban las sigmoides, de manera que se pueda avisorar
en donde se han realizado la modificacin. Se harn tres pruebas para comparar resultados.
Para el primer experimento se obtuvo el siguiente resultado:
Para el segundo experimento se obtuvo el siguiente resultado:
Para el tercer experimento se obtuvo el siguiente resultado:
Recopilando los experimentos realizados

# Experimento
1
2
3
Converge?
Si
Si
SI
# epocas
1371
594
292
4. Conclusiones
Como resultado del primer literal de este experimento, se ha corroborado la consistencia y
robustez del algoritmo del perceptrn de dos capas con descenso de gradiente. En tres
experimentos realizados, la convergencia se produjo en las tres ocasiones.
El segundo literal del experimento, demuestra que mejorar el factor de aprendizaje, con
respecto a la poca, optimiza el nmero de pocas, disminuyndola al 10% del nmero
total de pocas del experimento anterior.
El tercer experimento, compara los mtodos on-line y batch-training. Los resultados
muestran que la evolucin en cuanto a pocas es mejor, a pesar de que no se puede
compara entre uno y otro mtodos, debido a la caracterstica aleatoria de los pesos, al
principio del programa.
El ltimo experimento indica que la variacin de la funcin de activacin, conlleva el
modificar al programa como tal. No obstante, los resultados obtenidos son comparables (y
de hecho, mejores en algunos casos) que los resultados obtenidos con la sigmoide como
seal de activacin.

Análisis Perceptrón

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Análisis Perceptrón

Hochgeladen von

Copyright:

Verfügbare Formate

CTEDRA DE CONTROL INTELIGENTE

ANLISIS DE CONVERGENCIA DEL PERCEPTRN DE DOS CAPAS, USANDO COMO

la pareja DEBE recibir la charla

El algoritmo que se propone se indica a continuacin:

% Ajuste de los incrementos para las capas ocultas

En este caso, la parte del programa

Para el segundo experimento se obtuvo el siguiente resultado:

Para el tercer experimento se obtuvo el siguiente resultado:

% Ajuste de los incrementos para la capa de salida (net3)

En efecto se observa que se reduce el nmero de pocas a 313, lo que es aproximadamente la

3.3. Compare la convergencia entre on-line y batch-training.

MTODO DE BATCH TRAINING

% Verificacin de cumplimiento de la red neuronal: comparamos el target

Se observa que la evolucin es evidente, en cuanto al nmero de pocas. Ahora se indica al

El resultado se lo ha obtenido en pginas anteriores.

Siendo las evoluciones comparables, en cuanto al nmero de pocas.

% Ajuste de los incrementos para la capa de salida (net3)

Para el segundo experimento se obtuvo el siguiente resultado:

Para el tercer experimento se obtuvo el siguiente resultado:

Recopilando los experimentos realizados

Das könnte Ihnen auch gefallen