Instituto Politecnico Nacional

Escuela Superior de Computo

Neural Networks

Perceptrn Multicapa MLP

Reporte practica 4

Grupo: 3CM2
Alejandro Hernandez Gomez
Introduccin
En el presente reporte expondr de manera sencilla y concisa el funcionamiento, as como el
entrenamiento de un Perceptrn multicapa. Tomando 2 archivos con la informacin respectiva de
datos de ingreso (input.txt) y targets (target.txt) se pretende hacer funcionar la red para un rango
de una seal con una arquitectura de dos vectores v1[1 s1 s2 s3 1] y v2[2 3 2 1] (donde v2 tomar
sus valores de 1.- purelin; 2.- logsig; 3.- tansig;).

Se requiere que el usuario ingrese los datos s1, s2, s3, el valor del factor de aprendizaje, las
condiciones de finalizacin y el subconjunto de datos que se usar (80-10-10 / 70-15-15).

El perceptrn multicapa deber ser capaz de entrenar, probar y verificar los datos tal cual lo
especifica su definicin.

Al final de este documento se mostrar su funcionamiento y los resultados obtenidos en forma de

una seal a la cual queremos aproximarnos; poniendo as, en contraste, los datos de
entrenamiento, de prueba y verificacin.

Marco terico
El perceptrn simple y la neurona biolgica
El sistema nervioso est compuesto por millones de neuronas conectadas y organizadas
interactuando entre s. Las neuronas componen procesadores biolgicos de informacin sencilla
que en conjunto de todas estas, nuestro sistema puede procesar grandes cantidades de
informacin en tiempos muy reducidos. Gracias al estudio de las neuronas biolgicas los cientficos
pudieron crear una simulacin virtual de la misma; con esto y las aportaciones al rea comenzaron
a crearse modelos que solventan diferentes problemticas ms fcilmente unas que otras.

Figura 1: Ejemplo grfico de una neurona

El Perceptrn simple es un modelo neuronal introducido en 1959, desarrollado por
Frank Rosenblatt, y puede entenderse como una neurona artificial o una unidad bsica de
inferencia.

La importancia del perceptrn simple radica en el hecho de su carcter entrenable, ya que el

algoritmo introducido por Rosenblatt (1962) permite que el perceptrn simple determine
automticamente los pesos sinpticos que clasifican un conjunto de patrones etiquetados.

El algoritmo de aprendizaje del perceptrn simple pertenece al grupo de los algoritmos que se
fundamentan en la correccin de errores. Los algoritmos de este tipo ajustan los pesos de manera
proporcional a la diferencia existente entre la salida actual de la red neuronal y la salida deseada,
con el objetivo de minimizar el error actual de la red

Aun as existen limitaciones que hacen que no sea una herramienta perfecta en sencillez y
funcionalidad.

Figura 2: Ejemplo de clasificacin de perceptrn simple en funcionamiento con Matlab

El perceptrn simple y sus limitaciones

El perceptrn simple presenta grandes limitaciones, ya que tan solo es capaz de representar
funciones linealmente separables. Basndose en este hecho, Minsky y Papert (1969) publicaron un
trabajo exponiendo las limitaciones del perceptrn simple, como consecuencia del cual muchos de
los recursos que se venan dedicando a las redes neuronales se desviaron a otros campos de la
inteligencia artificial. El principal argumento de su desprestigio es el caso de la compuerta XOR
donde sus elementos estn linealmente separados y por lo tanto no es posible clasificarlo de la
manera tradicional pues sus fronteras de decisin convergen entre s.
La era del perceptrn multicapa
La manera ms comn de solucionar las limitaciones del perceptrn simple es por medio del uso e
inclusin de capas ocultas dndole mayor capacidad y un nuevo nombre: El perceptrn multicapa
o MLP (Multi-Layer Perceptron).

Ya que en 1969, Minsky y Papert, demuestran que el perceptrn simple y ADALINE no puede
resolver problemas no lineales surge la necesidad de la creacin de una nueva red que no tenga
estos problemas, la combinacin de varios perceptrones simples podra resolver ciertos problemas
no lineales pero no exista un mecanismo automtico para adaptar los pesos de la capa oculta.

Rumelhart y otros autores, en 1986, presentan la "Regla Delta Generalizada" para adaptar los
pesos propagando los errores hacia atrs haciendo uso del backpropagation. De esta forma se
consigue trabajar con mltiples capas y con funciones de activacin no lineales.

Un perceptrn multicapa puede aproximar relaciones no lineales entre los datos de entrada y
salida. Esta red se ha convertido en una de las arquitecturas ms utilizadas en el momento. El
perceptrn multicapa o MLP se suele entrenar por medio de un algoritmo de retropropagacin de
errores o BP (Backpropagation).

El perceptrn multicapa (de aqu en adelante MLP, MultiLayer Perceptron) se utiliza para resolver
problemas de asociacin de patrones, segmentacin de imgenes, compresin de datos,
aproximacin de seales etc.

Feedforward o algoritmo de propagacin hacia adelante

Describe un tipo de sistema que reacciona a los cambios en su entorno, normalmente para
mantener algn estado concreto del sistema. Un sistema que exhibe este tipo de comportamiento
responde a las alteraciones de manera predefinida.

En redes neuronales, la propagacin hacia adelante consiste en que las salidas de las neuronas van
a las siguientes capas, pero no a las anteriores, de modo que no hay bucles de retroalimentacin.
Pasando as los conjuntos de entrenamiento para que la siguiente neurona pueda partir del
resultado anterior obtenido.

Figura 3: Ejemplo de arquitectura Feedfoward

