Para la elaboración del trabajo de fin de curso he seleccionado

“Series Temporales Avanzadas: Aplicación de Redes Neuronales para el Pronóstico de Series de

Tiempo” ubicado en https://masteres.ugr.es/estadistica-aplicada/sites/master/moea/public/inline-files/TFM_FernAndez%20SalgueroRicardo%20Alonzo.pdf

El estudio de fin de grado que muestra la utilidad de las Redes Neuronales para predecir valores
futuros en lo que respecta a series de tiempo

Ejemplificando un modelo tradicional como es el modelo ARIMA, con una red neuronal simple, una
red neuronal recurrente simple y una red neuronal de memoria a largo plazo y corto plazo, se observa
diferencias en cuanto la capacidad predictiva de estos modelos, sin embargo se recalca que tanto los
modelos tradicionales como las redes neuronales tienen ventajas y desventajas, los modelos
tradicionales son muy útiles en problemas más sencillos o con pocos datos, mientras que las redes
neuronales son ventajosas en contextos de grandes volúmenes de datos. Se presenta una exposición
teórica de estos modelos y una aplicación práctica con Keras y Tensorflow.

Este trabajo pretende mostrar el uso de redes neuronales aplicadas a series de tiempo y parte de la
nueva tendencia de aplicar Deep learning a las finanzas y que no solo alivia algunos de los problemas
analíticos y de previsión, sino que también conduce a un cambio de paradigma en el análisis financiero
empírico, que hoy en día, crece a pasos exponenciales.

Con el advenimiento de la era inteligente y la creciente demanda de pronósticos de series de tiempo

financieras, el aprendizaje profundo se ha convertido en una aplicación de futuro e incluso de presente
exitoso en el sector financiero.

El aprendizaje profundo se utiliza ampliamente para la previsión del mercado financiero, como es en:

• La previsión de volatilidad,

• La previsión de precios y

• La previsión de tendencias

La investigación en el aprendizaje automático y a su vez en el aprendizaje profundo se concentra en:

• Diseñar nuevas arquitecturas

• Ajustar varias estructuras de tiempo, de múltiples variables.

• Ejecutar e integrar soluciones diversas

• Con el propósito genera de producir mejores resultados predictivos.

En el estudio, tras una introducción a las redes neuronales nos presenta los modelos ARIMA, el
algoritmo de descenso de gradiente y el de retropropagación.

Las herramientas que presenta en el estudio para el aprendizaje automático son Tensorflow y Keras,
de las que valora que desde el aprendizaje profundo ha convertido al Deep Learning en una actividad
mucho más sencilla.

En base a estas herramientas nos presenta el siguiente caso práctico:

1
En un entorno donde se tiene instalado Python se puede trabajar con Tensorflow y Keras en R, así por
ejemplo se dispondrá de un cuaderno de Google Collaboratory para mostrar cómo trabajar con R, de
forma que cualquier lector pueda seguir lo que se menciona en este capítulo tanto si lo quiere hacer
en su propio entorno como si lo desea hacer en el entorno del cuaderno dispuesto.

El siguiente es el enlace al cuaderno:

https://n9.cl/pd0jt

Desde este enlace el lector podrá ingresar al cuaderno, en cada sesión deberá secuencialmente correr
cada celda para instalar paquetes.

Los pasos según la metodología convencional para elaborar una red neuronal (Kelleher, 2019) son:

• Decida la duración de su serie de tiempo;

• La duración de una ventana de tiempo del modelo;

• Extraiga todos sus datos en un conjunto de datos de series de tiempo;

• Decida cómo desea preprocesar sus datos (si existe tal preprocesamiento) para obtener un conjunto
de datos para su modelo y

• Desarrolle un modelo que sea capaz de analizar sus datos de series de

tiempo. Considerar la longitud de los datos y longitud de la ventana que se usará, es probable que un
modelo tradicional sea más que una red neuronal en contextos de pocos datos.

• Definir la función de activación de cada nodo. Esta función asigna un valor real (por ejemplo, 1 para
un estado activado y 0 en caso contrario) a un nodo en cada paso de tiempo.

• Con el modelo se debe predecir el valor del estado.

• El modelo puede ampliarse mediante un bucle automático para predecir el futuro de un estado
determinado

Para instalar los paquetes Keras y Tensorflow se puede utilizar repositorios de rstudio como sigue:

