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

    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 鈥嬧媏n 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 鈥嬧媏n 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.

     

    Etiquetas:

    Deja una respuesta

    Tu direcci贸n de correo electr贸nico no ser谩 publicada. Los campos obligatorios est谩n marcados con *