Red Neuronal Hopfield

Vista previa del material en texto

IA 2017 – TP3EVAL - #3 
aprendizaje en un objeto tipo celda, en este caso llamado “entrada”. Y generamos la matriz ‘T’ 
de pesos adecuada para la red hopfield con los vectores de entrenamiento de la siguiente forma: 
 
%APRENDIZAJE DE LA RED NEURONAL 
v0 = [-1,-1,1,1,1,-1,-1,-1,1,-1,-1,-1,1,-1,1,-1,-1,-1,-1,-1,1,1,-1,-1,-1,-1,-
1,1,1,-1,-1,-1,-1,-1,1,1,-1,-1,-1,-1,-1,1,1,-1,-1,-1,-1,-1,1,1,-1,-1,-1,-1,-
1,1,1,-1,-1,-1,-1,-1,1,-1,1,-1,-1,-1,1,-1,-1,-1,1,1,1,-1,-1]; 
v1 = [-1,-1,-1,1,-1,-1,-1,-1,-1,1,1,-1,-1,-1,-1,1,-1,1,-1,-1,-1,1,-1,-1,1,-
1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,-
1,1,-1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,-1,1,-1,-1,-1,1,1,1,1,1,1,1]; 
v2 = [-1,-1,1,1,1,-1,-1,-1,1,-1,-1,-1,1,-1,1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-
1,-1,1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,1,-
1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,-1,1,1,1,1,1,1,1]; 
v3 = [-1,-1,1,1,1,-1,-1,-1,1,-1,-1,-1,1,-1,1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-
1,-1,1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,1,1,-1,-1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-
1,-1,-1,1,1,-1,-1,-1,-1,-1,1,-1,1,-1,-1,-1,1,-1,-1,-1,1,1,1,-1,-1]; 
v4 = [-1,-1,-1,-1,1,1,-1,-1,-1,-1,1,-1,1,-1,-1,-1,1,-1,-1,1,-1,-1,1,-1,-1,-
1,1,-1,1,-1,-1,-1,-1,1,-1,1,1,1,1,1,1,1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,-
1,1,-1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,-1,1,-1]; 
v5 = [1,1,1,1,1,1,1,1,-1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-
1,-1,1,-1,1,1,1,-1,-1,1,1,-1,-1,-1,1,-1,-1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,-
1,1,1,-1,-1,-1,-1,-1,1,-1,1,-1,-1,-1,1,-1,-1,-1,1,1,1,-1,-1]; 
v6 = [-1,-1,1,1,1,-1,-1,-1,1,-1,-1,-1,1,-1,1,-1,-1,-1,-1,-1,1,1,-1,-1,-1,-1,-
1,-1,1,-1,-1,-1,-1,-1,-1,1,-1,1,1,1,-1,-1,1,1,-1,-1,-1,1,-1,1,-1,-1,-1,-1,-
1,1,1,-1,-1,-1,-1,-1,1,-1,1,-1,-1,-1,1,-1,-1,-1,1,1,1,-1,-1]; 
v7 = [1,1,1,1,1,1,1,-1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,-
1,1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,1,-
1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,-1]; 
v8 = [-1,-1,1,1,1,-1,-1,-1,1,-1,-1,-1,1,-1,1,-1,-1,-1,-1,-1,1,1,-1,-1,-1,-1,-
1,1,-1,1,-1,-1,-1,1,-1,-1,-1,1,1,1,-1,-1,-1,1,-1,-1,-1,1,-1,1,-1,-1,-1,-1,-
1,1,1,-1,-1,-1,-1,-1,1,-1,1,-1,-1,-1,1,-1,-1,-1,1,1,1,-1,-1]; 
v9 = [-1,-1,1,1,1,-1,-1,-1,1,-1,-1,-1,1,-1,1,-1,-1,-1,-1,-1,1,1,-1,-1,-1,-1,-
1,1,-1,1,-1,-1,-1,1,1,-1,-1,1,1,1,-1,1,-1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,-
1,1,1,-1,-1,-1,-1,-1,1,-1,1,-1,-1,-1,1,-1,-1,-1,1,1,1,-1,-1]; 
 
entrada = {v0, v1, v2, v3, v4, v5, v6, v7, v8, v9};%Almacenamos los vectores 
patron en un objeto tipo celda 'entrada' 
%Generamos una matriz de pesos adecuada para la red de hopfield con los 
%vectores de entrenamiento 
%Definimos un matrix de ceros de 77x77 para almacenar los pesos 
T = [v0' v1' v2' v3' v4' v5' v6' v7' v8' v9']; 
 
Luego le a asignamos al a matriz ‘f’ la imagen del patron que se requiere reconocer, este patron 
es para comprobar el funcionamiento de la red. Los patrones estan almacenados en la direccion 
que se muestra en el codigo, para seleccionar uno se debe descomentar la parte correspondiente a 
la asignacion y asegurarse que la ruta concuerde. Como patrones para comprobar tenemos 
valores del 0 al 9 y para los valores del 1 al 6 colocamos 3 variantes de cada uno. 
 
%Imagenes, matrices y vectores 
%f =imread('D:\IA\TP3 EV\Patrones\1V1.jpeg');% NUMERO 1 PRIMER VARIANTE 
%f =imread('D:\IA\TP3 EV\Patrones\1V2.jpg');% NUMERO 1 SEGUNDA VARIANTE 
%f =imread('D:\IA\TP3 EV\Patrones\1V3.jpg');% NUMERO 1 TERCER VARIANTE 
 
%f =imread('D:\IA\TP3 EV\Patrones\2V1.jpeg');% NUMERO 2 PRIMER VARIANTE 
%f =imread('D:\IA\TP3 EV\Patrones\2V2.jpg');% NUMERO 2 SEGUNDA VARIANTE 
%f =imread('D:\IA\TP3 EV\Patrones\2V3.jpg');% NUMERO 2 TERCER VARIANTE 
 
