Beruflich Dokumente
Kultur Dokumente
El Perceptron de Múltiples Capas es una RNA que tiene “n” capas con “s” neuronas,
cada neurona se alimenta de múltiples entradas y bias, la función de activación de
esta(Denominaremos a el Perceptron Múltiples Capas como MLP) MLP que puede
utilizar están entre las señales lineales y no lineales, en el caso de que la regla de
aprendizaje requiera calcular la derivada de una dicha función será necesario usar
señales que sean continuas y diferenciables.
Una MLP tiene diferentes capas, he de ahí el nombre, estas capas pasaran a ser
llamadas:
Funciones de la Red
𝑎0 = 𝑃
Aprendizaje
𝑓̇ 𝑚 (𝑛1𝑚 ) 0 0
𝑓̇ 𝑚 (𝑛𝑠𝑚 ) = [ 0 𝑓̇ 𝑚 (𝑛2𝑚 ) 0 ]
0 0 𝑓̇ 𝑚 (𝑛𝑠𝑚𝑚 )
𝜕𝑓 𝑚 (𝑛𝑗𝑚 )
𝑓 ̇𝑚 (𝑛𝑗𝑚 ) =
𝜕(𝑛𝑗𝑚 )
𝑊 𝑚 (𝑘 + 1) = 𝑊 𝑚 (𝑘)− ∝ 𝑆 𝑚 (𝑎𝑚−1 )𝑇
𝑏(𝑘 + 1) = 𝑏(𝑘)−∝ 𝑆 𝑚
𝑒 = (𝑡 𝑗 − 𝑎 𝑗 )2
No---- 0.0510
No---- 0.4239
No---- 0.0496
No---- 0.2721
No---- 0.0468
No---- 0.1640
No---- 0.0428
No---- 0.0904
No---- 0.0380
No---- 0.0432
No---- 0.0328
No---- 0.0158
No---- 0.0276
Si---- 0.0029
No---- 0.0225
Si---- 5.8023e-05
No---- 0.0178
Si---- 0.0037
No---- 0.0136
No---- 0.0110
No---- 0.0101
No---- 0.0199
Si---- 0.0072
No---- 0.0290
Si---- 0.0049
No---- 0.0371
Si---- 0.0031
No---- 0.0436
Si---- 0.0019
No---- 0.0481
Si---- 0.0011
Si---- 5.1431e-04
Si---- 5.1596e-04
Si---- 3.1564e-04
Si---- 2.0241e-04
Si---- 1.3235e-04
Si---- 4.7929e-05
Si---- 1.4687e-05
Si---- 4.4097e-07
Si---- 2.7977e-05
Si---- 2.2161e-05
Si---- 2.5215e-04
Si---- 8.7431e-05
Si---- 7.8038e-04
Si---- 1.7979e-04
Si---- 0.0017
Si---- 2.8893e-04
Si---- 0.0032
Si---- 4.0796e-04
Si---- 0.0053
Si---- 5.3112e-04
Si---- 0.0081
Si---- 6.5220e-04
No---- 0.0118
Si---- 7.6350e-04
No---- 0.0165
Si---- 8.5562e-04
No---- 0.0222
Si---- 9.1787e-04
No---- 0.0290
Si---- 9.3950e-04
No---- 0.0369
Si---- 9.1144e-04
No---- 0.0459
Si---- 8.2867e-04
No---- 0.0560
Si---- 6.9272e-04
No---- 0.0671
No---- 0.0791 No---- 0.1439
En el caso de la MLP con 100 datos se puede observar que a medida que se pongan
más iteraciones el error ira disminuyendo gracias al aprendizaje, si es cierto que en
un punto el aprendizaje se estanque por “n” razón se tiene a earlystopping para
impedir esto, en especial esa señal al ponerle 3000 iteraciones se asemeja mucho,
es tardado pero es bueno saber que la MLP funciona correctamente, en caso de los
1000 datos, es una cantidad de datos gigantescos, yo mismo probé con 8000
iteraciones y los valores de salida se movían muy poco y la señal de salida no se
movía para nada, así que deduzco que se necesita una cantidad de iteraciones
bestial para poder llevar a cabo ese aprendizaje(o utilizar un alpha un poco más
grande), en caso de la señal de 200 datos(seno de -1 a 1) se puede visualizar que
el aprendizaje es uno de los más correctos que se tienen ya que las dos señales
graficadas parasen una misma y solo varia por algunos datos en un error marcado
por el usuario(En ese caso 0.05).
En todos los casos a medida que se cambiaban los alpha pude observar que si se
pone un alpha muy grande el error se dispara a infinito y la red neuronal queda en
un bucle en el cual los valores de salida, por obvias razones, tienden a infinito. Para
esta red hay que tener mucho cuidado tanto en las iteraciones como lo es en en
alpha ya que es como que la columna para que el aprendizaje se limite a ser
pequeño o grande.
Conclusiones
Al principio pensé que era una práctica sencilla, simple, trivial; que solo se
programaba en 3 días, pero no fue así, desde el primer día que la pidió la empecé
a programar y créame han sido las 3 semanas más largas de mi vida, no me
quedaba por razones que desconocía, simplemente me odiaba mi propio
programa. A pasar las semanas sufría de una desesperación constante y me
sumergí en una idea de no poder hacerlo, sinceramente la practica fue frustrante,
a tal grado de solo poder entregar 3 de 4 partes que se requerían. Finalmente, ya
cuando “creo” que salió es como que un alivio pensar que todo el tiempo invertido
valió para algo.
[2]Neural Networks Design/ Hagan T. Martin, Demuth B. Howard, Beale Mark -2en
ed.
Apéndice
%Luna Reyes Brandon Manuel
format short
clear
clc
fprintf('____________________________________________');
fprintf('\n-------------------MLP----------------------');
fprintf('\n___________________________________________');
fprintf('\n');
iteraciones=1;
errorayuda=0;
mayorval=0;
deten=false;
yes=1;
yes2=1;
arquitectura=input('\nIngresa la arquitectura:');
[l,m]=size(arquitectura);
funciones=input('Ingresa las funciones(1-Logsig|2-Purelin|3-Tansig)
:');
[l2,m2]=size(funciones);
archivo=input('Ingrese el nombre del archivo:','s');
datos=importdata(archivo);
[l3,m3]=size(datos);
erapre=input('Ingrese el error de aprendizaje:');
itmax=input('Ingrese la iteracion maxima:');
itval=input('Ingrese la frecuencia de la iteracion de validacion:');
maxval=input('Ingrese los incrementos consecutivos para validacion:');
alpha=input('Ingrese el factor de aprendizaje:');
sprintf('Seleccione que porcentaje de datos para los conjuntos:');
fprintf('\n 1) 80-10-10');
fprintf('\n 2) 70-15-15');
porcentaje=input('\nEleccion:');
fprintf('\n');
celdas=cell(m-1,1);
%Separacion de datos
switch porcentaje
case 1
separar=[80,10,10];
case 2
separar=[70,15,15];
end
%Separacion de target y datos de entrada
target=datos(:,2);
a=datos(:,1);
a2=datos;
[ay,ay2]=size(a2);
%Aprendizaje Calculos
aprendizaje=zeros(ay*80/100,m3);
[apr,anp]=size(aprendizaje);
prueba=zeros(ay*separar(2)/100,m3);
[pru,pra]=size(prueba);
validacion=zeros(ay*separar(3)/100,m3);
[val,vaa]=size(validacion);
for ma=1:3
i2=1;
while i2<(ay*separar(ma)/100)+1
x=(round(rand*(l3-1)+1));
switch ma
case 1
if a2(x)~=-10
aprendizaje(i2,1)=a2(x,1);
aprendizaje(i2,2)=a2(x,2);
a2(x,1)=-10;
a2(x,2)=-10;
i2=i2+1;
end
case 2
if a2(x)~=-10
validacion(i2,1)=a2(x,1);
validacion(i2,2)=a2(x,2);
a2(x,1)=-10;
a2(x,2)=-10;
i2=i2+1;
end
case 3
if a2(x)~=-10
prueba(i2,1)=a2(x,1);
prueba(i2,2)=a2(x,2);
a2(x,1)=-10;
a2(x,2)=-10;
i2=i2+1;
end
end
end
end
%Calculo de los valores de Pesos y Bias
for i=1:m
for j=1:2
if i~=m
pesos=zeros(arquitectura(i+1),arquitectura(i));
bias=zeros(arquitectura(i+1),1);
for l=1:arquitectura(i+1)
bias(l,1)=rand;
for k=1:arquitectura(i)
pesos(l,k)=rand;
end
end
if j==1
celdas{i,j}=pesos;
else
celdas{i,j}=bias;
end
end
end
end
%Separacion de pesos y bias en celdas
pesosm=celdas(:,1);
biasm=celdas(:,2);
%Celda para los valores de salida
salidas=cell(1,m-1);
%Matrices para las reglas
s=cell(m2,1);
%Propagacion hacia delante
while iteraciones<itmax && mayorval<maxval
errorayuda=0;
if (rem(iteraciones,itval))>0
yes=1;
yes3=1;
yes4=1;
yes5=1;
for j=1:apr
for i=1:m2
if i==1
switch funciones(i)
case 1
salidas{j,i}=logsig((pesosm{i,1}*aprendizaje(j))+biasm{i,1});
case 2
salidas{j,i}=purelin((pesosm{i,1}*aprendizaje(j))+biasm{i,1});
case 3
salidas{j,i}=tansig((pesosm{i,1}*aprendizaje(j))+biasm{i,1});
end
else
%Si falla checar la transpuesta del biasm
switch funciones(i)
case 1
salidas{j,i}=logsig((pesosm{i,1}*salidas{j,i-
1})+biasm{i,1});
case 2
salidas{j,i}=purelin((pesosm{i,1}*salidas{j,i-
1})+biasm{i,1});
case 3
salidas{j,i}=tansig((pesosm{i,1}*salidas{j,i-
1})+biasm{i,1});
end
end
end
%Calculo de error
preerror=(aprendizaje(j,2)-salidas{j,m2});
finerror=preerror^2;
%Comparacion con el target
if salidas{j,m2}==aprendizaje(j,2) || finerror<erapre
fprintf('\nSi');
disp(finerror);
yes=yes+1;
else
fprintf('\nNo');
disp(finerror);
%Inicia Aprendizaje
%Calculo de las matrices derivadas
deriva=cell(1,m2);
mhelp=m2;
while mhelp>=1
derivada=zeros(arquitectura(mhelp+1));
[la,an]=size(derivada);
ayuda=salidas{j,mhelp};
for k=1:la
for k2=1:an
if k==k2
switch funciones(mhelp)
case 1
derivada(k,k2)=(logsig(ayuda(k2,1))*(1-
logsig(ayuda(k2,1))));
case 2
derivada(k,k2)=1;
case 3
derivada(k,k2)=(1-
(tansig(ayuda(k2,1))^2));
end
else
derivada(k,k2)=0;
end
end
end
deriva{1,mhelp}=derivada;
%Calculo de las sensibilidades
if mhelp==m2
s{mhelp}=-2*deriva{1,mhelp}*preerror;
else
s{mhelp}=deriva{1,mhelp}*pesosm{mhelp+1,1}'*s{mhelp+1};
end
%Calculo de el aprendizaje
if mhelp==1
pesosm{mhelp,1}=pesosm{mhelp,1}-
(alpha*(s{mhelp}))*aprendizaje(j)';
biasm{mhelp,1}=biasm{mhelp,1}-(alpha*(s{mhelp}));
else
pesosm{mhelp,1}=pesosm{mhelp,1}-
(alpha*(s{mhelp}))*salidas{1,mhelp-1}';
biasm{mhelp,1}=biasm{mhelp,1}-alpha*(s{mhelp});
end
mhelp=mhelp-1;
end
end
end
if yes==apr+1
break;
end
iteraciones=iteraciones+1;
%Final de iteraciones de apprendizaje
else
errorayuda=0;
fprintf('Iteracion de validacion');
for j=1:val
for i=1:m2
if i==1
switch funciones(i)
case 1
salidas{j+apr,i}=logsig((pesosm{i,1}*validacion(j))+biasm{i,1});
case 2
salidas{j+apr,i}=purelin((pesosm{i,1}*validacion(j))+biasm{i,1});
case 3
salidas{j+apr,i}=tansig((pesosm{i,1}*validacion(j))+biasm{i,1});
end
else
%Si falla checar la transpuesta del biasm
switch funciones(i)
case 1
salidas{j+apr,i}=logsig((pesosm{i,1}*salidas{j+apr,i-
1})+biasm{i,1});
case 2
salidas{j+apr,i}=purelin((pesosm{i,1}*salidas{j+apr,i-
1})+biasm{i,1});
case 3
salidas{j+apr,i}=tansig((pesosm{i,1}*salidas{j+apr,i-
1})+biasm{i,1});
end
end
end
%Calculo de error
preerror=(validacion(j,2)-salidas{j+apr,m2});
finerror=preerror^2;
salidas{j+(apr+val),i}=logsig((pesosm{i,1}*a(j))+biasm{i,1});
case 2
salidas{j+(apr+val),i}=purelin((pesosm{i,1}*a(j))+biasm{i,1});
case 3
salidas{j+(apr+val),i}=tansig((pesosm{i,1}*a(j))+biasm{i,1});
end
else
%Si falla checar la transpuesta del biasm
switch funciones(i)
case 1
salidas{j+(apr+val),i}=logsig((pesosm{i,1}*salidas{j+(apr+val),i-
1})+biasm{i,1});
case 2
salidas{j+(apr+val),i}=purelin((pesosm{i,1}*salidas{j+(apr+val),i-
1})+biasm{i,1});
case 3
salidas{j+(apr+val),i}=tansig((pesosm{i,1}*salidas{j+(apr+val),i-
1})+biasm{i,1});
end
end
end
%Calculo de error
preerror=(prueba(j,2)-salidas{j+(apr+val),m2});
finerror=preerror^2;
%Comparacion con el target
if salidas{j+(apr+val),m2}==prueba(j,2) || finerror<erapre
fprintf('\nSi');
fprintf('---->');
disp(finerror);
yes5=yes5+1;
else
fprintf('\nNo');
fprintf('---->');
disp(finerror);
end
end
end
end
salidas2=cell(1,m-1);
fprintf('\nIteracion de prueba adicional');
for j=1:l3
for i=1:m2
if i==1
switch funciones(i)
case 1
salidas2{j,i}=logsig((pesosm{i,1}*a(j))+biasm{i,1});
case 2
salidas2{j,i}=purelin((pesosm{i,1}*a(j))+biasm{i,1});
case 3
salidas2{j,i}=tansig((pesosm{i,1}*a(j))+biasm{i,1});
end
else
%Si falla checar la transpuesta del biasm
switch funciones(i)
case 1
salidas2{j,i}=logsig((pesosm{i,1}*salidas2{j,i-
1})+biasm{i,1});
case 2
salidas2{j,i}=purelin((pesosm{i,1}*salidas2{j,i-
1})+biasm{i,1});
case 3
salidas2{j,i}=tansig((pesosm{i,1}*salidas2{j,i-
1})+biasm{i,1});
end
end
end
%Calculo de error
preerror=(datos(j,2)-salidas2{j,m2});
finerror=preerror^2;
%Comparacion con el target
if salidas2{j,m2}==datos(j,2) || finerror<erapre
fprintf('\nSi');
fprintf('----');
disp(finerror);
yes4=yes4+1;
else
fprintf('\nNo');
fprintf('----');
disp(finerror);
end
end
if deten==true
fprintf('Se ha detenido por EarlyStopping');
end
if yes==apr+1
fprintf('Se tenido un aprendizaje exitoso');
end
if iteraciones==itmax
fprintf('La red no aprendio lo suficiente');
end