Análisis de series temporales con LSTM utilizando la biblioteca Keras de Python

A

Introducción

El análisis de series de tiempo se refiere al análisis del cambio en la tendencia de los datos durante un período de tiempo. El análisis de series de tiempo tiene una variedad de aplicaciones. Una de esas aplicaciones es la predicción del valor futuro de un artículo en función de sus valores pasados. La predicción del precio futuro de las acciones es probablemente el mejor ejemplo de tal aplicación. En este artículo, veremos cómo podemos realizar análisis de series de tiempo con la ayuda de un red neuronal recurrente. Estaremos prediciendo los precios futuros de las acciones de Apple Company (AAPL), basados ​​en los precios de sus acciones de los últimos 5 años.

Conjunto de datos

Los datos que vamos a utilizar para este artículo se pueden descargar desde Yahoo Finanzas. Para entrenar nuestro algoritmo, utilizaremos los precios de las acciones de Apple desde el 1 de enero de 2013 hasta el 31 de diciembre de 2017. En aras de la predicción, usaremos los precios de las acciones de Apple para el mes de enero de 2018. Por lo tanto, para evaluar el rendimiento de el algoritmo, descargue también los precios reales de las acciones para el mes de enero de 2018.

Veamos ahora cómo se ven nuestros datos. Abra el archivo de entrenamiento de precios de acciones de Apple que contiene datos de cinco años. Verá que contiene siete columnas: Fecha, Abrir, Alto, Bajo, Cerrar, Cerrar Adj y Volumen. Estaremos prediciendo el precio de apertura de las acciones, por lo tanto, no estamos interesados ​​en el resto de las columnas.

Si grafica los precios de las acciones de apertura contra la fecha, verá la siguiente gráfica:

Puede ver que la tendencia es muy no lineal y es muy difícil capturar la tendencia utilizando esta información. Aquí es donde el poder de LSTM se puede utilizar. LSTM (Long Short-Term Memory network) es un tipo de red neuronal recurrente capaz de recordar la información pasada y, al predecir los valores futuros, tiene en cuenta esta información pasada.

Basta de preliminares, veamos cómo se puede usar LSTM para el análisis de series de tiempo.

Predecir los precios futuros de las acciones

La predicción del precio de las acciones es similar a cualquier otro problema de Machine Learning en el que se nos proporciona un conjunto de características y tenemos que predecir un valor correspondiente. Realizaremos los mismos pasos que realizamos para resolver cualquier problema de Machine Learning. Sigue estos pasos:

Importar bibliotecas

El primer paso, como siempre, es importar las bibliotecas necesarias. Ejecute el siguiente script para hacerlo:

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

Importar conjunto de datos

Ejecute el siguiente script para importar el conjunto de datos. Por el bien de este artículo, los datos se han almacenado en la carpeta Conjuntos de datos, dentro de la unidad “E”. Puede cambiar la ruta en consecuencia.

apple_training_complete = pd.read_csv(r'E:Datasetsapple_training.csv')

Como dijimos anteriormente, solo nos interesa el precio de apertura de la acción. Por lo tanto, filtraremos todos los datos de nuestro conjunto de entrenamiento y solo conservaremos los valores para el Abierto columna. Ejecute el siguiente script:

apple_training_processed = apple_training_complete.iloc[:, 1:2].values

Normalización de datos

Como regla general, siempre que utilice una red neuronal, debe normalizar o escalar sus datos. Usaremos MinMaxScaler clase de la sklear.preprocessing biblioteca para escalar nuestros datos entre 0 y 1. La feature_range El parámetro se utiliza para especificar el rango de los datos escalados. Ejecute el siguiente script:

from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler(feature_range = (0, 1))

apple_training_scaled = scaler.fit_transform(apple_training_processed)

Convertir datos de entrenamiento a la forma correcta

Como dije antes, en un problema de series de tiempo, tenemos que predecir un valor en el tiempo T, basado en los datos de los días TN donde N puede ser cualquier número de pasos. En este artículo, vamos a predecir el precio de apertura de las acciones de los datos en función de los precios de apertura de las acciones de los últimos 60 días. Probé diferentes números y descubrí que los mejores resultados se obtienen cuando se utilizan los últimos 60 pasos de tiempo. Puede probar diferentes números y ver cómo funciona su algoritmo.

Nuestro conjunto de características debe contener los valores iniciales del precio de las acciones de los últimos 60 días, mientras que la etiqueta o variable dependiente debe ser el precio de las acciones al día 61. Ejecute el siguiente script para crear un conjunto de características y etiquetas.

features_set = []
labels = []
for i in range(60, 1260):
    features_set.append(apple_training_scaled[i-60:i, 0])
    labels.append(apple_training_scaled[i, 0])

En el script anterior creamos dos listas: feature_set y labels. Hay 1260 registros en los datos de entrenamiento. Ejecutamos un ciclo que comienza desde el registro 61 y almacena los 60 registros anteriores en el feature_set lista. El registro 61 se almacena en el labels lista.