%f =imread('D:\IA\TP3 EV\Patrones\3V1.jpeg');%NUMERO 3 PRIMER VARIANTE 
%f =imread('D:\IA\TP3 EV\Patrones\3V2.jpg');%NUMERO 3 SEGUNDA VARIANTE 
%f =imread('D:\IA\TP3 EV\Patrones\3V3.jpg');%NUMERO 3 TERCER VARIANTE 
 
%f =imread('D:\IA\TP3 EV\Patrones\4V1.jpeg');%NUMERO 4 PRIMER VARIANTE 
%f =imread('D:\IA\TP3 EV\Patrones\4V2.jpg');%NUMERO 4 SEGUNDA VARIANTE 
%f =imread('D:\IA\TP3 EV\Patrones\4V3.jpg');%NUMERO 4 TERCER VARIANTE 
 
IA 2017 – TP3EVAL - #4 
%f =imread('D:\IA\TP3 EV\Patrones\5V1.jpeg');%NUMERO 5 PRIMER VARIANTE 
%f =imread('D:\IA\TP3 EV\Patrones\5V2.jpg');%NUMERO 5 SEGUNDA VARIANTE 
%f =imread('D:\IA\TP3 EV\Patrones\5V3.jpg');%NUMERO 5 TERCER VARIANTE 
 
%f =imread('D:\IA\TP3 EV\Patrones\6V1.jpeg');%NUMERO 6 PRIMER VARIANTE 
%f =imread('D:\IA\TP3 EV\Patrones\6V2.jpg');%NUMERO 6 SEGUNDA VARIANTE 
%f =imread('D:\IA\TP3 EV\Patrones\6V3.jpg');%NUMERO 6 TERCER VARIANTE 
 
Una vez elegido el patrón de prueba a reconocer debemos transformarlo en una imagen binaria, 
para hacer esto necesitamos elegir un umbral que permita distinguir las clases entre pixeles 
blancos y negros y así convertirla en imagen binaria. 
 
M=graythresh(f);%Elige el umbral para minimizar la varianza intraclase de los 
píxeles en blanco y negro. 
 
fbinaria=im2bw(f,M);%Convierte la imagen en escala de grises "f" en una 
imagen binaria 
 
Transformamos la matriz binaria de 7x11 en un vector de 1x77; y luego cambiamos los 0 por 1, 
y los 1 por -1 para analizar el patrón de prueba utilizando la función signo 
 
%Transformamos la matriz binaria en un vector de 1x77 
I = []; 
for i = 1:1:size(fbinaria, 1) 
 
 I = horzcat(I, fbinaria(i,:)); 
 
end; 
 
%cambiamos los 0 en 1, y los 1 en -1, para 
%poder analizar el patron de prueba haciendo uso de la función signo. 
for i=1:77 
 if I(i)==0 
 I(i)=1 
 else 
 I(i)=-1 
 end 
end 
 
Creamos la red, asignamos el patrón de prueba y simulamos la Red 
 
net = newhop(T); %Creación de la Red Neuronal de Hopfield 
vp = I; % Introducimos el patrón de prueba 
 