Backpropagation o algoritmo de propagacin hacia atrs
La propagacin hacia atrs de errores o retropropagacin o backpropagation (BP) es un algoritmo
de aprendizaje supervisado para RNA que emplea una propagacin de dos fases que usa la
entrada de la red como estmulo para su funcionamiento, propagndolo hacia la primera capa
desde las consiguientes hasta que se genera una salida. La salida obtenida por el algoritmo se
compara con el target y a partir de dicha comparacin se calcula el error para cada una de las
salidas.

Figura 4: Arquitectura de una red BP. Figura rescatada de

(es.slideshare.net/jcbp_peru/utp-20152ias6adaline-y-backpropagation)

Los errores obtenidos son propagados hacia atrs desde la ultima capa, hacia las neuronas de las
capas ocultas para que puedan ser aprovechados por estas y puedan generar una aportacin hacia
la mejora de las salidas. El proceso se repite por todas las capas hasta que todas las neuronas de la
red hayan obtenido el error y contribuyan a los resultados.

A medida que se entrena la red, las capas se organizan a si mismas de forma que cada neurona
reconoce caractersticas diferentes de la entrada y salida de la red.
Funciones de activacin
En este segmento trataremos a las funciones de activacin disponibles para crear nuestro MLP en
esta ocasin. La informacin, as como las imgenes, a continuacin mostradas fueron extradas
de la pgina web del manual de referencia de Matlab.

Funciones sigmoides
En general, una funcin sigmoide es una funcin real de variable real diferenciable, de la
forma general:
Y = 1 / (1+e^(-x))

Tiene tambin dos asntotas horizontales:

Lim (x -> - inf.) 1 / (1+e^(-x)) = 0
Lim (x -> + inf.) 1 / (1+e^(-x)) = 1

con una primera derivada no-negativa

y = dy/dx = e^(-x) / (1+ e^(-x))^2

La funcin sigmoide tiene una derivada simple:

y = y(1-y)

Tiene un punto de inflexin: x=0

Tansig
Matematicamente tansig es el equivalente de la tangente hiperblica tanh(x), Los valores
resultantes por tansig estn contenidos en un rango de -1 a 1
a = tansig(n) = 2/(1+exp(-2*n))-1
a = tansig(n) = (1-a^2)
 Figura 5: Funcin de activacin tansig.

Logsig
Los valores resultantes por logsig siempre estn contenidos en un rango de 0 a 1
a = logsig(n) = 1 / (1 + exp(-n))
a = logsig(n) = (1-a)(a)

Figura 6: Funcin de activacin logsig.

Purelin
Los valores resultantes por logsig siempre estn contenidos en un rango de -inf a inf pues en esta
funcin de activacin la entrada es la salida.
a = purelin(n) = n
a = purelin(n) = 1

Figura 7: Funcin de activacin purelin.

Comprensin de datos [Segmento tomado de esacademic.com]
Considerese un MLP de 3 capas, una de entrada, una oculta y la de salida. La capa de entrada est
formada por N neuronas, la capa oculta por M (M < N) neuronas y la capa de salida posee N
neuronas al igual que la capa de entrada. Se entrena dicho MLP para que cuando se le d como
entrada un vector de datos (x1, x2,..., xN) devuelva ese mismo vector con M datos como salida,
con ello estamos enseando al MLP a transformar un vector de N componentes en uno de M
componentes (recordemos que M < N) y a recuperar el vector original a partir del vector
"comprimido".

Una vez que el MLP est entrenado se procede de la siguiente forma:

Compresin: Para comprimir los datos utilizamos un MLP de dos capas, la de entrada con N
neuronas y la de salida con M, los pesos de estas dos capas son los de la capa de entrada y oculta
respectivamente, del MLP que entrenamos anteriormente.

Descompresin: Para descomprimir los datos utilizamos un MLP de dos capas, la de entrada con M
neuronas y la de salida con N, los pesos de estas dos capas son los de la capa oculta y la de salida
respectivamente, del MLP que entrenamos anteriormente.

El MLP no conseguir (al menos normalmente) un error nulo durante el entrenamiento, por lo que
se trata de un sistema de compresin con prdidas. Obviamente cuanto mayor queramos que sea
el factor de compresin, ms error se cometer.

Algoritmo del perceptrn multicapa MLP

1. Se solicita al usuario la siguiente informacin:
a. Los archivos de input.txt y target.txt
b. El rango de la seal. Ej: [-2 2]
c. La arquitectura de 2 vectores
i. V1 [1 s1 s2 s3 1] Aproximacion de seales
ii. V2 [2 3 2 1] 1. purelin 2. logsig 3. tansig
d. Valor del factor de aprendizaje
e. Condiciones de finalizacin (convergencia con la seal)
i. Numero mximo de iteraciones/poca (itmax)
ii. Valor minimo del error de entrenamiento en una iteracin (Eit)
iii. Valor de cada cuantas iteraciones se va a realizar una validacin (itval)
iv. Numero de incrementos consecutivos del error de validacin (numval)
f. El conjunto de datos se divide en 3 subconjuntos entre entrenamiento, validacin
y pruebas. El usuario debe elegir de entre dos conjuntos [80 10 10] o [70 15 15]
2. Se inicializan con valores aleatorios entre -1 y 1 todos los pesos y bias del MLP
3. Dado un valor de iteracin (it) se verifica si es igual o mltiplo de itval, si es asi se hace una
iteracin de validacion. It comienza en 1.
 a. La iteracin de entrenamiento consiste en propagar hacia adelante cada uno de