Necesitamos convertir tanto el feature_set y el labels list a la matriz numpy antes de que podamos usarla para el entrenamiento. Ejecute el siguiente script:

features_set, labels = np.array(features_set), np.array(labels)

Para entrenar a LSTM en nuestros datos, necesitamos convertir nuestros datos en la forma aceptada por LSTM. Necesitamos convertir nuestros datos en formato tridimensional. La primera dimensión es el número de registros o filas en el conjunto de datos, que es 1260 en nuestro caso. La segunda dimensión es el número de pasos de tiempo que es 60 mientras que la última dimensión es el número de indicadores. Dado que solo estamos usando una función, es decir Abierto, el número de indicadores será uno. Ejecute el siguiente script:

features_set = np.reshape(features_set, (features_set.shape[0], features_set.shape[1], 1))

Entrenando el LSTM

Hemos preprocesado nuestros datos y los hemos convertido al formato deseado. ahora es el momento de crear nuestro LSTM. El modelo LSTM que vamos a crear será un modelo secuencial con múltiples capas. Agregaremos cuatro capas LSTM a nuestro modelo seguidas de una capa densa que predice el precio futuro de las acciones.

Primero importemos las bibliotecas que vamos a necesitar para crear nuestro modelo:

from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras.layers import Dropout

En el script anterior importamos el Sequential clase de keras.models biblioteca y Dense, LSTMy Dropout clases de keras.layers biblioteca.

Como primer paso, debemos crear una instancia del Sequential clase. Esta será nuestra clase de modelo y agregaremos capas LSTM, Dropout y Dense a este modelo. Ejecute el siguiente script

model = Sequential()

Creación de capas LSTM y Dropout

Agreguemos la capa LSTM al modelo que acabamos de crear. Ejecute el siguiente script para hacerlo:

model.add(LSTM(units=50, return_sequences=True, input_shape=(features_set.shape[1], 1)))

Para agregar una capa al modelo secuencial, el add se utiliza el método. Dentro de add método, pasamos nuestra capa LSTM. El primer parámetro de la capa LSTM es el número de neuronas o nodes que queremos en la capa. El segundo parámetro es return_sequences, que se establece en true ya que agregaremos más capas al modelo. El primer parámetro del input_shape es el número de pasos de tiempo mientras que el último parámetro es el número de indicadores.

Agreguemos ahora una capa de exclusión a nuestro modelo. Se agrega una capa de abandono para evitar el ajuste excesivo, que es un fenómeno en el que un modelo de Machine Learning funciona mejor en los datos de entrenamiento en comparación con los datos de prueba. Ejecute el siguiente script para agregar una capa de abandono.

model.add(Dropout(0.2))

Agreguemos tres capas LSTM y de abandono más a nuestro modelo. Ejecute el siguiente script.

model.add(LSTM(units=50, return_sequences=True))
model.add(Dropout(0.2))

model.add(LSTM(units=50, return_sequences=True))
model.add(Dropout(0.2))

model.add(LSTM(units=50))
model.add(Dropout(0.2))

Creando una capa densa

Para hacer nuestro modelo más robusto, agregamos una capa densa al final del modelo. El número de neuronas en la capa densa se establecerá en 1 ya que queremos predecir un solo valor en la salida.

model.add(Dense(units = 1))

Compilación de modelos

Finalmente, necesitamos compilar nuestro LSTM antes de poder entrenarlo con los datos de entrenamiento. El siguiente script compila nuestro modelo.

model.compile(optimizer="adam", loss="mean_squared_error")

Llamamos al método de compilación en el objeto de modelo secuencial que es “modelo” en nuestro caso. Usamos el error medio cuadrado como función de pérdida y para reducir la pérdida o para optimizar el algoritmo, utilizamos la Adán optimizador.

Entrenamiento de algoritmos

Ahora es el momento de entrenar el modelo que definimos en los pasos anteriores. Para hacerlo, llamamos al fit método en el model y transmítale nuestras características y etiquetas de capacitación como se muestra a continuación:

model.fit(features_set, labels, epochs = 100, batch_size = 32)

Dependiendo de su hardware, el entrenamiento de modelos puede llevar algún tiempo.

Probando nuestro LSTM

Hemos entrenado con éxito nuestro LSTM, ahora es el momento de probar el rendimiento de nuestro algoritmo en el conjunto de prueba al predecir los precios de apertura de las acciones para el mes de enero de 2018. Sin embargo, como hicimos con los datos de entrenamiento, necesitamos convertir nuestro datos de prueba en el formato correcto.

Primero importemos nuestros datos de prueba. Ejecute el siguiente script:

apple_testing_complete = pd.read_csv(r'E:Datasetsapple_testing.csv')
apple_testing_processed = apple_testing_complete.iloc[:, 1:2].values

En el script anterior, importamos nuestros datos de prueba y, como hicimos con los datos de entrenamiento, eliminamos todas las columnas de los datos de prueba, excepto la columna que contiene los precios de las acciones de apertura.