salida = 0; %para iterar en el bucle while 
prueba = sim(net,1,[],vp'); %Simulación de la Red de Hopfield 
iteraciones = 0; 
 
 
 
 
 
 
 
IA 2017 – TP3EVAL - #5 
Luego comparamos el patrón de prueba con los patrones aprendidos para así poder asociárselo 
correctamente Si no hay ninguno con el que pueda asociarse se dice que la red no converge 
 
while ((salida == 0) || (iteraciones == 77))%Itera mientras los vectores son 
diferentes 
 iteraciones = iteraciones + 1;%número de iteraciones en las que se 
determina el patrón obtenido 
 prueba1 = sim(net,1,[],prueba); 
 if isequal(prueba1,prueba)%Compara si ambas son iguales 
 salida = 1;%Si son iguales termina de iterar 
 else 
 prueba = prueba1;%Si son diferentes le asigno prueba1 al patron de 
prueba 
 end 
end 
 
if iteraciones > 77 
 fprintf('La red no converge'); 
end 
 
for i = 1:1:10 %Este bucle es para saber que puntos de prueba coinciden con 
ciertos puntos de aprendizaje 
 if isequal(entrada{i},prueba')%Compara el patron de prueba con los 
patrones de entrada, para luego mostrar a cual se asemeja más 
 fprintf ('Patron encontrado: %d \n', i-1); 
 IT2 = prueba'; 
 %resulta conveniente transformar los "-1" 
 %en 0 y por ello que utilizamos el siguiente bucle "for" 
 for i=1:77 
 if IT2(i)==-1 
 IT2(i)=0; 
 end 
 end 
 %Con el siguiente bucle "for", transformo el vector en matriz, y con 
 %ello muestra la matriz que identifica univocamente al patron 
 %encontrado 
 for i=1:7 
 x(1,i)=IT2(i); 
 x(2,i)=IT2(i+7); 
 x(3,i)=IT2(i+14); 
 x(4,i)=IT2(i+21); 
 x(5,i)=IT2(i+28); 
 x(6,i)=IT2(i+35); 
 x(7,i)=IT2(i+42); 
 x(8,i)=IT2(i+49); 
 x(9,i)=IT2(i+56); 
 x(10,i)=IT2(i+63); 
 x(11,i)=IT2(i+70); 
 end 
 disp(x); %Muestro la matriz formada 
 fprintf('\nNumero de iteraciones: %d \n', iteraciones); 
 %esta línea muestra el número de iteraciones realizadas hasta 
 %que se logra encontrar el patrón más próximo al patrón de prueba 
 end 
endIA 2017 – TP3EVAL - #6 
Los resultados de las pruebas son los siguientes: 
PATRON 1 
Primer Variante 
 
 
f =imread('D:\IA\TP3 EV\Patrones\1V1.jpeg');% NUMERO 1 PRIMER VARIANTE 
 
En 3 iteraciones logro el resultado esperado lo clasifico como el valor 1 
 
 
 
Segunda Variante 
 
 
f =imread('D:\IA\TP3 EV\Patrones\1V2.jpg');% NUMERO 1 SEGUNDA VARIANTE 
 
IA 2017 – TP3EVAL - #7 
 
 
Tambien llego al resultado deseado en 8 iteraciones. Clasifico correctamente como valor 1 
 
Tercer Variante 
 
 
f =imread('D:\IA\TP3 EV\Patrones\1V3.jpg');% NUMERO 1 TERCER VARIANTE 
 
IA 2017 – TP3EVAL - #8 
 
 
En 11 iteraciones llego al resultado correcto el patron 1. 
 
PATRON 2 
Primer Variante 
 
 
f =imread('D:\IA\TP3 EV\Patrones\2V1.jpeg');% NUMERO 2 PRIMER VARIANTE 
 
IA 2017 – TP3EVAL - #9 
 
En 10 iteraciones llega el resultado 2 que es el correcto 
 
Segunda Variante 
 
 
f =imread('D:\IA\TP3 EV\Patrones\2V2.jpg');% NUMERO 2 SEGUNDA VARIANTE 
No llego al resultado correcto no encontró el patrón. 
 
Tercer Variante 
 
 
f =imread('D:\IA\TP3 EV\Patrones\2V3.jpg');% NUMERO 2 TERCER VARIANTE 
IA 2017 – TP3EVAL - #10 
 
 
Llego al patron 2 que es el correcto en 12 iteraciones 
 
PATRON 3 
Primer Variante 
 
 
f =imread('D:\IA\TP3 EV\Patrones\3V1.jpeg');%NUMERO 3 PRIMER VARIANTE 
IA 2017 – TP3EVAL - #11 
 
 
En 12 iteraciones llego a un resultado incorrecto, lo clasifico como 2. 
 
Segunda Variante 
 
 
f =imread('D:\IA\TP3 EV\Patrones\3V2.jpg');%NUMERO 3 SEGUNDA VARIANTE 
 
IA 2017 – TP3EVAL - #12 
En 10 iteraciones produjo un resultado incorrecto. Lo clasifico como 5 
Tercer Variante 
 
 
f =imread('D:\IA\TP3 EV\Patrones\3V3.jpg');%NUMERO 3 TERCER VARIANTE 
 
 
En 21 iteraciones tambien clasifico incorrectamente como 5. 
 
PATRON 4 
Primer Variante 
 
f =imread('D:\IA\TP3 EV\Patrones\4V1.jpeg');%NUMERO 4 PRIMER VARIANTE 
 
IA 2017 – TP3EVAL - #13 
 
Encontro el resultado correcto en 5 iteraciones 
Segunda Variante 
 
 
f =imread('D:\IA\TP3 EV\Patrones\4V2.jpg');%NUMERO 4 SEGUNDA VARIANTE 
 
 
 
En 21 iteraciones alcanzo el valor correcto 
IA 2017 – TP3EVAL - #14 
Tercer Variante 
 
 
f =imread('D:\IA\TP3 EV\Patrones\4V3.jpg');%NUMERO 4 TERCER VARIANTE 
 
 
 
En 24 iteraciones llega al valor correcto 
 
PATRON 5 
 
Primer Variante 
 
 
 
f =imread('D:\IA\TP3 EV\Patrones\5V1.jpeg');%NUMERO 5 PRIMER VARIANTE 
 
IA 2017 – TP3EVAL - #15 
 
 
En 13 iteraciones llega al patron 5 
 
Segunda Variante 
 
 
 
 
f =imread('D:\IA\TP3 EV\Patrones\5V2.jpg');%NUMERO 5 SEGUNDA VARIANTE 
 
 
 
En 20 iteraciones llega al resultado deseado 
 
IA 2017 – TP3EVAL - #16 
 
 
Tercer Variante 
 
 
f =imread('D:\IA\TP3 EV\Patrones\5V3.jpg');%NUMERO 5 TERCER VARIANTE 
 
 
 
En 27 iteraciones llega al resultado 
 
PATRON 6 
 
Primer Variante 
 
 
f =imread('D:\IA\TP3 EV\Patrones\6V1.jpeg');%NUMERO 6 PRIMER VARIANTE 
IA 2017 – TP3EVAL - #17 
 
 
Lo clasifico erroneamente como 0 
 
 
 
 
Segunda Variante 
 
 
 
f =imread('D:\IA\TP3 EV\Patrones\6V2.jpg');%NUMERO 6 SEGUNDA VARIANTE 
 
IA 2017 – TP3EVAL - #18 
 
 
En 33 iteraciones lo clasifico como un 6 
 
Tercer Variante 
 
 
 
f =imread('D:\IA\TP3 EV\Patrones\6V3.jpg');%NUMERO 6 TERCER VARIANTE 
No llego a clasificarlo correctamente 
 
Conclusiones: 
A partir de los resultados que la red presente un funcionamiento aceptable ya que encontró la 
solución a la mayoría de los patrones, algunos de estos fueron dibujados con una mayor 
dificultad para comprobar el funcionamiento de la red ante patrones distintos a los aprendidos sin 
embargo hay patrones en los que fallo la convergencia o que dio un resultado que era incorrecto, 
entre ellos son la segunda variante del patrón 2, todas las variantes del patrón 3 y la primer y 
tercer variante del patrón 6 . Como remarcamos anteriormente las variantes de los patrones 
fueron diseñadas con formas confusas, algunas con líneas rectas otras sin ninguna línea recta y 
hasta algunas imperfecciones y rotaciones para poder probar el potencial de la red. La mayoría 
de las pruebas fueron satisfactorias por lo que podemos concluir que si a la red le brindamos 
patrones en término medio de imperfecciones esta va a poder reconocerlos correctamente 
IA 2017 – TP3EVAL - #19 
2. Red RBF (2 puntos). 
La red RBF de la figura (a) se va a utilizar como herramienta de agrupamiento (clustering). Se 
implementará con un entrenamiento híbrido. 
 
Figura (a) 
 
Figura (b) 
Estimar desde la figura (b) los datos correspondientes a los centros y aperturas para el 
entrenamiento no supervisado de las funciones de las neuronas ocultas. Para el entrenamiento 
supervisado se deben utilizar los puntos mostrados en la figura (b) para cada clase (C1, C2 y C3). 
En la fase de operación, comprobar los resultados utilizando tres puntos para cada clase, 
ubicados solamente sobre las intersecciones de la cuadrícula y que no sean los utilizados en el 
entrenamiento. Cada terna de puntos de comprobación, debe ser: uno ubicado cerca del centro de 
la clase; otro ubicado cerca de la periferia del agrupamiento, pero dentro de la clase; y el tercero 
fuera de cualquiera de las clases. 
DESARROLLO 
Primero tomamos las coordenadas de los centros de las clases de la figura y le asociamos su 
correspondiente salida 
 
%%%PUNTO 2%%%% 
%datos de entrada y salida 
ent = [2 2 6 6; 6 2 6 2]; 
%coordenadaas x y 
%clase a la que pertenece 
sal = [2 1 1 3]; 
Luego creamos la red a través del GUI de redes neuronales 
 
%creacion de la red con la gui 
nntool 
 
 
 
 
 
 
 
 
 
 
 
IA 2017 – TP3EVAL - #20 
Una vez creados los datos en el espacio de trabajos los importamos para usar en la red: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
IA 2017 – TP3EVAL - #21 
Al momento de crear la red seleccionamos la correcta la cual está marcada esta es la red RBF 
hibrida. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
IA 2017 – TP3EVAL - #22 
Luego debemos elegir el valor de delta nosotros propusimos el valor 1.5 porque creemos que es 
el más adecuado al problema 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
IA 2017 – TP3EVAL - #23 
Luego solo queda exportar la red al espacio de trabajo y usarla y comprobar su funcionamiento 
 
PRUEBA 
CLASE 2 
 
 
 
IA 2017 – TP3EVAL - #24 
 
CLASE 1 
 
 
CLASE 3 
 
 
IA 2017 – TP3EVAL - #25 
3. Red feedforward-backpropagation (5 puntos). 
Considerar la secuencia de una tormenta producida en la cuenca del río Elorrio (España) y el 
caudal que se genera en este río (archivo TORMENTAS ELORRIO.xlx), con mediciones cada 
10 min. Diseñar una red FF-BP, para trabajar como un predictor de caudales, bajo las siguientes 
consideraciones: 
 Diseñar dos redes FF-BP con una entrada (lluvia) y una salida (caudal). 
 Estimar la cantidad de neuronas ocultas requeridas. 
 Las funciones de activación ocultas pueden ser sigmoides bivaluadas. La función de 
activación de salida debe ser lineal. 
 Utilizar el 80% de los datos para el entrenamiento, con predicción de un paso adelantado 
(10 min) para la primera red FF-BP y seis pasos adelantados (1 hora) para la segunda red 
FF-BP. 
 Con los datos restantes, comprobar el proceso de predicción utilizando el error cuadrático 
medio, para ambas redes (por separado). 
 Repetir el proceso anterior, pero agregando seis ventanas de tiempo diferido a cada red 
FF-BP. 
 Nuevamente comprobar el proceso de predicción mediante el error cuadrático medio. 
 Generar conclusiones respecto de los resultados obtenidos. 
 
DESARROLLO 
 
Para empezar vamos a preparar los datos, extrayendo los datos de entradas y de salidas para 
luego importar en espacio de trabajo. También distinguimos los datos de la red 1 de un paso y los 
datos que tendrán la red 2 de seis pasos: 
1 Paso: 
 
 
IA 2017 – TP3EVAL - #26 
6 pasos: 
 
 
 
Ahora importamos los datos que vamos a usar en las redes: 
Caudal 1 paso: 
 
 
 
 
 
IA 2017 – TP3EVAL - #27 
 
 
Lluvia1 paso: 
 
 
Caudal 6 pasos: 
 
 
 
 
 
 
IA 2017 – TP3EVAL - #28 
 
 
Lluvia 6 pasos: 
 
 
Luego guardamos estas estructuras para luego simplemente cargarlas mediante el comando ‘load’ cuando 
realicemos las redes. 
 
RED 1 PASO 
Cargamos, invertimos y renombramos las matrices importadas para que puedean usarse para el 
entrenamiento y prueba de la red 1 paso: 
%%% Cargamos y preparamos los datos para poder usarlos para entrenamiento y 
prueba 
load('lluvia1paso.mat'); 
load('caudal1paso.mat'); 
entradaLluvia1Paso = lluvia1paso'; 
salidaCaudal1Paso = caudal1paso'; 
Luego de tener los datos que vamos a usar comenzamos a ajustar los parámetros que va a utilizar 
la red “Red1Paso”. 
Los datos que vamos a definir de entrada y salida del todo el conjunto se preparan de la siguiente 
forma: 
%%Con este parametro cambiamos la ventana 
N = 1; 
 
%%% Comenzamos con la red1 
entradaRed1Paso = entradaLluvia1Paso(1:end - N); 
salidaRed1Paso = salidaCaudal1Paso(1:end - N); 
%%% Estos dos datos son la entrada y salida para el entrenamiento de la red 
 
 
%%% Ahora creamos los datos para prediccion y pruebas 
entradaRed1PasoTest = entradaLluvia1Paso(end - N + 1:end); 
salidaRed1PasoTest = salidaCaudal1Paso(end - N + 1:end); 
 
IA 2017 – TP3EVAL - #29 
 
 
Como función de activación usamos la de defecto que es ‘trainlm’. 
El número de neuronas que utilizamos es 30 ya que es el que mejor resultados nos dio. Un 
número pequeño de neuronas provoca que el error sea demasiado grande y si usamos demasiadas 
vamos a perder el poder de generalización de la red. 
 
%Seleccionamos la funcion de entrenamiento por defecto 
trainFcn = 'trainlm'; 
%Estamos trabajando con una unica ventana 
delay = N; 
%Colocamos el numero de neuronas a usar en la capa oculta 
neuronsHiddenLayer = 30; 
 
Ahora creamos la red ‘Red1Paso’ y modificamos sus parámetros. 
Las funciones de activación que debemos usar indicadas en la consigna son sigmoidal bivaluada 
para la capa oculta y lineal para la capa de salida. La definimos a continuación: 
 
%Creamos la red neuronal 
Red1Paso = timedelaynet(1:N, neuronsHiddenLayer, trainFcn); 
 
%Verificamos las funciones de activacion de la capa oculta y salida 
%Modificando por la funcion deseada 
Red1Paso.layers{1}.transferFcn = 'tansig'; 
Red1Paso.layers{2}.transferFcn = 'purelin'; 
Se pide en este punto que usemos un 80% de los datos para entrenamiento y un 20% para prueba 
en las siguientes líneas preparamos los datos para la red en esa distribución, además definimos 
que la distribución de los datos de entrenamiento y prueba es en forma aleatoria por lo que en 
cada ejecución se obtendrán distintos conjuntos de datos y por lo tanto distintos resultados: 
 
%Preparamos de los datos de entrenamiento y test 
[Xs, Xi, Ai, Ts] = preparets(Red1Paso, entradaRed1Paso, salidaRed1Paso); 
%Realizamos la distribucion de los datos en 80 entrenamiento y 20 test 
Red1Paso.divideParam.trainRatio = 80/100; 
Red1Paso.divideParam.valRatio = 20/100; 
Red1Paso.divideParam.testRatio = 0/100; 
 
%Luego dividimos los datos de forma aleatoria 
Red1Paso.divideFcn = 'dividerand'; 
%Dividimos cada valor 
Red1Paso.divideMode = 'time'; 
%Usamos como funcion de rendimiento el error cuadratico medio 
Red1Paso.performFcn = 'mse'; 
Con los datos preparados ya podemos comenzar a entrenar la red y mostrar su arquitectura: 
 
%Una vez definidos todos los parametros podemos comenzar a entrenar la red 
Red1Paso = train(Red1Paso, Xs, Ts, Xi, Ai); 
 
%El diagrama de la red se muestra a continuacion 
view(Red1Paso); 
 
 
 
 
 
 
IA 2017 – TP3EVAL - #30 
 
 
El resultado del entrenamiento: 
 
 
 
 
 
 
 
IA 2017 – TP3EVAL - #31 
 
 
Y la arquitectura de la red: 
 
 
Con la red entrenada y lista ya podemos hacerla funcionar y volcar sus resultados en una gráfica: 
 
%Realizamos las predicciones 
[Y, Xf, Af] = Red1Paso(Xs, Xi, Ai); 
[yPred, Xfp, Afp] = Red1Paso(entradaRed1PasoTest, Xf, Af); 
 
%Para comparar los resultados realizamos el grafico 
figure; 
originalSeries = salidaCaudal1Paso; 
predictionSeries = salidaCaudal1Paso; 
 
predictionSeries(end - N + 1:end) = yPred; 
 
%Representamos el grafico 
plot(1:length(salidaCaudal1Paso), cell2mat(predictionSeries), 'r', 
1:length(salidaCaudal1Paso),cell2mat(originalSeries), 'b'); 
legend('Serie de Predicción', 'Serie Original', 'Location', 'SouthEast'); 
 
Grafico: 
 
IA 2017 – TP3EVAL - #32 
Se puede ver como el valor generado por la red es mínimamente diferente al original por lo que 
tiene un error pequeño y concordamos que la red funciona a un muy buen nivel. 
 
Valor esperado: 4,00100000000000 
Valor obtenido: 4,10031853653551 
 
RED 6 PASOS 
Para la red de 6 pasos el procedimiento es el mismo salvo cambiar el nombre de la red a 
‘Red6Pasos’ y los datos que usamos son los de 6 pasos adelantados por lo que la línea de código 
de los datos cambia por: 
 
%%% Cargamos y preparamos los datos para poder usarlos para entrenamiento y 
prueba 
load('lluvia6pasos.mat'); 
load('caudal6pasos.mat'); 
 
entradaLluvia6Pasos = lluvia6pasos'; 
salidaCaudal6Pasos = caudal6pasos'; 
 
El resto del código es igual al anterior. Misma cantidad de neuronas y mismas funciones. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
IA 2017 – TP3EVAL - #33 
 
 
 
Entrenamiento de la red: 
 
 
 
 
 
 
IA 2017 – TP3EVAL - #34 
 
 
 
Arquitectura de la red: 
 
Gráfico de resultados: 
 
Podemos apreciar del grafico que el resultado de esta no es tan buena como la de 1 paso, esto es 
debido que está calculando 6 pasos adelantados y además no se tienen tantos datos para 
entrenarse como en la red de un paso. Aun así el resultado es aceptable no se aleja demasiado del 
valor original 
Valor esperado: 4,21900000000000 
Valor obtenido: 3,69245803194862 
 
 
 
 
 
 
 
IA 2017 – TP3EVAL - #35 
 
NOTA: AL FINAL DEL TRABAJO SE MOSTRARA EL CODIGO COMPLETO DE CADA RED 
ADEMAS DE INCLUIRLO EN LA CARPETA DEL TRABAJO 
AGREGACION DE 6 
VENTANAS DE TIEMPO 
DIFERIDO 
RED 1 PASO 
El código para esta la red es el mismo mostrado para la red 1 paso, la diferencia estar en cambiar 
el valor de las ventanas de tiempo diferido en la siguiente línea: 
%%Con este parametro cambiamos la ventana 
N = 6; 
Todo el resto del código sigue siendo igual 
Entrenamiento de la red: 
IA 2017 – TP3EVAL - #36 
 
Arquitectura de la red: 
 
Gráfico de resultados: 
IA 2017 – TP3EVAL - #37 
 
 Se puede apreciar que es considerablemente diferente a la red1 paso sin las 6 ventanas de tiempo 
diferido. En esta red se están prediciendo 6 valores debido a la ventana. Para los primeros 
valores el error de predicción es algo moderado pero este va disminuyendo hacia los últimos 
valores. 
Valores esperados: 4,34700000000000 4,32900000000000 4,21900000000000
 4,14600000000000 4,05500000000000 4,00100000000000 
 
Valores obtenidos: 3,90630036996537 3,90630036996537 3,90630036996537
 3,90630036996537 3,90630036996537 3,90630036996537 
 
 
 
 
 
 
NOTA: AL FINAL DEL TRABAJO SE MOSTRARA EL CODIGO COMPLETO DE CADA RED 
ADEMAS DE INCLUIRLO EN LA CARPETA DEL TRABAJO 
RED 6 PASOS 
Al igual que en el caso anterior el código es el mismo que de la red 6 pasos salvo cambiar el 
número de ventanas: 
%%Con este parametro cambiamos la ventana 
N = 6; 
Entrenamiento de la red: 
IA 2017 – TP3EVAL - #38 
 
 
 
 
 
Arquitectura de la red: 
IA 2017 – TP3EVAL - #39 
 
Gráfico de resultados: 
 
Los peores resultados los presenta esta red. Si bien en los últimos valores el error es menor sigue 
teniendo errores grandes en comparación de la anterior sin 6 ventanas, esto es debido al usar las 
6 ventanas de tiempo diferido más una cantidad no muy grande de ejemplos de entrenamiento. 
Valores esperados: 7,44600000000000 7,08100000000000 6,54700000000000
 5,75500000000000 4,93600000000000 4,21900000000000 
Valores obtenidos: 20,0388654109711 11,9727776995465 4,30957125945115
 4,62283173198718 7,58213354628093 4,88491418533692NOTA: AL FINAL DEL TRABAJO SE MOSTRARA EL CODIGO COMPLETO DE CADA RED 
ADEMAS DE INCLUIRLO EN LA CARPETA DEL TRABAJO 
IA 2017 – TP3EVAL - #40 
Conclusiones 
 RESULTADOS 
Red Serie Original Resultado 
1 ventana 
Resultado 
6 ventanas tiempo 
diferido 
 
 
Red 1 paso 
4,34700000000000 - 3,90630036996537 
4,32900000000000 - 3,90630036996537 
4,21900000000000 - 3,90630036996537 
4,14600000000000 - 3,90630036996537 
4,05500000000000 - 3,90630036996537 
4,00100000000000 4,10031853653551 3,90630036996537 
ECM - 4.93 -03 0.08 
 
 
Red 6 pasos 
7,44600000000000 - 20,0388654109711 
7,08100000000000 - 11,9727776995465 
6,54700000000000 - 4,30957125945115 
5,75500000000000 - 4,62283173198718 
4,93600000000000 - 7,58213354628093 
4,21900000000000 3,69245803194862 4,88491418533692 
ECM - 0.14 32,707 
 
Observando los resultados se puede concluir que los mejores resultados las obtuvieron las redes 
de 1 paso. Tanto con una ventana de 6 tiempos diferidos como sin ella. Entre estas dos el mejor 
resultado es el de una única ventana. 
La red de 6 pasos si ventana diferida presenta un error no tan grave considerado que el espacio 
de muestras de ejemplos es más reducido que para la red anterior. 
El peor error lo tiene la red de 6 pasos con las 6 ventanas de tiempo diferido esto es debido a que 
a las ventanas se le suma la pequeña cantidad de datos de entrenamiento lo que hace más difícil 
llegar a un buen entrenamiento de la red lo que produce poco poder de predicción. 
 
 
 
 
 
 
 
 
IA 2017 – TP3EVAL - #41 
Código Red 1 paso sin ventana 
 
%%% TP3 PUNTO 3 RED 1 PASO%%% 
%%% Cargamos y preparamos los datos para poder usarlos para entrenamiento y 
prueba 
load('lluvia1paso.mat'); 
load('caudal1paso.mat'); 
entradaLluvia1Paso = lluvia1paso'; 
salidaCaudal1Paso = caudal1paso'; 
 
 
%%Con este parametro cambiamos la ventana 
N = 1; 
 
%%% Comenzamos con la red1 
entradaRed1Paso = entradaLluvia1Paso(1:end - N); 
salidaRed1Paso = salidaCaudal1Paso(1:end - N); 
%%% Estos dos datos son la entrada y salida para el entrenamiento de la red 
 
 
%%% Ahora creamos los datos para prediccion y pruebas 
entradaRed1PasoTest = entradaLluvia1Paso(end - N + 1:end); 
salidaRed1PasoTest = salidaCaudal1Paso(end - N + 1:end); 
 
 
%Seleccionamos la funcion de entrenamiento por defecto 
trainFcn = 'trainlm'; 
%Estamos trabajando con una unica ventana 
delay = N; 
%Colocamos el numero de neuronas a usar en la capa oculta 
neuronsHiddenLayer = 30; 
 
%Creamos la red neuronal 
Red1Paso = timedelaynet(1:N, neuronsHiddenLayer, trainFcn); 
 
%Verificamos las funciones de activacion de la capa oculta y salida 
%Modificando por la funcion deseada 
Red1Paso.layers{1}.transferFcn = 'tansig'; 
Red1Paso.layers{2}.transferFcn = 'purelin'; 
 
%Preparamos de los datos de entrenamiento y test 
[Xs, Xi, Ai, Ts] = preparets(Red1Paso, entradaRed1Paso, salidaRed1Paso); 
%Realizamos la distribucion de los datos en 80 entrenamiento y 20 test 
Red1Paso.divideParam.trainRatio = 80/100; 
Red1Paso.divideParam.valRatio = 20/100; 
Red1Paso.divideParam.testRatio = 0/100; 
 
%Luego dividimos los datos de forma aleatoria 
Red1Paso.divideFcn = 'dividerand'; 
%Dividimos cada valor 
Red1Paso.divideMode = 'time'; 
%Usamos como funcion de rendimiento el error cuadratico medio 
Red1Paso.performFcn = 'mse'; 
 
%Una vez definidos todos los parametros podemos comenzar a entrenar la red 
Red1Paso = train(Red1Paso, Xs, Ts, Xi, Ai); 
 
%El diagrama de la red se muestra a continuacion 
view(Red1Paso); 
 
%Realizamos las predicciones 
[Y, Xf, Af] = Red1Paso(Xs, Xi, Ai); 
[yPred, Xfp, Afp] = Red1Paso(entradaRed1PasoTest, Xf, Af); 
 
%Para comparar los resultados realizamos el grafico 
IA 2017 – TP3EVAL - #42 
figure; 
originalSeries = salidaCaudal1Paso; 
predictionSeries = salidaCaudal1Paso; 
 
predictionSeries(end - N + 1:end) = yPred; 
 
%Representamos el grafico 
plot(1:length(salidaCaudal1Paso), cell2mat(predictionSeries), 'r', 
1:length(salidaCaudal1Paso),cell2mat(originalSeries), 'b'); 
legend('Serie de Predicción', 'Serie Original', 'Location', 'SouthEast'); 
 
Codigo Red 1 paso 6 ventanas tiempo diferido 
 
%%% TP3 PUNTO 3 RED 1 PASO / 6 VENTANAS%%% 
%%% Cargamos y preparamos los datos para poder usarlos para entrenamiento y 
prueba 
load('lluvia1paso.mat'); 
load('caudal1paso.mat'); 
entradaLluvia1Paso = lluvia1paso'; 
salidaCaudal1Paso = caudal1paso'; 
 
 
%%Con este parametro cambiamos la ventana 
N = 6; 
 
%%% Comenzamos con la red 1 
entradaRed1Paso = entradaLluvia1Paso(1:end - N); 
salidaRed1Paso = salidaCaudal1Paso(1:end - N); 
%%% Estos dos datos son la entrada y salida para el entrenamiento de la red 
 
 
%%% Ahora creamos los datos para prediccion y pruebas 
entradaRed1PasoTest = entradaLluvia1Paso(end - N + 1:end); 
salidaRed1PasoTest = salidaCaudal1Paso(end - N + 1:end); 
 
 
%Seleccionamos la funcion de entrenamiento por defecto 
trainFcn = 'trainlm'; 
%Estamos trabajando con una unica ventana 
delay = N; 
%Colocamos el numero de neuronas a usar en la capa oculta 
neuronsHiddenLayer = 30; 
 
%Creamos la red neuronal 
Red1Paso = timedelaynet(1:N, neuronsHiddenLayer, trainFcn); 
 
%Verificamos las funciones de activacion de la capa oculta y salida 
%Modificando por la funcion deseada 
Red1Paso.layers{1}.transferFcn = 'tansig'; 
Red1Paso.layers{2}.transferFcn = 'purelin'; 
 
%Preparamos de los datos de entrenamiento y test 
[Xs, Xi, Ai, Ts] = preparets(Red1Paso, entradaRed1Paso, salidaRed1Paso); 
%Realizamos la distribucion de los datos en 80 entrenamiento y 20 test 
Red1Paso.divideParam.trainRatio = 80/100; 
Red1Paso.divideParam.valRatio = 20/100; 
Red1Paso.divideParam.testRatio = 0/100; 
 
%Luego dividimos los datos de forma aleatoria 
Red1Paso.divideFcn = 'dividerand'; 
%Dividimos cada valor 
Red1Paso.divideMode = 'time'; 
IA 2017 – TP3EVAL - #43 
%Usamos como funcion de rendimiento el error cuadratico medio 
Red1Paso.performFcn = 'mse'; 
 
%Una vez definidos todos los parametros podemos comenzar a entrenar la red 
Red1Paso = train(Red1Paso, Xs, Ts, Xi, Ai); 
 
%El diagrama de la red se muestra a continuacion 
view(Red1Paso); 
 
%Realizamos las predicciones 
[Y, Xf, Af] = Red1Paso(Xs, Xi, Ai); 
[yPred, Xfp, Afp] = Red1Paso(entradaRed1PasoTest, Xf, Af); 
 
%Para comparar los resultados realizamos el grafico 
figure; 
originalSeries = salidaCaudal1Paso; 
predictionSeries = salidaCaudal1Paso; 
 
predictionSeries(end - N + 1:end) = yPred; 
 
%Representamos el grafico 
plot(1:length(salidaCaudal1Paso), cell2mat(predictionSeries), 'r', 
1:length(salidaCaudal1Paso),cell2mat(originalSeries), 'b'); 
legend('Serie de Predicción', 'Serie Original', 'Location', 'SouthEast'); 
 
Codigo Red 6 pasos sin ventana 
 
%%% TP3 PUNTO 3 RED 6 PASOS %%% 
%%% Cargamos y preparamos los datos para poder usarlos para entrenamiento y 
prueba 
load('lluvia6pasos.mat'); 
load('caudal6pasos.mat'); 
 
entradaLluvia6Pasos = lluvia6pasos'; 
salidaCaudal6Pasos = caudal6pasos'; 
 
 
%%Con este parametro cambiamos la ventana 
 
N = 1; 
 
%%% Comenzamos con la red 1 
entradaRed6Pasos = entradaLluvia6Pasos(1:end - N); 
salidaRed6Pasos = salidaCaudal6Pasos(1:end - N); 
%%% Estos dos datos son la entrada y salida para el entrenamiento de la red 
 
 
%%% Ahora creamos los datos para prediccion y pruebas 
entradaRed6PasosTest = entradaLluvia6Pasos(end - N + 1:end); 
salidaRed6PasosTest = salidaCaudal6Pasos(end - N + 1:end); 
 
 
%Seleccionamos la funcion de entrenamiento por defecto 
trainFcn = 'trainlm'; 
%Estamos trabajando con una unica ventana 
delay = N; 
%Colocamos el numero de neuronas a usar en la capa oculta 
neuronsHiddenLayer = 30; 
 
%Creamos la red neuronal 
IA 2017 – TP3EVAL - #44 
Red6Pasos = timedelaynet(1:N, neuronsHiddenLayer, trainFcn); 
 
%Verificamos las funciones de activacion de la capa oculta y salida 
%Modificando por la funcion deseada 
Red6Pasos.layers{1}.transferFcn = 'tansig'; 
Red6Pasos.layers{2}.transferFcn = 'purelin'; 
 
%Preparamos de los datos de entrenamiento y test 
[Xs,Xi, Ai, Ts] = preparets(Red6Pasos, entradaRed6Pasos, salidaRed6Pasos); 
%Realizamos la distribucion de los datos en 80 entrenamiento y 20 test 
Red6Pasos.divideParam.trainRatio = 80/100; 
Red6Pasos.divideParam.valRatio = 20/100; 
Red6Pasos.divideParam.testRatio = 0/100; 
 
%Luego dividimos los datos de forma aleatoria 
Red6Pasos.divideFcn = 'dividerand'; 
%Dividimos cada valor 
Red6Pasos.divideMode = 'time'; 
%Usamos como funcion de rendimiento el error cuadratico medio 
Red6Pasos.performFcn = 'mse'; 
 
%Una vez definidos todos los parametros podemos comenzar a entrenar la red 
Red6Pasos = train(Red6Pasos, Xs, Ts, Xi, Ai); 
 
%El diagrama de la red se muestra a continuacion 
view(Red6Pasos); 
 
%Realizamos las predicciones 
[Y, Xf, Af] = Red6Pasos(Xs, Xi, Ai); 
[yPred, Xfp, Afp] = Red6Pasos(entradaRed6PasosTest, Xf, Af); 
 
%Para comparar los resultados realizamos el grafico 
figure; 
originalSeries = salidaCaudal6Pasos; 
predictionSeries = salidaCaudal6Pasos; 
 
predictionSeries(end - N + 1:end) = yPred; 
 
%Representamos el grafico 
plot(1:length(salidaCaudal6Pasos), cell2mat(predictionSeries), 'r', 
1:length(salidaCaudal6Pasos),cell2mat(originalSeries), 'b'); 
legend('Serie de Predicción', 'Serie Original', 'Location', 'SouthEast'); 
 
Codigo Red 6 pasos 6 ventanas 
 
%%% TP3 PUNTO 3 RED 6 PASOS / 6 VENTANAS %%% 
%%% Cargamos y preparamos los datos para poder usarlos para entrenamiento y 
prueba 
load('lluvia6pasos.mat'); 
load('caudal6pasos.mat'); 
 
entradaLluvia6Pasos = lluvia6pasos'; 
salidaCaudal6Pasos = caudal6pasos'; 
 
 
%%Con este parametro cambiamos la ventana 
 
N = 6; 
 
%%% Comenzamos con la red 1 
entradaRed6Pasos = entradaLluvia6Pasos(1:end - N); 
IA 2017 – TP3EVAL - #45 
salidaRed6Pasos = salidaCaudal6Pasos(1:end - N); 
%%% Estos dos datos son la entrada y salida para el entrenamiento de la red 
 
 
%%% Ahora creamos los datos para prediccion y pruebas 
entradaRed6PasosTest = entradaLluvia6Pasos(end - N + 1:end); 
salidaRed6PasosTest = salidaCaudal6Pasos(end - N + 1:end); 
 
 
%Seleccionamos la funcion de entrenamiento por defecto 
trainFcn = 'trainlm'; 
%Estamos trabajando con una unica ventana 
delay = N; 
%Colocamos el numero de neuronas a usar en la capa oculta 
neuronsHiddenLayer = 30; 
 
%Creamos la red neuronal 
Red6Pasos = timedelaynet(1:N, neuronsHiddenLayer, trainFcn); 
 
%Verificamos las funciones de activacion de la capa oculta y salida 
%Modificando por la funcion deseada 
Red6Pasos.layers{1}.transferFcn = 'tansig'; 
Red6Pasos.layers{2}.transferFcn = 'purelin'; 
 
%Preparamos de los datos de entrenamiento y test 
[Xs, Xi, Ai, Ts] = preparets(Red6Pasos, entradaRed6Pasos, salidaRed6Pasos); 
%Realizamos la distribucion de los datos en 80 entrenamiento y 20 test 
Red6Pasos.divideParam.trainRatio = 80/100; 
Red6Pasos.divideParam.valRatio = 20/100; 
Red6Pasos.divideParam.testRatio = 0/100; 
 
%Luego dividimos los datos de forma aleatoria 
Red6Pasos.divideFcn = 'dividerand'; 
%Dividimos cada valor 
Red6Pasos.divideMode = 'time'; 
%Usamos como funcion de rendimiento el error cuadratico medio 
Red6Pasos.performFcn = 'mse'; 
 
%Una vez definidos todos los parametros podemos comenzar a entrenar la red 
Red6Pasos = train(Red6Pasos, Xs, Ts, Xi, Ai); 
 
%El diagrama de la red se muestra a continuacion 
view(Red6Pasos); 
 
%Realizamos las predicciones 
[Y, Xf, Af] = Red6Pasos(Xs, Xi, Ai); 
[yPred, Xfp, Afp] = Red6Pasos(entradaRed6PasosTest, Xf, Af); 
 
%Para comparar los resultados realizamos el grafico 
figure; 
originalSeries = salidaCaudal6Pasos; 
predictionSeries = salidaCaudal6Pasos; 
 
predictionSeries(end - N + 1:end) = yPred; 
 
%Representamos el grafico 
plot(1:length(salidaCaudal6Pasos), cell2mat(predictionSeries), 'r', 
1:length(salidaCaudal6Pasos),cell2mat(originalSeries), 'b'); 
legend('Serie de Predicción', 'Serie Original', 'Location', 'SouthEast');