devtools::install_github("rstudio/tensorflow")

devtools::install_github("rstudio/keras")

install.packages(’reticulate’)

A su vez se instaló reticulate por el entorno en relación a Python.

Para confirmar que Tensorflow se ha instalado correctamente se puede utilizar el siguiente código:

library(tensorflow)

tf$constant("Hellow Tensorflow")

La salida correcta es: "tf.Tensor(b’Hellow Tensorflow’, shape=(), dtype= string)"

2
Se necesitan además otros paquetes para trabajar, entre ellos están quantmod, forecast y tidyverse.

El primer ejemplo que se puede mostrar es la comparación entre modelos

ARIMA y una red neuronal simple.

A partir de quantmod se pueden extraer datos financieros que se descargan de Yahoo Finance, por
ejemplo, con el siguiente código:

#Obtener datos de:

#S&P 500 (EE. UU.)(GSPC)

Gráfico: Datos de volumen y precio de SP500 descargados a partir de quantmod

#Dow Jones (EE. UU.)(DJI)

#NASDAQ (EE. UU.)(IXIC)
#Nikkei 225 (Japón)(N225)
#Índice de componentes de Shenzen (China)(399001.SZ)
#Índice S&P/NZX 50 bruto (Nueva Zelanda)(NZ50)
#Índice ponderado TSEC (Taiwán)(TWII)
tickers <- c("^GSPC", "^DJI" ,"^IXIC" ,"^N225" ,"399001.SZ", "^NZ50", "^TWII")
getSymbols(tickers, src = "yahoo", from = "1927-01-01", periodicity= "daily")
chartSeries(GSPC)
chartSeries(DJI)
chartSeries(IXIC)

Con chartSeries se graficas las siguientes series de tiempo:

Para SP500:

Con lo cual se puede evidenciar los datos históricos de SP500, pero se escoge en todas las series solo
los valores ajustados.

3
Gráfico: Datos de volumen y precio de Dow Jones descargados a partir de quantmod

Se grafica además Dow Jones.

Para observar sus tendencias, desde todos los datos del repositorio de Yahoo Finance.

Por último se puede observar datos de NASDAQ una bolsa tecnológica.

El paquete forecast tiene nnetar que es una función con una red neuronal que es fácilmente
comparable a los modelos ARIMA, pero que atraparían las relaciones no lineales de las series
temporales.

ADJSP500=GSPC$GSPC.Adjusted
ADJDJI=DJI$DJI.Adjusted
ADJSIXIC=IXIC$IXIC.Adjusted
modeloIXIC<-auto.arima(ADJSIXIC)
modeloIXICN<-nnetar(ADJSIXIC)
modeloDJI<-auto.arima(ADJDJI)
modeloDJIN<-nnetar(ADJDJI)
modeloSP500<-auto.arima(ADJSP500)
modeloSP500N<-nnetar(ADJSP500)

Una vez creados todos los modelos se pueden hacer predicciones.

Gráfico: Datos de volumen y precio de NASDAQ descargados a partir de quantmod

4
Por ejemplo por rangos de tiempo de 100 días
plot(forecast(modeloIXIC, h=100))
plot(forecast(modeloIXICN, h=100))
plot(forecast(modeloDJI, h=100))
plot(forecast(modeloDJIN, h=100))
plot(forecast(modeloSP500, h=100))
plot(forecast(modeloSP500N, h=100))

Aquí mostramos algunas gráficas de estos modelos.

Por ejemplo las correspondientes a NASDAQ en cuanto a su modelo ARIMA y el modelo de la red
neuronal simple.

Este corresponde al modelo ARIMA, se observa una tendencia positiva para los próximos 100 días.

Este corresponde al modelo NNAR, se observa una tendencia constante para los próximos 100 días.

Ambos modelos difieren, por lo que en diferentes contextos, unos son más pesimistas que otros, sin
embargo NNAR reconoce algunos patrones no lineales, por lo que puede tener una ventaja.

Gráfico: Predicción a 100 días con ARIMA de NASDAQ

Otro ejemplo que se puede hacer es con las RNN y LSTM

Para el ejemplo usando Keras, se plantea los mismos datos creados artificialmente:

library(keras)
N = 400
step = 2
set.seed(123)
n = seq(1:N)
a = n/10+4*sin(n/10)+sample(-1:6,N,replace=T)+rnorm(N)
a = c(a,replicate(step,tail(a,1)))