los datos del subconjunto de entrenamiento y realiza el aprendizaje. Al final se
calcula Eaprendizaje.
b. En la iteracin de validacin (itval), se toman los valores de pesos y bias de la
iteracin anterior y se fijan para propagar hacia adelante todos los datos del
subconjunto de validacin. Al final se calcula Evalidacion
c. Para el caso de la iteracin de validacin se debe verificar si este error tiene un
valor mayor al error de validacin anterior y si es asi se aumenta en uno el
contador de incrementos consecutivos, si este contador es igual a numval, se
detiene el aprendizaje y se pasa a realizar el calculo con el conjunto de prueba.
d. Contval es un contador de aumentos en el error de validacin, cada error que
crece respecto al anterior aumenta en uno el contador, en caso contrario regresa
a 0. Este error tiende a ser mayor al de entrenamiento.
4. El paso 3 se repite hasta que se cumpla alguna condicin de finalizacin (earlystopping,
itmax, eap<eit)
5. Una vez terminada la fase de aprendizaje se toman los valores dinales de los pesos y bias y
se usan para propagar hacia adelante los datos del conjunto de prueba. Se calcula el error
de prueba y se grafican estos puntos.
6. Presentacin de resultados
a. En pantalla se muestra el valor final de los errores: Eap, Eval, Ep.
b. Las siguientes graficas del MLP
i. Una grafica de evolucin de pesos
ii. Una grafica de evolucin de bias
iii. Una grafica de evolucin del error de entrenamiento y error de validacin
iv. Una grafica de los puntos deseados del conjunto de prueba vs la salida del
mlp
v. Archivos con los valores finales de pesos y bias en cada capa.
Diagrama de flujo del perceptrn multicapa MLP
Manejo e interpretacin de los vectores de arquitectura
Para representar la arquitectura de una red neuronal multicapa, siendo en este caso el perceptrn
multicapa, se usa la notacin de 2 vectores.

Vector 1 [R S1 S2 S3 SM]

Vector 2 [F1 F1 F3 FM]

Donde

R es la dimencion del vector de entrada P

SM es el numero de neuronas en cada capa
FM es el tipo de funcin de activacin de cada capa
M es el numero de capas en la RNA

Capa 1

a1 = F1(w1 * a0 + b1)

w1 = S1xR a0 = Rx1 b1 = S1x1

Capa 2

a2 = F2(w2 * a1 + b2)

w2 = S2xS1 a1 = S1x1 b2 = S2x1

Capa 3

a3 = F3(w3 * a2 + b3)

w3 = S3xS2 a2 = S2x1 b3 = S3x1

Ejemplos del MLP
La eleccin de la arquitectura del MLP

En general, no podemos decir cuantas capas y cuantas neuronas en las capas ocultas son
necesarias para el adecuado comportamiento del MLP. A continuacin se vera un par de ejemplos
para analizar y resolver este problema.

Para el primer ejemplo se desea usar un MLP para aproximar la siguiente funcin

Usando los conjuntos de datos [80 0 20]

Usando la arquitectura V1 [1 3 1] y V2 [2 1]
G(p) = 1+sin((i * pi * p)/ 4)
Para el rango de p [-2 2]
Se tomarn los siguientes valores para i: 1,2,4,8.

A medida que i aumenta se tendr mayor nmero de periodos de la seal en el rango dado. Esto
har ms difcil la aproximacin de la MLP si tiene un tamao fijo.
Para el segundo ejemplo se desea usar un MLP para aproximar la siguiente funcin

Usando los conjuntos de datos [80 0 20]

Usando la arquitectura V1 [1 S2 1] y V2 [2 1]
S2 variar de 2 a 5
G(p) = 1+sin((6 * pi * p)/ 4)
Para el rango de p [-2 2]

El objetivo ser incrementar el numero de neuronas en la capa oculta para lograr la correcta
aproximacin de esta seal.
Resultados experimentales
Ejemplo 1: Archivo 03-Polinomio_entrada_y_target.txt
Introduzca el archivo de prototipos y targets: 'Funciones/Polinomio.txt'
>> El archivo "Funciones/Polinomio.txt" se carg correctamente

Tomando en cuenta que [aprendiaje validacion pruebas]

1.[75% 15% 15%]
2.[80% 10% 10%]
Elija la opcion de distribucin deseada: 2
>> Conjunto de datos elegido [80 10 10]

Cuntos valores tiene el vector de la arquitectura?: 4

Nmero de entradas de la RNA: 1
Neuronas en la capa 1: 3
Neuronas en la capa 2: 2
Neuronas en la capa 3: 1
>> Vector de arquitectura elegido: [1 3 2 1]

Tomando en cuenta que:

1. purelin(n)
2. logsig(n)
3. tansig(n)
Elija la funcion de activacion para cada capa:
Funcin de activacin 1: 3
Funcin de activacin 2: 2
Funcin de activacin 3: 1
>> Vector de arquitectura 2 elegido: [3 2 1]

Porfavor ingrese los parametros del MLP:

Ingrese el valor mnimo del error de iteracin (eit): .0001
Ingrese el factor de aprendizaje (alpha): .2
Ingrese el nmero de iteraciones mximas (itmax): 1000
Ingrese la frecuencia en la que se validar (pval): 40
Ingrese el maximo de aumentos en validacin (maxval): 3

>> Iniciando el entrenamiento, porfavor espere...

>> CRITERIO DE PARO: Nmero mximo de incrementos consecutivos alcanzado
>> Tiempo de ejecucin: 383717636032.000000
>> Graficando datos, porfavor espere..

Comportamiento de los pesos en la capa 1

Comportamiento de los pesos en la capa 2

Comportamiento de los pesos en la capa 3

Grafica de evolucion de errores

Resultados
Archivo Resultados.txt para el ejemplo 1
Archivo ingresado: Funciones/Polinomio.txt

Arquitectura del MLP: [ 1 3 2 1 ] [ 3 2 1 ]

Eit: 0.000100
alpha: 0.200000
itmax: 1000
pval: 30
maxval: 3

>> CRITERIO DE PARO: Nmero mximo de incrementos consecutivos alcanzado