Si los precios de apertura de las acciones para el mes de enero de 2018 se grafican contra las fechas, debería ver el siguiente gráfico.

Puede ver que la tendencia es muy no lineal. En general, los precios de las acciones experimentan un pequeño aumento a principios de mes, seguido de una tendencia a la baja a finales de mes, con un ligero aumento y disminución en los precios de las acciones en el medio. Es extremadamente difícil pronosticar tal tendencia. Veamos si el LSTM que entrenamos es realmente capaz de predecir tal tendencia.

Conversión de datos de prueba al formato correcto

Para cada día de enero de 2018, queremos que nuestro conjunto de funciones contenga los precios de apertura de las acciones de los 60 días anteriores. Para el 1 de enero, necesitamos los precios de las acciones de los 60 días anteriores. Para hacerlo, necesitamos concatenar nuestros datos de entrenamiento y los datos de prueba antes del preprocesamiento. Ejecute el siguiente script para hacerlo:

apple_total = pd.concat((apple_training_complete['Open'], apple_testing_complete['Open']), axis=0)

Ahora preparemos nuestras entradas de prueba. La entrada para cada día debe contener los precios de apertura de las acciones de los 60 días anteriores. Eso significa que necesitamos los precios de apertura de las acciones para los 20 días de prueba para el mes de enero de 2018 y los 60 precios de las acciones de los últimos 60 días para el conjunto de capacitación. Ejecute el siguiente script para obtener esos 80 valores.

test_inputs = apple_total[len(apple_total) - len(apple_testing_complete) - 60:].values

Como hicimos con el conjunto de entrenamiento, necesitamos escalar nuestros datos de prueba. Ejecute el siguiente script:

test_inputs = test_inputs.reshape(-1,1)
test_inputs = scaler.transform(test_inputs)

Escalamos nuestros datos, ahora preparemos nuestro conjunto de entrada de prueba final que contendrá los 60 precios de las acciones anteriores para el mes de enero. Ejecute el siguiente script:

test_features = []
for i in range(60, 80):
    test_features.append(test_inputs[i-60:i, 0])

Finalmente, necesitamos convertir nuestros datos al formato tridimensional que se puede utilizar como entrada para el LSTM. Ejecute el siguiente script:

test_features = np.array(test_features)
test_features = np.reshape(test_features, (test_features.shape[0], test_features.shape[1], 1))

Haciendo predicciones

Ahora es el momento de ver la magia. Preprocesamos nuestros datos de prueba y ahora podemos usarlos para hacer predicciones. Para hacerlo, simplemente necesitamos llamar al predict método en el modelo que entrenamos. Ejecute el siguiente script:

predictions = model.predict(test_features)

Dado que escalamos nuestros datos, las predicciones realizadas por el LSTM también se escalan. Necesitamos revertir la predicción escalada a sus valores reales. Para hacerlo, podemos usar el ìnverse_transform método del objeto escalador que creamos durante el entrenamiento. Eche un vistazo al siguiente guión:

predictions = scaler.inverse_transform(predictions)

Finalmente, veamos qué tan bien nuestro algoritmo predijo los precios futuros de las acciones. Ejecute el siguiente script:

plt.figure(figsize=(10,6))
plt.plot(apple_testing_processed, color="blue", label="Actual Apple Stock Price")
plt.plot(predictions , color="red", label="Predicted Apple Stock Price")
plt.title('Apple Stock Price Prediction')
plt.xlabel('Date')
plt.ylabel('Apple Stock Price')
plt.legend()
plt.show()

La salida se ve así:

En la salida, la línea azul representa los precios de las acciones reales para el mes de enero de 2018, mientras que la línea roja representa los precios de las acciones pronosticados. Puede ver claramente que nuestro algoritmo ha podido capturar la tendencia general. Los precios previstos también ven una tendencia alcista al principio seguida de una tendencia bajista o bajista al final. Increíble, ¿no?

Conclusión

Una red de memoria a largo plazo a corto plazo (LSTM) es una de las redes neuronales más utilizadas para el análisis de series de tiempo. La capacidad de LSTM para recordar información previa lo hace ideal para tales tareas. En este artículo, vimos cómo podemos usar LSTM para la predicción del precio de las acciones de Apple. Le sugiero que descargue acciones de alguna otra organización como Google o Microsoft de Yahoo Finance y vea si su algoritmo es capaz de capturar las tendencias.

 

About the author

Ramiro de la Vega

Bienvenido a Pharos.sh

Soy Ramiro de la Vega, Estadounidense con raíces Españolas. Empecé a programar hace casi 20 años cuando era muy jovencito.

Espero que en mi web encuentres la inspiración y ayuda que necesitas para adentrarte en el fantástico mundo de la programación y conseguir tus objetivos por difíciles que sean.

Add comment

Sobre mi

Últimos Post

Etiquetas

Esta web utiliza cookies propias para su correcto funcionamiento. Al hacer clic en el botón Aceptar, aceptas el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Más información
Privacidad