De este modo tendremos datos que usar para las redes neuronales.

x = NULL

5
y = NULL
for(i in 1:N)
{
s = i-1+step
x = rbind(x,a[i:s])
y = rbind(y,a[s+1])
}
X = array(x, dim=c(N,step,1))

Gráfico: Predicción a 100 días con NNAR de NASDAQ

Lo anterior es una pequeña estructuración de los datos, que es útil para que la red neuronal pueda
procesarlos, serán entonces necesarios entradas como salidas.

Primero se crea un modelo RNN simple, con sus neuronas correspondientes, utilizando en este caso la
función de activición ReLU.

La gran ventaja que tiene Keras es que crear modelos es muy sencillo, como se observa a continuación:

#Creación del modelo

model = keras_model_sequential() %>%
layer_simple_rnn(units=128, input_shape=c(step, 1), activation="relu") %>%
layer_dense(units=64, activation = "relu") %>%
layer_dense(units=32) %>%
layer_dense(units=1, activation = "linear")

#Compilación del modelo usando mse y el optimizador de adam

model %>% compile(loss = ’mse’, optimizer = ’adam’, metrics = list("mean_absolute_error") )

Cuadro 8.1: Resumen del modelo de RNN

Model: "sequential"

_____________________

6
Layer (type) Output Shape Param #
=========================
simple_rnn (SimpleRNN) (None, 128) 16640
___________________________
dense_2 (Dense) (None, 64) 8256
___________________________
dense_1 (Dense) (None, 32) 2080
___________________________
dense (Dense) (None, 1) 33
========================
Total params: 27,009
Trainable params: 27,009
Non-trainable params: 0
__________________________
loss mean_absolute_error
9.478787 2.536582

#Resumen del modelo

model %>% summary()
model %>% fit(X,y, epochs=50, batch_size=32, shuffle = FALSE, verbose=0)
y_pred = model %>% predict(X)

#Evaluación
scores = model %>% evaluate(X, y, verbose = 0)
print(scores)

#Graficando
x_axes = seq(1:length(y_pred))
plot(x_axes, y, type="l", col="red", lwd=2)
lines(x_axes, y_pred, col="blue",lwd=2)
legend("topleft", legend=c("y-original", "y-predicted"),
col=c("red", "blue"), lty=1,cex=0.8)

Tiene un error medio absoluto de 2.53

Por último crearemos un modelo LSTM que solo es necesario modificar un poco al modelo con la
función layerlstm y quedaría de la siguiente manera:

Cuadro 8.2: Resumen del modelo de LSTM

Model: "sequential_3"
________________________
Layer (type) Output Shape Param #
=====================
lstm (LSTM) (None, 128) 66560
_________________________

7
 dense_11 (Dense) (None, 64) 8256
_________________________
dense_10 (Dense) (None, 32) 2080
________________________
dense_9 (Dense) (None, 1) 33
======================
Total params: 76,929
Trainable params: 76,929
Non-trainable params: 0
________________________
loss mean_absolute_error
9.426416 2.550603
Tiene un error medio absoluto de 2.550785

Esto muestra la alta adecuación entre los modelos de redes neuronales y los datos.

Observando los cuadros de resumen por ejemplo se uso el mismo número de neuronas ocultas tanto
en RNN y LSTM, con 3 capas ocultas para ambos modelos, evidentemente por la arquitectura de las
LSTM se tendrán mayor número de parámetros en estas redes neuronales.

En este caso al ser 2.53<2.55 con esta arquitectura las redes neuronales LSTM tienen mayor error
medio absoluto que las RNN.

Observando tanto el gráfico de las RNN como de las LSTM se observa que las redes neuronales buscan
adecuarse de forma ajustada a los datos.

Sin embargo siempre los investigadores deberán evitar los problemas del sobreajuste, estas redes
neuronales son especialmente susceptibles a ello, por lo que siempre se debe testear una buena
generalización.

8
Figura: Predicción de RNN, datos originales versus predichos

9
Figura: Predicción de LSTM, datos originales versus predichos

10
Anexo: Código utilizado

#Instalción Keras y Tensorflow

devtools::install_github("rstudio/tensorflow")

devtools::install_github("rstudio/keras")

install.packages(’reticulate’)

Librerías útiles y utilizadas