en la iteracin 300
>>Tiempo de ejecucin: 388063736695.000000

Vector de pesos W1
0.629056 0.188776
1.083065 0.046764
0.905792 -0.421023

Vector de bias 1
-1.585009
-1.951896
-2.117844

Vector de pesos W2
0.900952 1.664482 1.838800
0.809886 1.057140 1.659111

Vector de bias 2
-0.918204
-0.590758

Vector de pesos W3
-1.094259 -0.143143

Vector de bias 3
0.193343

Ejemplo 2: seal cuadrada square(5x);

Generamos un archivo de prototipos y targets con el generador de funciones GeneradorDatos.m

Introduzca el archivo de prototipos y targets: 'Funciones/square.txt'

>> El archivo "Funciones/square.txt" se carg correctamente

Tomando en cuenta que [aprendiaje validacion pruebas]

1.[75% 15% 15%]
2.[80% 10% 10%]
Elija la opcion de distribucin deseada: 2
>> Conjunto de datos elegido [80 10 10]
Cuntos valores tiene el vector de la arquitectura?: 3
Nmero de entradas de la RNA: 1
Neuronas en la capa 1: 3
Neuronas en la capa 2: 1
>> Vector de arquitectura elegido: [1 3 1]

Tomando en cuenta que:

1. purelin(n)
2. logsig(n)
3. tansig(n)
Elija la funcion de activacion para cada capa:
Funcin de activacin 1: 2
Funcin de activacin 2: 1
>> Vector de arquitectura 2 elegido: [2 1]

Porfavor ingrese los parametros del MLP:

Ingrese el valor mnimo del error de iteracin (eit): .0001
Ingrese el factor de aprendizaje (alpha): .2
Ingrese el nmero de iteraciones mximas (itmax): 1000
Ingrese la frecuencia en la que se validar (pval): 30
Ingrese el maximo de aumentos en validacin (maxval): 3

>> Iniciando el entrenamiento, porfavor espere...

>> CRITERIO DE PARO: Error de iteracin alcanzado
>> Tiempo de ejecucin: 393093627841.000000
>> Graficando datos, porfavor espere..

Comportamiento de los pesos en la capa 1

Comportamiento de los pesos en la capa 2

Grafica de la evolucion de errores

Resultados
Ejemplo 3: funcin senoidal con polinomio como argumento
5 + sin(7x^4 + 2x^3 + x^2)
Introduzca el archivo de prototipos y targets: 'Funciones/senx4.txt'
>> El archivo "Funciones/senx4.txt" se carg correctamente
Tomando en cuenta que [aprendiaje validacion pruebas]
1.[75% 15% 15%]
2.[80% 10% 10%]
Elija la opcion de distribucin deseada: 2
>> Conjunto de datos elegido [80 10 10]
Cuntos valores tiene el vector de la arquitectura?: 4
Nmero de entradas de la RNA: 1
Neuronas en la capa 1: 4
Neuronas en la capa 2: 3
Neuronas en la capa 3: 1
>> Vector de arquitectura elegido: [1 4 3 1]

Tomando en cuenta que:

1. purelin(n)
2. logsig(n)
3. tansig(n)
Elija la funcion de activacion para cada capa:
Funcin de activacin 1: 3
Funcin de activacin 2: 2
Funcin de activacin 3: 1
>> Vector de arquitectura 2 elegido: [3 2 1]

Porfavor ingrese los parametros del MLP:

Ingrese el valor mnimo del error de iteracin (eit): .0001
Ingrese el factor de aprendizaje (alpha): .2
Ingrese el nmero de iteraciones mximas (itmax): 1500
Ingrese la frecuencia en la que se validar (pval): 40
Ingrese el maximo de aumentos en validacin (maxval): 3

>> Iniciando el entrenamiento, porfavor espere...

>> CRITERIO DE PARO: Nmero mximo de incrementos consecutivos alcanzado

>>Tiempo de ejecucin: 440772564285.000000
>> Graficando datos, porfavor espere..

Comportamiento de los pesos en la capa 1

Comportamiento de los pesos en la capa 2

Comportamiento de los pesos en la capa 3

Grafica del comportamiento de los errores

Resultados
 Archivo Resultados.txt para el ejemplo 3

Archivo ingresado: Funciones/senx4.txt

Arquitectura del MLP: [ 1 4 3 1 ] [ 3 2 1 ]

Eit: 0.000100
alpha: 0.200000
itmax: 1500
pval: 40
 maxval: 3

>> CRITERIO DE PARO: Nmero mximo de incrementos consecutivos alcanzado

en la iteracin 1240
>>Tiempo de ejecucin: 440772564285.000000

Vector de pesos W1
9.161812 -2.204915
0.220068 0.630079
0.322458 0.842421
0.053059 0.746003

Vector de bias 1
4.308793
1.072088
0.842523
0.000307

Vector de pesos W2
-3.882428 -1.322736 -1.136340 -0.835291
-0.511288 -0.696833 -0.578762 -0.910605
-3.535870 0.961231 1.072536 1.058106

Vector de bias 2
-1.621786
-0.873654
1.162413

Vector de pesos W3
1.359024 0.451265 1.938083

Vector de bias 3
2.700203

Discusin de resultados
En los resultados de los ejemplos de entrenamiento anteriores se puede ver el favorable
funcionamiento del MLP. A excepcin del ejemplo 3, las dos anteriores se aproximaron
correctamente a la seal objetivo; por parte del nmero 3 tuvo un pequeo error en su
entrenamiento contenido en x perteneciente al rango [1.5 2]
Conclusiones
Las redes neuronales artificiales comenzaron a estudiarse desde 1943 (en el momento que se creo
su primer modelo) y aunque a lo largo del tiempo se fueron utilizando para temas acadmicos sin
mas uso mas que la investigacin. Hoy en da, con los avances tecnolgicos que van emergiendo
con cada da que pasa, las redes neuronales estn en pleno auge en temas de inteligencia artificial.

Un claro ejemplo es tesla, la empresa de bateras y automviles autnomos, que hizo uso de las
redes neuronales para la navegacin autnoma de sus automviles. Pero no es el nico, por poner
otro ejemplo son los ltimos celulares que han salido al mercado (como los actuales iPhone o el
Google pixel) que tienen procesadores potenciados con redes neuronales para crear inteligencia
artificial y usarla en los asistentes personales, as como en procesos internos del telfono.

Sin duda es una gran poca para adentrarse en el rea de las redes neuronales y gracias a esta
prctica, que sirve de escaln para temas ms avanzados, me motivo para seguir mis estudios en
estos temas.

Referencias
Libreta de apuntes de la clase
https://www.researchgate.net/profile/Pedro_Larranaga2/publication/268291232_Tema_
8_Redes_Neuronales/links/55b7b5c408ae9289a08c0c68/Tema-8-Redes-Neuronales.pdf
http://dspace.uib.es/xmlui/bitstream/handle/11201/1126/TFG%20Marta%20Vidal%20Go
nz%C3%A1lez.pdf?sequence=1
http://neuralnetworksanddeeplearning.com/chap2.html
http://www.esacademic.com/dic.nsf/eswiki/922098
https://es.slideshare.net/jcbp_peru/utp-20152ias6adaline-y-backpropagation
https://www.mathworks.com/help/nnet/ref/tansig.html
https://www.mathworks.com/help/nnet/ref/logsig.html
Anexo
%% Generador de funciones
% Autor: Alejandro Hernndez Gmez
% Carrera: Ingenieria en Sistemas Computacionales
% Escuela: Escuela Superior de Computo ESCOM - Insituto Politecnico Nacional IPN
% Asignatura: Neural Networks
% Grupo: 3CM2
% Version de MATLAB: R2017a

function GeneradorDatos()
clc
name = input('Ingrese el nombre del archivo: ');
datmin = input('Ingrese el limite inferior del rango: ');
datmax = input('Ingrese el limite superior del rango: ');
datos = input('Ingrese el numero de datos a obtener: ');
p = linspace(datmin,datmax,datos); %p - rango de evaluacin
i = [1];
[fy, fx] = size(i);

for it = i
if(fx > 1)
file_name = ['FunSeries/',name,'_',int2str(it),'.txt'];
else

file_name = ['Funciones/',name,'.txt'];
end
file = fopen(file_name,'w');
targetL = [];
for n = 1 : datos
prototype = p(n);
target = g(it,p(n));
targetL = [targetL, target];
fprintf(file,'%f',prototype);
fprintf(file,' %f',target);
if it<datos-1
fprintf(file,'\n');
end
end
fclose(file);
fprintf("\n>> Archivo %s generado correctamente", file_name);
fprintf("\n>> Graficando funcion resultante\n\n");
figure
plot(p,targetL);
end
opc = input('Desea crear un nuevo archivo? 1.Si 2.No: ');
if(opc == 1)
GeneradorDatos();
else
opc = input('Desea entrenar la red ahora? 1.Si 2.No: ');
if(opc == 1)
main();
end
end
end

%% Funcion a generar
function [out] = g(n,x)
out = 1 + sin(n*5*x*pi/4); % 1+sen(5Xpi/4)
end
%% Perceptrn Multicapa MLP
% Autor: Alejandro Hernndez Gmez
% Carrera: Ingenieria en Sistemas Computacionales
% Escuela: Escuela Superior de Computo ESCOM - Insituto Politecnico Nacional IPN
% Asignatura: Neural Networks
% Grupo: 3CM2
% Version de MATLAB: R2017a

function main()
%% Limpia consola
clear,clc,close all

%% Asignacin del archivo de resultados y carga del archivo de prototipos y

targets
fid = fopen('Resultados.txt', 'wt');
txt=input('Introduzca el archivo de prototipos y targets: ');
data=load(txt);
fprintf('>> El archivo "%s" se carg correctamente \n\n', txt);
[fil, colum]=size(data);

fprintf(fid, 'Archivo ingresado: %s', txt);

%% Asignacin de los conjuntos de datos

mux=input('Tomando en cuenta que [aprendiaje validacion pruebas] \n 1.[75%
15% 15%] \n 2.[80% 10% 10%] \nElija la opcion de distribucin deseada: ');
[Mvalidacion, Maprendizaje, Mprueba]=ConjuntoDat(mux,fil,data);

target= Maprendizaje(:,end);
entrenam=elimina_columna(Maprendizaje,colum);
[fil2, colum2]=size(entrenam);

%% Asignacin de la arquitectura (vector 1)

N=input('\nCuntos valores tiene el vector de la arquitectura?: ');
RNA=ones(N, 1);
FUNACT=ones(N-1,1);