# Core Tidyverse

library(tidyverse)

library(glue)

library(forcats)

# Series temporales

library(timetk)

library(tidyquant)

library(tibbletime)

# Visualización

library(cowplot)

# Preprocesado

library(recipes)

# Muestreo

library(rsample)

library(yardstick)

# Modelado

library(keras)

library(quantmod)

library(forecast)

library(neuralnet)

DATOS para modelar

#Obtener datos de:

#S&P 500 (EE. UU.)(GSPC)

11
 #Dow Jones (EE. UU.)(DJI)

#NASDAQ (EE. UU.)(IXIC)

#Nikkei 225 (Japón)(N225)

#Índice de componentes de Shenzen (China)(399001.SZ)

#Índice S&P/NZX 50 bruto (Nueva Zelanda)(NZ50)

#Índice ponderado TSEC (Taiwán)(TWII)

tickers <- c("^GSPC", "^DJI" ,"^IXIC" ,"^N225" ,"399001.SZ", "^NZ50",

"^TWII")

getSymbols(tickers, src = "yahoo", from = "1927-01-01",

periodicity= "daily")

chartSeries(GSPC)

chartSeries(DJI)

chartSeries(IXIC)

Modelos ARIMA y NNAR

ADJSP500=GSPC$GSPC.Adjusted

ADJDJI=DJI$DJI.Adjusted

ADJSIXIC=IXIC$IXIC.Adjusted

modeloIXIC<-auto.arima(ADJSIXIC)

modeloIXICN<-nnetar(ADJSIXIC)

modeloDJI<-auto.arima(ADJDJI)

modeloDJIN<-nnetar(ADJDJI)

modeloSP500<-auto.arima(ADJSP500)

modeloSP500N<-nnetar(ADJSP500)

Ejemplo RNN

library(keras)

N = 400

step = 2

set.seed(123)

12
 n = seq(1:N)

a = n/10+4*sin(n/10)+sample(-1:6,N,replace=T)+rnorm(N)

a = c(a,replicate(step,tail(a,1)))

DATOS y manipulación de datos

x = NULL

y = NULL

for(i in 1:N)

s = i-1+step

x = rbind(x,a[i:s])

y = rbind(y,a[s+1])

X = array(x, dim=c(N,step,1))

#Creación del modelo

model = keras_model_sequential() %>%

layer_simple_rnn(units=128, input_shape=c(step, 1), activation="relu") %>%

layer_dense(units=64, activation = "relu") %>%

layer_dense(units=32) %>%

layer_dense(units=1, activation = "linear")

#Compilación del modelo usando mse y el optimizador de adam

model %>% compile(loss = ’mse’,

optimizer = ’adam’,

metrics = list("mean_absolute_error")

#Resumen del modelo

model %>% summary()

model %>% fit(X,y, epochs=50, batch_size=32, shuffle = FALSE, verbose=0)

y_pred = model %>% predict(X)

#Evaluación

13
 scores = model %>% evaluate(X, y, verbose = 0)

print(scores)

#Graficando

x_axes = seq(1:length(y_pred))

plot(x_axes, y, type="l", col="red", lwd=2)

lines(x_axes, y_pred, col="blue",lwd=2)

legend("topleft", legend=c("y-original", "y-predicted"),

col=c("red", "blue"), lty=1,cex=0.8)

#Creación del modelo

model = keras_model_sequential() %>%

layer_lstm(units=128, input_shape=c(step, 1), activation="relu") %>%

layer_dense(units=64, activation = "relu") %>%

layer_dense(units=32) %>%

layer_dense(units=1, activation = "linear")

#Compilación del modelo usando mse y el optimizador de adam

model %>% compile(loss = ’mse’,

optimizer = ’adam’,

metrics = list("mean_absolute_error")

#Resumen del modelo

model %>% summary()

model %>% fit(X,y, epochs=50, batch_size=32, shuffle = FALSE, verbose=0)

y_pred = model %>% predict(X)

#Evaluación

scores = model %>% evaluate(X, y, verbose = 0)

print(scores)

#Graficando

x_axes = seq(1:length(y_pred))

plot(x_axes, y, type="l", col="red", lwd=2)

14
lines(x_axes, y_pred, col="blue",lwd=2)

legend("topleft", legend=c("y-original", "y-predicted"),

col=c("red", "blue"), lty=1,cex=0.8)

15