for i=1:N
if i==1
RNA(i)=colum2;
fprintf('\tNmero de entradas de la RNA: %i \n', RNA(i)-1);
else
fprintf('\tNeuronas en la capa %i: ', i-1);
RNA(i)=input('');
end
end
RNA2 = RNA;
RNA2(1) = 1;
disp(['>> Vector de arquitectura elegido: [' num2str(RNA2(:).') ']']) ;
fprintf("");

%% Asignacin de la arquitectura (vector 2)

fprintf('\nTomando en cuenta que:\n 1. purelin(n) \n 2. logsig(n) \n 3.
tansig(n) \nElija la funcion de activacion para cada capa:\n');
for i=1:N-1
fprintf('\tFuncin de activacin %i: ', i);
FUNACT(i)=input('');
end
disp(['>> Vector de arquitectura 2 elegido: [' num2str(FUNACT(:).') ']']) ;
fprintf("\n");

%% Escribe en el archivo Resultado.txt la arquitectura del MLP

 fprintf(fid, '\n\n Arquitectura del MLP: ');
fprintf(fid, '['); fprintf(fid, ' %i', RNA2(:,:)); fprintf(fid, ' ] [');
fprintf(fid, ' %i', FUNACT(:,:)); fprintf(fid, ' ]');

%% Asignacin de los parametros del MLP

fprintf("Porfavor ingrese los parametros del MLP:\n");
eit = input(' Ingrese el valor mnimo del error de iteracin (eit): ');
alpha = input(' Ingrese el factor de aprendizaje (alpha): ');
itMAX = input(' Ingrese el nmero de iteraciones mximas (itmax): ');
Pval =input(' Ingrese la frecuencia en la que se validar (pval): ');
MAXval =input(' Ingrese el maximo de aumentos en validacin (maxval): ');

Wcell = cell(itMAX,N-1);
set(0,'RecursionLimit',9999999999)

%% Escribe en el archivo Resultado.txt los parametros utilizados

fprintf(fid,'\n Eit: %f',eit);
fprintf(fid,'\n alpha: %f',alpha);
fprintf(fid,'\n itmax: %i',itMAX);
fprintf(fid,'\n pval: %i',Pval);
fprintf(fid,'\n maxval: %i',MAXval);

%% Inicializa con valores aleatorios los pesos y bias

Capas=length(RNA)-1;
for k=1: Capas
W(k)={rand(RNA(k+1), RNA(k))};
bias(k)={rand(RNA(k+1), 1)};
end

%% Inicializa el entrenamiento
tic %inicializa el cronometro
fprintf("\n>> Iniciando el entrenamiento, porfavor espere...\n");
perceptron(Wcell,0, fid, target, entrenam, W, bias, 0, eit, alpha, itMAX, 1,
RNA, FUNACT, Pval, 1, MAXval, Mvalidacion, Mprueba, 1, 0);
end

%% Validacion
function [Mvalidacion, Maprendizaje, Mprueba]=ConjuntoDat(mux,fil, data)

if(mux==1)
mac = .7;
mvc = .15;
mpc = .15;
else
mac = .8;
mvc = .1;
mpc = .1;
end
fprintf('>> Conjunto de datos elegido [%i %i %i]\n', mac*100, mvc*100,
mpc*100);

matrizAUX=data;
[filas, columnas]=size(data);
Mvalidacion = [];
Maprendizaje = [];
Mprueba = [];
aux = 1;

for i = 1:filas
aux = aux +1;
if(i < filas*(mac+mvc)+1)
 if(aux == (mvc*100))
aux = 1;
Mvalidacion = [Mvalidacion; data(i,:)];
else
Maprendizaje = [Maprendizaje; data(i,:)];
end
else
Mprueba = [Mprueba; data(i,:)];
end
end
end

%% Eliminar columna
function out = elimina_columna(matriz,columna)
%matriz(:,columna)=[];
out=matriz;
end

%% Funciones de activacin
function A_out=FuncionActivacion(N_out, FunAct)
[fila, columna]=size(N_out);
N_aux=N_out;

switch FunAct
case 1 %PURELIN
A_out=N_out;

case 2 %LOGSIG
for i=1:fila
N_aux(i)=1/(1+exp(-N_out(i)));
end
A_out=N_aux;
case 3 %TANSIG
for i=1:fila
N_aux(i)=(exp(N_out(i))-exp(-N_out(i)))/(exp(N_out(i))+exp(-
N_out(i)));
end
A_out=N_aux;
end
end

%% Graficar pesos
function Grafica_Pesos(matriz,iteracion)
[filas,col]=size(matriz);
figure('position',[0,0,800,800])
for j=1:col
subplot(col,1,j)
auxW=matriz{1,j};
[filasA,colA]=size(auxW);
auxPlot=zeros(iteracion,colA);
cont=1;
for k=1:colA*filasA
for i=1:iteracion
auxW=matriz{i,j};
if k>colA
auxPlot(i,k)=auxW(cont,rem(k,colA)+1);
else
auxPlot(i,k)=auxW(cont,k);
end
if rem(k,colA)==0&&i>iteracion-1
cont=cont+1;
end
 end
end
plot(auxPlot);
title('Comportamiento de W')
if cont-1 == 3
legend('W1','W2', 'W3')
elseif cont-1==1
legend('W1')
elseif cont-1==2
legend('W1','W2')
elseif cont-1 == 4
legend('W1','W2', 'W3', 'W4')
elseif cont-1 == 5
legend('W1','W2', 'W3', 'W4', 'W5');
elseif cont-1 == 6
legend('W1','W2', 'W3', 'W4', 'W5','W6');
elseif cont-1 == 7
legend('W1','W2', 'W3', 'W4', 'W5','W6','W7');
elseif cont-1 == 8
legend('W1','W2', 'W3', 'W4', 'W5','W6','W7','W8');
elseif cont-1 == 9
legend('W1','W2', 'W3', 'W4', 'W5','W6','W7','W8','W9');
elseif cont-1 == 10
legend('W1','W2', 'W3', 'W4', 'W5','W6','W7','W8','W9','W10');
elseif cont-1 == 11
legend('W1','W2', 'W3', 'W4', 'W5','W6','W7','W8','W9','W10','W11');
elseif cont-1 == 12
legend('W1','W2', 'W3', 'W4',
'W5','W6','W7','W8','W9','W10','W11','W12');
elseif cont-1 == 13
legend('W1','W2', 'W3', 'W4',
'W5','W6','W7','W8','W9','W10','W11','W12','W13');
elseif cont-1 == 14
legend('W1','W2', 'W3', 'W4',
'W5','W6','W7','W8','W9','W10','W11','W12','W13','W14');
end
end
end

%% Graficar datos
function Graficar_Datos(GraficaE, Eprueba, iteracion, Pval, a_total, target,opc)
[fil, col]=size(GraficaE);
[f, c]=size(a_total);
i=Pval;
k=1;
if iteracion >= Pval
if opc==1
x=linspace(1, iteracion-1, iteracion-1);
y=linspace(1, iteracion-1, 1);
elseif opc==2
x=linspace(1, iteracion, iteracion);
y=linspace(1, iteracion, 1);
end
while(i<=col)
ErrorVal(1,k)=GraficaE(1,i);
i=i+Pval;
k=k+1;
end
else
ErrorVal=0;
x=linspace(1, iteracion, iteracion)
y=linspace(1, iteracion, 1);
end
 [fx, cx]=size(x);
z=linspace(-2,2,c);
fprintf('\n>> Graficando datos, porfavor espere..');

figure

subplot(2,1,1)
plot(x,GraficaE, 'o:k', y,Eprueba, 'o:b','markersize',8);
title('Errores')
legend('Error ent y val', 'Error prueba');
xlabel('Nmero de iteraciones')
ylabel('Valor del error')

subplot(2,1,2)
plot(z,target, 'o k',z,a_total,'o r');
legend('Seal Real', 'Seal obtenida');
title('Resultados')

figure

plot(z,target, 'b',z,a_total,'r');

end

%% Generar vectores random

function [m] = Random(imin,imax,K)
% Retorna um arreglo de K valores entre imin e imax

if (imax-imin < K)
fprintf(' Error:excede el rango\n');
m = NaN;
return
end

n = 0; % contador de # aleatorios
m = imin-1;
imin
imax
while (n < K)
a = randi([round(imin),round(imax)],1);
if ((a == m) == 0)
m = [m, a];
n = n+1;
end
end
m = m(:,2:end);
end

%% Algoritmo del perceptrn

function perceptron(Wcell,Wplot, fid, target, matriz, W, bias, GraficaE, eit,
alpha, itMAX, iteracion, RNA, FUNACT, Pval, Periodo, MAXval, Mvalidacion,
Mprueba, contador, aFinal)

[fil2, colum2]=size(matriz);

Capas=length(RNA)-1;
for i=1:Capas
Wcell{iteracion,i}=W{1,i};
end
 if contador == MAXval
fprintf('\n>> CRITERIO DE PARO: Nmero mximo de incrementos consecutivos
alcanzado');
fprintf(fid,'\n\n>> CRITERIO DE PARO: Nmero mximo de incrementos
consecutivos alcanzado en la iteracin %i', iteracion-1);

timerVal = tic;
fprintf("\n>>Tiempo de ejecucin: %f",timerVal);
fprintf(fid,"\n>>Tiempo de ejecucin: %f",timerVal);

fprintf(fid,'\n');

for p=1:Capas

fprintf(fid,'\n Vector de pesos W%i\n',p);

[v,u]=size(W{p});
for i=1:v
for j=1:u
fprintf(fid,' %f \t',W{p}(i,j));
end
fprintf(fid,'\n');
end

fprintf(fid,'\n Vector de bias %i\n',p);

[v,u]=size(bias{p});
for i=1:v
for j=1:u
fprintf(fid,' %f \t',bias{p}(i,j));
end
fprintf(fid,'\n');
end
end

fclose(fid);

Eprueba=Prueba(W, bias, RNA, Mprueba, FUNACT);

Graficar_Datos(GraficaE, Eprueba, iteracion,Pval, aFinal, target,1);
Grafica_Pesos(Wcell,iteracion);
opcion=input('\n\n');
if opcion == 1
clc
return
else
main();
end
end

if iteracion == itMAX+1
fprintf('\n>> CRITERIO DE PARO: Iteraciones mximas alcanzadas');
fprintf(fid,'\n>> CRITERIO DE PARO: Iteraciones mximas alcanzadas');

timerVal = tic;
fprintf("\n>>Tiempo de ejecucin: %f",timerVal);
fprintf(fid,"\n>>Tiempo de ejecucin: %f",timerVal);

fprintf(fid,'\n');
for p=1:Capas
fprintf(fid,'\n W%i\n',p);
[v,u]=size(W{p});
for i=1:v
 for j=1:u
fprintf(fid,' %f \t',W{p}(i,j));
end
fprintf(fid,'\n');
end
fprintf(fid,'\n\n');
end

fclose(fid);
Eprueba=Prueba(W, bias, RNA, Mprueba, FUNACT);
Graficar_Datos(GraficaE, Eprueba, iteracion,Pval, aFinal, target,1);
Grafica_Pesos(Wcell,iteracion);
opcion=input('\n\n');
if opcion == 1
clc
return
else
main();
end
end

if Periodo == Pval
Eval=Validacion(W, bias, RNA, Mvalidacion, FUNACT);
GraficaE(iteracion)=Eval;
if iteracion>Pval
if Eval>GraficaE(iteracion-Pval)
contador=contador+1;
else
contador=1;
end

end
perceptron(Wcell,Wplot, fid, target, matriz, W, bias, GraficaE, eit,
alpha, itMAX, iteracion+1, RNA, FUNACT, Pval, 1, MAXval, Mvalidacion, Mprueba,
contador, aFinal);
end

error=zeros(fil2, 1);
i=1;
auxerror=0;

Waux=W;
while(i<fil2+1)
entrenamiento=matriz(i,:)';
[a, a_out]=Propagacion(W, bias, entrenamiento, RNA, FUNACT); %Propagacin
hacia adelante

auxerror=(target(i)-a_out);
error(i)=auxerror.^2;
aFinal(i)=a_out;

[Wnew, BIASnew]=BackPropagation(a, W, bias, auxerror, RNA, FUNACT, alpha,

entrenamiento);
W=Wnew;
bias=BIASnew;

i=i+1;
auxerror=0;
end
 if iteracion==1
Wplot=Waux{2};
else
T=vertcat(Wplot,Wnew{2});
Wplot=T;
end

sum_error=0;
for i=1: fil2
sum_error=sum_error+error(i);
end
sum_error=(sum_error)/fil2;

GraficaE(iteracion)=sum_error;

if sum_error <= eit

fprintf(fid, '\n\n\t error total= %f <= error iteracin = %f ----> SI',
sum_error, eit);
fprintf('\n\n\t --> CRITERIO DE PARO: Error de iteracin alcanzado');
fprintf(fid, '\n\n\t --> CRITERIO DE PARO: Error de iteracin alcanzado
en la iteracin %i', iteracion-1);

timerVal = tic;
fprintf("\n>>Tiempo de ejecucin: %f",timerVal);
fprintf(fid,"\n>>Tiempo de ejecucin: %f",timerVal);

fprintf(fid,'\n');
fclose(fid);

Eprueba=Prueba(W, bias, RNA, Mprueba, FUNACT);

Graficar_Datos(GraficaE, Eprueba, iteracion,Pval, aFinal, target,2);
Grafica_Pesos(Wcell,iteracion);
opcion=input('\n\n');
if opcion == 1
clc
return
else
main();
end

else
perceptron(Wcell,Wplot, fid, target, matriz, W, bias, GraficaE, eit,
alpha, itMAX, iteracion+1, RNA, FUNACT, Pval, Periodo+1, MAXval, Mvalidacion,
Mprueba, contador, aFinal);
end

end

%% Sensitividad
function S = Sensitividades(a, RNA, FUNACT, auxerror, W)
Capas=length(RNA)-1;
for k=1: Capas
S(k)={zeros(RNA(k+1), RNA(k+1))};
F(k)={zeros(RNA(k+1), RNA(k+1))};
end

i=Capas;
while(i>0)
[x, y]=size(F{i});
 for j=1:x
for k=1:y
if k==j %% diagonal de la matriz F
if FUNACT(i)==1 %derivada de purelin
F{i}(j,k)=1;
elseif FUNACT(i)==2 %derivada de logsig
F{i}(j,k)=a{i}(j,1)*(1-a{i}(j,1));
elseif FUNACT(i)==3 %derivada de tansig
F{i}(j,k)=1-(a{i}(j,1))^2;
end
end
end
end

if i==Capas
S{i}=(-2)*auxerror*F{i};
else
S{i}=F{i}*W{i+1}'*S{i+1};
end
i=i-1;
end
S=S;
end

%% Validacin
function sum_error=Validacion(W, bias, RNA, Mvalidacion, FUNACT)
[fix, cox]=size(RNA);
[f0, c0]=size(Mvalidacion);
target= Mvalidacion(:,end);
matriz=elimina_columna(Mvalidacion,c0);

error=zeros(f0, 1);
i=1;
auxerror=0;
while(i<f0+1)
entrenamiento=matriz(i,:)';
[a, a_out]=Propagacion(W, bias, entrenamiento, RNA, FUNACT);
%Propagacin hacia adelante
auxerror=(target(i)-a_out);
error(i)=auxerror.^2;
auxerror=0;
i=i+1;
end
sum_error=0;
for i=1: f0
sum_error=sum_error+error(i);
end
sum_error=(sum_error)/f0;
end

%% Prueba
function sum_error=Prueba(W, bias, RNA, Mprueba, FUNACT)
[fix, cox]=size(RNA);
[f0, c0]=size(Mprueba);
target= Mprueba(:,end);
matriz=elimina_columna(Mprueba,c0);
error=zeros(f0, 1);
i=1;
auxerror=0;
while(i<f0+1)
entrenamiento=matriz(i,:)';
 [a, a_out]=Propagacion(W, bias, entrenamiento, RNA, FUNACT); %Propagacin
hacia adelante
auxerror=(target(i)-a_out);
error(i)=auxerror.^2;
auxerror=0;
i=i+1;
end
sum_error=0;
for i=1: f0
sum_error=sum_error+error(i);
end
sum_error=(sum_error)/f0;
end

%% Algoritmo de propagacion hacia adelante

function [a, A]=Propagacion(W, bias, entrenamiento, RNA, FUNACT)
[fila, columna]=size(RNA);
Capas=length(RNA)-1;
i=1;
cadena='funcin';

for k=1: Capas

a(k)={rand(RNA(k+1), 1)};
end

while(i<fila)
N_aux=W{i}(:,:)*entrenamiento+bias{i}(:,:);
A_out=FuncionActivacion(N_aux,FUNACT(i));

if FUNACT(i)==1
cadena='purelin (n)';
elseif FUNACT(i)==2
cadena='logsig(n)';
elseif FUNACT(i)==3
cadena='tansig(n)';
end

entrenamiento=A_out;
a{i}=A_out;
i=i+1;
end
A=A_out;

end

%% Algoritmo BackPropagation
function [Wnew, BIASnew]=BackPropagation(a, W, bias, auxerror, RNA, FUNACT,
alpha, entrenamiento)
Capas=length(RNA)-1;
k=Capas;
S=Sensitividades(a, RNA, FUNACT, auxerror,W);
while(k>0)
bias{k}=bias{k}-alpha*S{k};
if k-1==0
W{k}= W{k}-alpha*S{k}*entrenamiento';
else
W{k}= W{k}-alpha*S{k}*a{k-1}';
end
k=k-1;
end
Wnew=W;
BIASnew=bias;
end