CREACIÓN DE LIBRERÍA PARA PREDICCIÓN DE SERIES …

CREACIÓN DE LIBRERÍA PARA PREDICCIÓN DE SERIES TEMPORALES DE

SEÑALES INDUSTRIALES (Library for forecasting time series data from

industrial sources)

Trabajo de Fin de Máster para acceder al

MÁSTER INTERUNIVERSITARIO EN CIENCIA DE DATOS

Autor: Miguel Murillo Gonzalez

Director\es: Verónica Pinilla Gómez Diego García Saíz

Julio - 2021

RESUMEN

En los últimos años la demanda por parte del campo de la industria y la manufactura de serviciosde ciencia de datos no ha hecho más que crecer. Entre los objetivos principales que tiene este sectordestacan la eficiencia energética y la optimización de demandas y procesos. En la mayoría de los casosesto depende de sistemas ya instalados, los cuales tienen limitaciones en cuanto a la variedad de datosde salida. Los datos de entrada de los problemas industriales suelen ser series de datos temporales,contando únicamente con la variable del momento en el que se toman los datos, y el dato en cuestión.

Una de las limitaciones o barreras de entrada a que las empresas y usuarios puedan generar mo-delos usando los datos correspondientes a sus procesos de manufactura es la curva de aprendizaje. Laciencia de datos es una disciplina que requiere bastante conocimiento previo, lo cual puede traducirseen el desistimiento por parte de usuarios inexpertos en el tema.

La predicción de series temporales (time series forecasting) es un problema muy común en cienciade datos, para el cual no se dispone todavía de herramientas que faciliten la aplicación de aprendizajeautomático o Machine Learning (ML). Es por ello que en este trabajo se va a elaborar una librería,desarrollada en el lenguaje de programación Python 3 y basada en herramientas disponibles de otraslibrerías ya establecidas, como Sci-kit Learn o Keras, para el análisis mediante Automated MachineLearning (AutoML) de series temporales. El objetivo principal es limitar los parámetros que se soli-citan al usuario, el cual puede no contar con conocimientos especializados de ciencia de datos pararealizar las predicciones, sino que solo deberá ejecutar un comando en Python, en el que incluirá lascaracterísticas básicas de su consulta, como por ejemplo el horizonte de predicción, o el tiempo en elfuturo al que se quiere conocer el dato, y la velocidad de procesamiento de la predicción.

Este trabajo, una colaboración entre Consulting Informático de Cantabria (CIC) y la Universidadde Cantabria (UC), tiene como motivación mejorar la accesibilidad de los métodos más comunesde predicción de series temporales, tanto para la industria en general, en el marco de la mejora deeficiencia y la promoción de la innovación sostenible (Objetivo de Desarrollo Sostenible (ODS) de laOrganización de las Naciones Unidas (ONU) número 9), como para la divulgación científica, al poderaportar una puerta de entrada a la ciencia de datos para personas inexpertas en el tema.

Palabras clave: Series Temporales, Predicción, Aprendizaje Automático, AutoML

iii

ABSTRACT

In recent years, demand for Data Science applied to industry and manufacturing has only increased.The main goals expected from the integration of data science methods are improvement of energyefficiency and intelligent process and supply chain management. The main barrier to overcome whenworking in an industrial setting is the reliance on often legacy and outdated hardware for takingmeasurements and gathering data. These systems present limitations especially in the variety of datathey can output. Input data in industrial problems often consists on uni-variate time series, havingonly available the raw measurements and the timestamps associated to it.

Another limitation, or barrier of entry for users or companies to add data science to their workflowregarding their manufacturing lines is the learning curve. Data science is a complex discipline thatrequires a lot of prior knowledge to apply, which can often make novice companies or users give upprematurely.

Time series forecasting is therefore a very common problem in data science, especially in theprivate sector, and one in which developement is still in early stages for the most part. Most solutionsrequire advanced knowledge and lack ease-of-use. The goal of this work is to, using the Python 3programming language, develop a library focused on auttomated time series forecasting. This libraryis based on others like Scikit-Learn and Keras, and aims to be user-friendly. The main objective ofthe package is to limit the parameters specified by the user, so that previous training in data scienceis not needed to work it. The user will only need to execute a command in Python with their query,specifying the forecasting horizon for the predition and the desired processing time, which will inturn determine the confidence of the prediction.

This work is a colaboration between Consulting Informático de Cantabria (CIC) and Universidadde Cantabria (UC), and has as a motivation to improve accessibility to the most commonly usedMachine Learning algorithms for time series prediction, both for Industrial applications, followingthe United Nations (UN) Sustainable Developement Goal (SDG) number 9, pertaining to sustainableindustrialization and innovation. It also has a presence in the Scientific dissemination space, allowingfor easy entry into time series prediction tasks, that can in turn be an entry into other Machine Learningproblems.

Palabras clave: Time Series, Forecasting, Machine Learning, AutoML

iii

ÍNDICE GENERAL

1. INTRODUCCIÓN. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

1.1. Descripción del problema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

1.2. Motivación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

1.3. Alcance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

2. FUNDAMENTO TEÓRICO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.1. Preparación de datos para predicción de series temporales . . . . . . . . . . . . . . . . . . . 4

2.1.1. Descomposición de series temporales . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.1.2. Modelos auto-regresivos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.1.3. Creación de características . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.1.4. Predicción recursiva . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.2. Modelos tradicionales para predicción de series temporales . . . . . . . . . . . . . . . . . . 8

2.2.1. Modelos Naïve . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.2.2. Modelo ARIMA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.3. Modelos de Machine Learning para series temporales . . . . . . . . . . . . . . . . . . . . . 9

2.3.1. Modelos Lineales Generalizados (GLM) . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2.3.2. Modelo basado en Árboles de Decisión y Gradient Boosting . . . . . . . . . . . . . . . 9

2.3.3. Modelos basados en redes neuronales recurrentes . . . . . . . . . . . . . . . . . . . . . 10

3. ESTADO DEL ARTE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

3.1. Librerías para series temporales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

3.1.1. Sktime. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

3.1.2. Skits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

3.1.3. Prophet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

3.2. AutoML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

3.2.1. Historia de AutoML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

3.2.2. Ejemplos de librerias de AutoML en Python . . . . . . . . . . . . . . . . . . . . . . . . 16

4. DESARROLLO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

4.1. Convenciones de estilo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

4.1.1. PEP8 - Guía de estilo en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

vi

ÍNDICE GENERAL

4.1.2. PEP257 - Docstrings. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

4.2. Organización de los módulos de la librería . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

4.2.1. Importación de datos data_input.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

4.2.2. Preprocesado de series temporales preprocessing.py . . . . . . . . . . . . . . . . . . . . 19

4.2.3. Predicción prediction.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

4.2.4. Cálculo de errores metrics.py. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

4.2.5. Representación de datos plotting.py. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

4.2.6. Pipelines pipelines.py. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

4.3. Integración continua y desarrollo continuo en git . . . . . . . . . . . . . . . . . . . . . . . . 23

4.3.1. Licencia de código abierto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

4.3.2. Testado de componentes del código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

4.4. Interfaz gráfica utilizando FastAPI y SwaggerUI . . . . . . . . . . . . . . . . . . . . . . . . 25

5. RESULTADOS Y DISCUSIÓN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

5.1. Metodología de obtención de resultados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

5.2. Inspección numérica de resultados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

5.2.1. Predicción rápida. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

5.2.2. Predicción media . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

5.2.3. Predicción lenta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

5.2.4. Predicción rápida con optimización de hiper-parámetros. . . . . . . . . . . . . . . . . . 31

5.2.5. Predicción media con optimización de hiper-parámetros . . . . . . . . . . . . . . . . . . 31

5.3. Inspección visual de los resultados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

5.3.1. Predicciones de la serie 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32




5.3.5. Mejoras de predicción con optimización de hiper-parámetros . . . . . . . . . . . . . . . 35

6. CONCLUSIÓN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

7. PRÓXIMOS PASOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

BIBLIOGRAFÍA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

vii

ÍNDICE DE FIGURAS

ÍNDICE DE FIGURAS

2.1 Ejemplo de descomposición de una serie temporal de ventas de equipos eléctricos [8] 6

2.2 Red neuronal recurrente desenrollada [13] . . . . . . . . . . . . . . . . . . . . . . . 10

2.3 Esquema de una neurona LSTM [13] . . . . . . . . . . . . . . . . . . . . . . . . . . 11

3.1 Ejemplo de predicción básico con la librería Prophet [1] . . . . . . . . . . . . . . . . 14

3.2 Representación del flujo de trabajo cubierto por AutoML [18] . . . . . . . . . . . . 14

3.3 Ejemplo de entrenamiento y predicción de serie temporal con AutoKeras [24] . . . . 16

3.4 Ejemplo de entrenamiento de modelo y predicción con AutoSklearn [22] . . . . . . . 17

4.1 Ejemplo de Docstring usando el estilo NumPy . . . . . . . . . . . . . . . . . . . . . 19

4.2 Imagen de la interfaz de usuario de la API (Swagger UI) . . . . . . . . . . . . . . . 25

5.1 Series de ejemplo incluidas con TS-AutoML . . . . . . . . . . . . . . . . . . . . . . 28

5.2 Datos reales vs predicciones de TS-AutoML sobre la serie 1 de ejemplo . . . . . . . 32




5.6 Comparaciones de la mejoría de predicción con optimización en la serie 4 . . . . . . 36

ix

ÍNDICE DE CUADROS

ÍNDICE DE CUADROS

2.1 Ejemplo de serie de datos univariada de demanda energética . . . . . . . . . . . . . 4

2.2 Ejemplo de DataFrame de pandas con lags creados . . . . . . . . . . . . . . . . . . 7

2.3 Ejemplo de DataFrame de pandas preparado con lags y características . . . . . . . . 7

5.1 Información de las series temporales de ejemplo . . . . . . . . . . . . . . . . . . . . 27

5.2 Relación de resultados para cada serie del modelo medio de predicción . . . . . . . . 29

5.3 Relación de resultados para cada serie del modelo medio de predicción . . . . . . . . 30

5.4 Relación de resultados para cada serie del modelo lento de predicción . . . . . . . . 30

5.5 Relación de resultados para cada serie del modelo rápido de predicción con 30 con-Figuraciones de optimización de hiper-parámetros . . . . . . . . . . . . . . . . . . . 31

5.6 Relación de resultados para cada serie del modelo medio de predicción con 50 conFi-guraciones de optimización de hiper-parámetros . . . . . . . . . . . . . . . . . . . . 31

7.1 Glosario de términos referenciados a lo largo del trabajo . . . . . . . . . . . . . . .

7.2 Lista de Acronimos (En orden alfabético) . . . . . . . . . . . . . . . . . . . . . . .

7.3 Enlaces a recursos del trabajo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

xi

1. INTRODUCCIÓN

1.1. Descripción del problema

En el ámbito industrial, la mejora continua y la optimización de procesos siempre ha sido unaprioridad. En las ultimas décadas, y con la popularización de la ciencia de datos, se ha recurrido a lainteligencia artificial para mejorar las planificaciones. En este contexto, es común que se busque elML para predecir demandas energéticas, producciones o señales industriales derivadas de procesosde manufactura. Los datos de estos procesos suelen estar compuestos por señales de máquinas, y portanto por series temporales univariadas.

A la hora de hacer la predicción de series temporales, un problema suele ser la barrera de entradaque presenta utilizar librerías de inteligencia artificial como SciKit-Learn o Keras, sobre todo enproblemas con particularidades en las fases de preparación de datos y lanzamiento de predicciones,como ocurre al tratar con series temporales. Aunque se han hecho avances en la experiencia de usuariode las librerías mencionadas, se siguen necesitando conocimientos específicos del funcionamiento delos algoritmos de Machine Learning (ML) utilizados, sus potencias y sus carencias, para poder diseñaruna Pipeline de predicción adecuada. También se requieren conocimientos avanzados de herramientasde manejo y estructuración de datos como Pandas, las cuales son difíciles de comprender viniendo desoftware interactivo de hojas de cálculo. Sin formación específica la ciencia de datos es un problemamuy complejo de atacar, y aunque sea una disciplina con muchos tutoriales y ayuda en internet, unesfuerzo autodidacta requiere tiempo que muchas veces no se tiene. Esta dificultad de comprensióny de prototipado rápido de modelos hace que algunas empresas decidan posponer la implementaciónde componentes de Inteligencia Artificial (IA) a sus procesos.

Se propone en este trabajo una herramienta de prototipado rápido de modelos de predicción de se-ries temporales utilizando técnicas de ML. Se plantea que se pueda elegir el mejor modelo explorandodistintas opciones según el tiempo y capacidad de procesamiento del que se disponga, implementadooptimización automática de hiper-parámetros y, en general siguiendo todos los pasos del AutoML.También se hará énfasis en la experiencia de usuario, añadiendo opciones rápidas de representaciónde las señales, y sus predicciones, así como métricas de error personalizables y comprensibles. Encuanto a la facilidad de uso, se busca que solo se requieran conocimientos básicos de Python para uti-lizarla, basándose en los comandos de Scikit-Learn (fit y predict). Por otro lado se propone tambiénuna interfaz de usuario básica, utilizando la interfaz Swagger UI por encima de una API REST conel motor FastAPI, de manera que tampoco se requieran conocimientos de Python para lanzar predic-ciones, e incluso se puedan integrar las predicciones en entornos de producción mediante peticionesentre servidores.

1

CAPÍTULO 1. INTRODUCCIÓN

1.2. Motivación

La principal motivación para la realización de este trabajo es la falta de herramientas maduras depredicción de series temporales. Comprobando los proyectos más populares relacionados con seriestemporales en Github se observa que la mayoría están aún en fases tempranas de desarrollo, sin haberllegado en su mayoría a sacar una versión definitiva (mayor que la 1.0). La herramienta de Prophet,desarrollada por Facebook [1] es la más madura, al haber lanzado su versión 1.0 en marzo de 2021.Otras como Sktime [2] (v0.6 en abril de 2021) están aún lejos del lanzamiento definitivo, habiendotodavía sendas diferencias entre una versión y la siguiente.

Mientras que la realización de predicciones sobre series temporales es posible en el estado actualde algunas de estas librerías, facilitando algunos de los procesos, como la extracción de característicaso la división de datos en conjunto de entrenamiento y validación, siguen requiriendo de mucho códigoa la hora de preparar los datos o predecir más allá de un dato en el futuro de forma recursiva. Es poresto que surge la necesidad de crear una herramienta que permita un flujo de trabajo simplificado paraestos problemas.

1.3. Alcance

En este proyecto se define un objetivo claro: la creación de una librería de Python que facilite eluso de modelos de predicción de series temporales. El alcance de este objetivo puede ser inmenso,ya que se pueden añadir infinidad de modelos de predicción y de parámetros de parámetros de op-timización para mejorar y afinar las predicciones, así como “perfiles” para seleccionar los modelosdependiendo de la señal o serie de entrada que se quiera analizar.

Al estar este trabajo limitado en el tiempo, disponiendo únicamente de 150 horas (6 ECTS) detiempo para su realización, se debe limitar el alcance del mismo, definiendo unos objetivos menosambiciosos. Estos son los pilares básicos que deben sostener al proyecto, y sobre los que se podráiterar si se decide proseguirlo una vez terminada la componente académica.

El alcance por tanto de la creación de la librería vendrá definido por los siguientes objetivos:

1. Respeto de las Python Enhancement Proposals (PEP) que definen el estilo, tanto del código yestructura de la librería en sí (PEP 8) [3], cómo de las explicaciones o docstrings correspon-dientes a los módulos y funciones (PEP 257).

2. Importación de datos y preprocesado sencillo, con manejo de datos faltantes e interpolación deseries temporales automatizada.

3. Preprocesado y predicción desde los datos de entrada automática, limitando los parámetros so-licitados al usuario al mínimo indispensable para el correcto funcionamiento de la importaciónde datos y las predicciones.

4. Disponibilidad de un parámetro para limitar el tiempo de procesamiento establecido por elusuario. Esto se implanta en forma de perfiles de predicción, que apliquen unos u otros modelos

2

CAPÍTULO 1. INTRODUCCIÓN

de predicción a los datos dependiendo de la “dificultad” escogida.

5. Utilización simple, usando comandos similares a otras librerías, como Scikit-Learn [4]. En con-creto las funciones fit y predict, o fit_predict para el entrenamiento de modelos y realizaciónde predicciones.

3

2. FUNDAMENTO TEÓRICO

2.1. Preparación de datos para predicción de series temporales

Antes de proceder al estudio del estado del arte para la predicción de series temporales en Python,es conveniente hacer un repaso de las bases teóricas de la predicción de series temporales. En concretola preparación de datos para crear datasets estructurados, de datos tabulados, de forma que se puedanaplicar modelos de ML.

La Tabla 2.1 representa un ejemplo de una serie temporal de entrada. La serie representa el con-sumo energético de una planta industrial. Como se puede ver, solo se cuenta con dos campos: unavariable temporal y una objetivo, independientes entre sí, es decir que es una serie univariada. Es ne-cesario realizar limpieza, preprocesado y aumentación de datos antes de proceder a las predicciones.

ENERGÍA [kWh]

2000-02-05 15:07:33.511000+01:00 429.136414

2000-02-05 15:08:33.511000+01:00 441.115204

2000-02-05 15:09:33.511000+01:00 437.226990

2000-02-05 15:10:33.511000+01:00 415.408021

2000-02-05 15:11:33.511000+01:00 432.827713

Tabla 2.1. Ejemplo de serie de datos univariada de demanda energética

Para la limpieza de datos, en este caso, se comprueba que no hay valores repetidos ni vacíos entrelos datos, y que la frecuencia de la serie es constante para asegurar la homogeneidad entre entradasde predictores. Si la frecuencia no es constante, o si hay datos vacíos, se deberá interpolar la serie aun periodo fijo. También se pueden aplicar otras técnicas como detección de anomalías o filtrado dedatos, pero estas no son estrictamente necesarias para la aplicación de los modelos.

En cuanto a la creación de características auxiliares, el objetivo es convertir la serie en un datasettabulado, un formato compatible con los algoritmos de ML para regresión. Para hacer esto, se empleandos técnicas, la creación de características y la reorganización con datos auto-regresivos, detalladasen las secciones 2.1.3 y 2.1.2 respectivamente. Otra técnica de preprocesado de series común, sobretodo para la aplicación de modelos clásicos de predicción, es la descomposición, que se detalla en lasección 2.1.1

2.1.1. Descomposición de series temporales

Para muchas técnicas específicas de análisis de series temporales, como puede ser ARIMA [5],uno de los pasos iniciales fundamentales para el preprocesado de las series es la descomposición ensus componentes básicos. El conocimiento más extendido es que las series temporales constan de trescomponentes: la tendencia, la estacionalidad y el resto o ruido blanco. Cada una de estas componentes

4

CAPÍTULO 2. FUNDAMENTO TEÓRICO

se puede apreciar en la Figura 2.1. Existen dos maneras clásicas de realizar la descomposición: laprimera es la más intuitiva, la serie completa es la suma de las tres componentes (Ecuación 2.1), laotra es la multiplicativa (Ecuación 2.2), en este caso multiplicando las componentes. Hay otras formasmás elaboradas, como pueden ser X11, SEATS o STL [6] diseñadas para evitar algunas de las lagunasde los métodos clásicos, como la falta de estimación de tendencia en los datos iniciales y finales de laseries, o la incompatibilidad con estacionalidades no constantes.

yt = S t + Tt + Rt (2.1)

yt = S t ∗ Tt ∗ Rt (2.2)

yt −→ Serie Temporal completa

S t −→ Componente de estacionalidad

Tt −→ Componente de tendencia

Rt −→ Componente de ruido

Como se puede observar en la Ecuación 2.1, cada una de las componentes de las series temporales,tanto en casos de descomposición clásica como en los más elaborados, tiene unas características y unamorfología particulares y reconocibles.

Componente de estacionalidad: Es una curva cíclica, en la descomposición clásica tiene pe-riodo constante, aunque en algunos de los métodos más elaborados puede adaptarse con res-pecto a cambios de estacionalidad con el tiempo. Se puede calcular, entre otros métodos, contransformaciones matemáticas como la de Fourier [7].

Componente de tendencia: Suele ser una curva suavizada, la cual no responde a cambiosbruscos en la serie temporal sino a la tendencia general. Suele estar presente en todo tipo deseries, y es fácilmente calculable con métodos basados en media móvil (Moving Average) osimilares.

Componente de ruido: Corresponde a la resta de las otras dos componentes a la serie, y portanto corresponde a un error de ajuste. Como tal, se suele aceptar que los valores de esta compo-nente, cuando las demás están calculadas adecuadamente, deben seguir una distribución normalo gaussiana [8].

5


Fig. 2.1. Ejemplo de descomposición de una serie temporal de ventas de equipos eléctricos [8]

En general, la descomposición de series es el primer paso antes de su análisis. Sin embargo, noes un método apto para todo tipo de series. La componente de tendencia suele estar presente en todoslos ejemplos de series que se puedan predecir, sin embargo la estacionalidad no suele ser trivial decalcular. Muchas de las librerías más comunes de series temporales (Sección 3.1.3) requieren intro-ducir la estacionalidad como un parámetro en las funciones, sin tener funcionalidad para su cálculoautomatizado. En el alcance de este proyecto, que es sobre todo el análisis de señales industriales conhorizontes de predicción cortos, no es trivial definir la estacionalidad de los datos de entrada.

2.1.2. Modelos auto-regresivos

El principal problema a superar con las series temporales es que se trata, en su mayoría, de pro-blemas univariados, es decir que solo se dispone del histórico de valores que ha tomado una variablepara predecirla. Para aplicar ML, es necesario convertirlos en una Tabla convencional. La Figura 2.2muestra el proceso a seguir para adaptar estas series. El concepto básico a definir es el de lags, omomentos pasados. Para cada momento en la serie temporal, se le añaden como características losanteriores. La cantidad de lags incluidos en cada fila del dataset creado se define como la windowo ventana. Se suele limitar el tamaño de la ventana tanto para reducir la complejidad del problema,reduciendo el número de características, como para aumentar la cantidad de datos, ya que cuantos

6


más lags se tomen, más información se perderá del inicio de la serie por la aparición de valores NaN(Not a Number) [8].

lag_3 lag_2 lag_1

2000-02-05 15:12:33.511000+01:00 437.226990 415.408021 432.827713

2000-02-05 15:13:33.511000+01:00 415.408021 432.827713 422.442383

2000-02-05 15:14:33.511000+01:00 432.827713 422.442383 437.476608

2000-02-05 15:15:33.511000+01:00 422.442383 437.476608 347.434494

2000-02-05 15:16:33.511000+01:00 437.476608 347.434494 378.375046

Tabla 2.2. Ejemplo de DataFrame de pandas con lags creados

2.1.3. Creación de características

A continuación, con la finalidad de exprimir al máximo los datos disponibles, se crean nuevascaracterísticas para enriquecer los datos. En la Tabla 2.3 se muestra un ejemplo de dataset con ca-racterísticas calculadas. En primer lugar se debe definir una rolling window, o ventana deslizante, lacual englobará los datos sobre las que se calculan las características. Con una rolling window valor 2,se calcularán las características en parejas por ejemplo, deslizando un paso cada vez la ventana paraenglobar un dato y su anterior.

lag_3 lag_2 lag_1 mean_3_3 mean_3_2 mean_3_1 std_3_3 std_3_2 std_3_1

2000-02-05 15:12:33.511000+01:00 437.226990 415.408021 432.827713 435.826203 431.250071 428.487574 6.111015 13.856676 11.538824

2000-02-05 15:13:33.511000+01:00 415.408021 432.827713 422.442383 431.250071 428.487574 423.559372 13.856676 11.538824 8.763399

2000-02-05 15:14:33.511000+01:00 432.827713 422.442383 437.476608 428.487574 423.559372 430.915568 11.538824 8.763399 7.697350

2000-02-05 15:15:33.511000+01:00 422.442383 437.476608 347.434494 423.559372 430.915568 402.451162 8.763399 7.697350 48.235177

2000-02-05 15:16:33.511000+01:00 437.476608 347.434494 378.375046 430.915568 402.451162 387.762050 7.697350 48.235177 45.749125

Tabla 2.3. Ejemplo de DataFrame de pandas preparado con lags y características

2.1.4. Predicción recursiva

La última fase en el proceso de data science sobre las series temporales, una vez creada una matrizde características y valores pasados de la variable a predecir, es la obtención de predicciones a másde un paso en el futuro. El instante t + 1 se puede predecir a partir de datos reales, pero para obtenervalores para instantes más allá de él, hasta t+n, es necesario contar con datos al menos hasta t+(n−1),que no están disponibles a la hora de lanzar las predicciones. Para ello se hace uso de la predicciónrecursiva [9], la cual consiste en utilizar los valores predichos para un instante como dato de partidapara predecir el siguiente. En cada paso, la predicción se incorpora al dataset que toma como base lasiguiente iteración, de forma que se pueden hacer predicciones a un horizonte mayor. Los pasos de lapredicción recursiva son los siguientes:

1. Usando los datos contenidos hasta el punto temporal t, entrenar el modelo para la predicción ypredecir el instante t + h.

7


2. Incorporar la predicción para el instante t + h a la serie temporal original, calcular sus caracte-rísticas y lags si es necesario.

3. Utilizando los nuevos datos hasta el instante t+h, realizar la predicción para t+2h, repetir paralos siguientes pasos

Esta estrategia es un arma de doble filo, ya que, por definición, se incorporan a los datos de entre-namiento datos generados, por lo que se pueden propagar errores cuando se realizan las prediccionesa muy largo plazo relativo a la frecuencia de la serie de entrada.

2.2. Modelos tradicionales para predicción de series temporales

Existen varios métodos analíticos de predicción de datos de series univariadas de datos. Estospresentan las deficiencias de ser altamente dependientes de los datos.

2.2.1. Modelos Naïve

Los modos de predicción Naïve son aquellos que toman decisiones de manera “inocente” sobrelos datos. Asumen que diversos comportamientos se van a repetir sin analizar su procedencia. Unejemplo de modelo Naïve sería el de pronosticar que el valor de una variable para el siguiente mo-mento en el tiempo sea la media de las ultimas 10 observaciones. Existen otros enfoques Naïve, comopuede ser tomar el ultimo valor conocido para la estacionalidad seleccionada, por ejemplo para lasventas de enero 2021, tomar el dato de enero 2020. Este tipo de modelos tienen la ventaja de requerirpocos recursos computacionales, lo cual se traduce en predicciones a menudo imprecisas y con muchaincertidumbre.

2.2.2. Modelo ARIMA

El modelo Autorregresive Integrated Moving Average (ARIMA), o modelo auto-regresivo inte-grado de media móvil es un modelo estadístico de predicción de series temporales dinámico. Es decirque las predicciones a futuro vienen dadas por datos anteriores. El objetivo de los modelos ARIMAes describir las autocorrelaciones de los datos [8].

El modelo ARIMA se describe por la Ecuación 2.3, en donde y′t representa la serie de iniciodiferenciada. La diferenciación es una transformación de una serie temporal en la que se expresael punto t + h de la serie con respecto a su diferencia con t, en un esfuerzo por hacer predeciblesseries estacionarias y puede ser aplicada varias veces sobre una misma serie [8]. p representa el ordende la parte auto-regresiva del modelo, es decir el número de lags tomados para la predicción delinstante t + h, d representa el grado de la diferenciación que se aplica (cuantas veces se ha aplicadodiferenciación sobre la serie original), y por último q representa el tamaño de ventana tomado para lacomponente de media móvil de ARIMA.

8


Para simplificar su descripción, se puede definir un modelo ARIMA como la aplicación de unmodelo auto-regresivo sobre la media móvil de una serie diferenciada, en la que se puede o no elegiromitir cada una de las componentes.

y′t = c + φ1y′t−1 + ... + φpy′t−p + θ1ϵt−1 + ... + θqϵt−q + ϵt (2.3)

Al ARIMA convencional, se puede añadir una componente para lidiar con la estacionalidad, éstacomponente es sumada a la parte convencional del modelo, pero se aplica sobre la componente deestacionalidad de la serie.

2.3. Modelos de Machine Learning para series temporales

A diferencia de los ejemplos de la sección anterior, los modelos aquí descritos no están diseñadospara resolver específicamente problemas de series temporales, sino que se trata de métodos de ML.Los problemas de ML son aquellos que no han sido programados explícitamente para resolver unproblema en concreto, sino que tratan de emular el aprendizaje humano valiéndose de la informacióndel entorno para llegar a conclusiones [10].

Tradicionalmente los modelos de regresión de ML no son compatibles con datos univariados, alser una colección de algoritmos supervisados que requieren una variable objetivo para funcionar. Alrealizar la generación de lags y de características se consigue transformar los datos a un formatotabular estructurado, al que se le pueden aplicar los modelos.

2.3.1. Modelos Lineales Generalizados (GLM)

Los GLM, como su nombre indica, funcionan ajustando los predictores de un problema a la va-riable objetiva de forma lineal. Esto se consigue mediante la definición de una función de coste querepresente la diferencia o error entre los datos reales y los obtenidos del ajuste. La componente “ge-neral” del acrónimo GLM hace referencia a las medidas o distribuciones de error que puedan serdistintas de una distribución normal.

E(Y |X) = µ = g−1(Xβ) (2.4)

En un GLM, se asume que los valores de cada predictor siguen una distribución de probabilidaddada, y que la media µ de la distribución depende de las variables independientes X, como se presentaen la Ecuación 2.4. E(Y |X) representa el valor esperado de la variable objetivo Y con respecto a lospredictores X, y g es la función de enlace que lo relaciona con los parámetros β y los predictores X.Es esta función g la que representa la componente de distribución probabilística del modelo.

2.3.2. Modelo basado en Árboles de Decisión y Gradient Boosting

El modelo de Gradient Boosting con árboles de decisión es un método ensemble de aprendizaje,en el que se entrenan varios modelos de modelos débiles para formar predicciones robustas. En éste

9


caso, los distintos arboles de decisión son construidos uno después del otro en serie. De manera queun árbol siempre parte del anterior para optimizar el ajuste a los datos.

Para hacer posible el aprendizaje en serie, es necesario un algoritmo de descenso de gradientecon función de coste. A cada iteración, se debe tratar de minimizar los residuos del modelo anterior,siendo los residuos el error de ajuste del árbol anterior con respecto a los datos de entrenamiento.Cada nuevo árbol se ajusta entonces en la gradiente negativa de la función de coste [11].

El proceso iterativo continua hasta que se cumplan uno de dos supuestos; que se alcance unaprofundidad de árbol máxima establecida, ya que tener arboles demasiado grandes puede traducirseen overfitting, o que las iteraciones no se traduzcan en una mejora significante en el ajuste a los datosde entrenamiento. Ambos supuestos son parámetros en los algoritmos, que se pueden modificar segúnel problema.

2.3.3. Modelos basados en redes neuronales recurrentes

Las redes neuronales son modelos de computación de ML que permiten caracterizar relacionesno lineales entre predictores y variable objetivo. Esta capacidad de explicar relaciones complejas esprecisamente la razón por la que son interesantes para la predicción general de series temporales.Muchas veces, las series son obtenidas y analizadas sin importar su procedencia, por lo que poderno asumir ninguna de sus características (estacionalidad, tendencia) permite reducir el sesgo de laspredicciones [12] y la necesidad de intervención humana.

Aunque existe documentación de utilizar modelos de redes neuronales convencionales como lasfeed-forward para elaborar predicciones sobre datos temporales [12], éstas carecen de la componentede ”temporal awarenesst’t’ o conciencia temporal para tratarlas adecuadamente. Por ello en este tra-bajo se va a hacer hincapié en los modelos de Redes Neuronales Recurrentes (RNN). Estas redes secaracterizan por tener "memoria", es decir que permiten que la información persista [13].

Fig. 2.2. Red neuronal recurrente desenrollada [13]

La Figura 2.2 representa una RNN, junto con su expansión. Se puede apreciar en su parte izquierdaque hay dos caminos por los que puede pasar la información, el primero entre los predictores y lavariable objetivo, y el segundo devolviéndola a la misma red. La parte derecha "desenrolla"la red,y permite apreciar que una red recurrente puede interpretarse como varias copias de una misma redneuronal, cada una transmitiendo información a su sucesora [13].

10


Modelo basado en Long Short Term Memory (LSTM)

Una de las limitaciones de utilizar una red neuronal recurrente normal para series temporales esel plazo de la memoria. Como enseña la Figura 2.2, solo se puede transmitir información entre unaneurona y su sucesora. Solo hay memoria a corto plazo. Esta memoria a corto plazo impide a estetipo de redes capturar componentes como la estacionalidad o tendencia de los datos. Las redes LongShort Term Memory (LSTM), introducidas en 1997 [14], cuentan con memoria a corto y largo plazoprecisamente por este motivo, ya que funcionan bien para procesamiento de lenguaje natural o desecuencias de imágenes.

Fig. 2.3. Esquema de una neurona LSTM [13]

La Figura 2.3 representa el comportamiento de una red LSTM. En primer lugar se puede observarque en la parte superior existe una linea recta que cruza todas las neuronas de la red. Esta se llama cellstate, y permite la transmisión de información a largo plazo. Las celdas pueden aportar información aeste elemento mediante “puertas” reguladas por funciones de activación sigmoidales. Los valores dela función sigmoidal representan cantidad de información que puede persistir a largo plazo, siendo 1toda y 0 nada de la información [13]. A continuación se decide que cantidad de información nueva seva añadir al cell state desde la neurona actual, para ello se generan valores ”candidatost’t’ reguladosotra vez por una función de activación, en este caso de tangente hiperbólica (tanh). Finalmente sedecide la salida, de forma análoga a una red neuronal tradicional, aunque en este caso la celda deestado pasa por una función de activación sigmoidal, el valor actual por una tanh, y se multiplican losdos valores [13].

El problema tradicional con las redes neuronales es su consumo de recursos computacionales.Entrenar una red neuronal con muchas conexiones (muchas capas y neuronas) durante 50 o 100 ge-neraciones (épocas) requiere mucha más potencia y tiempo que los demás modelos ML mencionadoshasta ahora. Esto hace que sea más comparable en coste a métodos como ARIMA, cuyo tiempo decomputación es muy alto para series largas con muchos lags. Se ha decidido implementar este métodopor encima de ARIMA por su superioridad en cuanto a precisión. En un experimento aplicado sobreseries de datos financieras en las que se entrenó una LSTM y calculó una predicción con ARIMA, elmétodo LSTM consiguió una mejora del 85 % con respecto al método estadístico [15].

11

3. ESTADO DEL ARTE

En esta sección se analizarán las principales herramientas ya disponibles para los problemas depredicción de series temporales. En este caso, al tratarse de series temporales, el enfoque tomadoes el método de predicción auto-regresivo (AR). Este método se basa en utilizar los datos anterioresal momento actual t para predecir los puntos en el futuro t + h, donde h es el horizonte temporal apredecir [8].

Para los modelos AR, es necesaria la importación y preprocesado para generar datos tabuladosy múltiples predictores. Para esta fase de aumentación de datos, se ha tomado inspiración de otropaquete para análisis de series temporales en Python, TsFresh [16]. Esta librería cuenta con una granvariedad de características que se pueden derivar a partir de datos en bruto de series temporales.

3.1. Librerías para series temporales

Existen varias librerías para la predicción de series temporales, las cuales en general están en fasestempranas de su desarrollo. La única excepción de las aquí presentadas es Prophet [1], una libreríadesarrollada por Facebook y de código abierto, que al momento de escribir éste trabajo se halla ensu versión 1.0 (Abril 2021). La ausencia de una solución estándar para este tipo de problemas, unidaa la habitual falta de facilidad de uso de librerías más complejas y completas como Scikit-Learn [4],hacen que sea buena idea afrontar el reto de crear una librería en este ámbito.

3.1.1. Sktime

Sktime [2] es un framework en Python basado en Scikit-Learn [4] para análisis de series temporalesmantenida por el Alan Turing Institute, el instituto nacional de ciencia de datos y de inteligenciaartificial de Reino Unido. Se centra en la compatibilidad con Scikit-Learn, de forma que los algoritmosy modelos que contiene se puedan introducir en los pipelines de la librería padre. Esto permite ademásaprovechar todas las integraciones que puedan tener otras librerías con Scikit-Learn, como pueden seroptimización de hiper-parámetros con HyperOpt [17], evaluaciones de modelos o similares.

Esta librería destaca por ser completa, sirviendo para análisis de series temporales para problemasde clasificación, predicción o regresión entre otros. Además aporta útiles de preprocesado o creaciónde características para aplicar métodos tradicionales de ML a los problemas. En el contexto de lapredicción, se centra más en métodos estadísticos, como pueden ser ARIMA 2.2.2 o naïve. También esadmirable su documentación, contando con ejemplos comentados de muchas de sus funcionalidades,facilitando su utilización.

La principal desventaja que tiene utilizar esta librería es su hincapié por los métodos convenciona-les de predicción de series temporales. Al estar TS-AutoML diseñada para series de datos industriales,en general de gran frecuencia, con históricos amplios y estacionalidades largas, el tiempo de proce-

12

CAPÍTULO 3. ESTADO DEL ARTE

samiento y robustez de los modelos es un factor importante. Los modelos de ML tienen la ventaja depoder ser entrenados con antelación, de forma que las predicciones se pueden hacer casi de manerainstantánea para la mayoría de modelos. Aún teniendo esto en cuenta, se ha incluido este proyectopara la librería, en concreto para incorporar fácilmente métodos Naïve.

3.1.2. Skits

Skits [2] también está basada en Scikit-Learn [4] mantenida por Ethan Rosenthal, científico dedatos y Doctor en Física. Al estar mantenida por una única persona, tiene menos funcionalidadesque las demás de que se mencionan en este informe, y no está mantenida de forma activa, siendo elúltimo commit en noviembre de 2019. Esta falta de mantenimiento activo hace que ni sea recomen-dable utilizarla, ya que limita la posibilidad de actualizar las dependencias del proyecto sin romper lacompatibilidad.

La librería cuenta con 3 componentes principales, preprocessors o preprocesamiento para la pre-paracion de series, contando con funciones de suavizado o transformado de datos, feature_extractorspara la creación de características a partir de la serie de origen, por último cuenta con pipelines, paraasemejar el uso de los modelos al de los de Scikit-Learn.

De esta librería se ha tomado como inspiración la estructura de los módulos, ya que es bastantesimple sin dejar de ser descriptiva. Esto contrasta con Sktime, que tiene muchos más módulos y estádistribuida en muchos más ficheros, dificultando la exploración del código.

3.1.3. Prophet

Prophet es uno de los nombres más comunes en predicción de series temporales, se trata de unpaquete disponible tanto en R como en Python y basado en un modelo aditivo (Ecuación 2.1), dondela componente de tendencia se combina con varias estacionalidades al mismo tiempo, de forma que sepuedan obtener predicciones robustas de series con mucha estacionalidad y parece que esto tambiénse puede obtener utilizando una gran cantidad de datos del pasado [1]. Suele ser especialmente útilpara series de datos largas, con estacionalidades anuales, mensuales o semanales, y sobre todo parapredicciones a tiempo largo.

Esta librería no sería recomendable para datos de alta frecuencia o horizontes cortos de predicción,ya que en estos casos los datos necesarios para obtener información de las estacionalidades puedenno ser suficientes, o la periodicidad puede no corresponderse con los plazos establecidos de días,semanas o meses (puede por ejemplo ser cada 8 horas o cada 90 minutos). Además, debido a la granfrecuencia de datos, y a la aplicación de modelos analíticos de predicción, el coste computacionalcrece considerablemente cuando se trabaja con varios lags en el pasado.

Donde destaca esta implementación es en su facilidad de uso comparada con las demás. Una vezimportados los datos, basta con tres comandos para realizar una predicción. El flujo de trabajo básicose presenta en la Figura 3.1. Solo es necesario ajustar el modelo a los datos (fit), crear un horizontede predicción (make_future_dataframe) y por último predecir con el modelo ajustado (predict). Esta

13


funcionalidad es interesante sobre todo en el contexto de AutoML (sección 3.2), porque, aunque nose pueda considerar como un ejemplo de esta filosofía, se asemeja en el sentido de facilitar el accesoa herramientas de ML a usuarios sin conocimientos previos mediante la simplificación del flujo detrabajo.

1 df = pd.DataFrame() # Dataframe con una columna de fecha y otra de

datos

2 m = Prophet() # Inicializar prophet

3

4 m.fit(df) # Ajustar el modelo prophet a los datos de

entrada

5 future = prophet.make_future_dataframe(periods=365) # Crear matriz

de horizonte

6 m = prophet.predict(future)} # Realizar predicciones con el modelo

en la matriz

Fig. 3.1. Ejemplo de predicción básico con la librería Prophet [1]

3.2. AutoML

El AutoML es la acción de automatizar la tarea de aplicar modelos de ML a problemas reales. Así,debería incluir todos los pasos desde la importación y preprocesado de los datos hasta su representa-ción y su despliegue en un entorno de producción. La idea de los proyectos que siguen esta filosofíaes reducir la interacción del usuario con el modelo de ML en bruto, y fomentar su uso como una “cajanegra”. De esta manera no es necesario mucho conocimiento previo en temáticas de ciencia de datospara aplicar modelos y conseguir resultados confiables.

Fig. 3.2. Representación del flujo de trabajo cubierto por AutoML [18]

La Figura 3.2 muestra un flujo de trabajo que debería cumplir una pipeline de AutoML, que se

14


divide en cuatro pasos principales:

1. Preparación de datos: Esto correspondería a la fase de importación, pero también, según elcaso, puede incluir la limpieza si los datos no se entregan preprocesados.

2. Ingeniería de Características: Consiste en la extracción de información extra a partir de losdatos de entrada. Es una fase imprescindible en todos los tipos de problema, pero sobre todoen las de series temporales univariadas. También engloba la selección de las características másimportantes, puesto que si se incluyen demasiados datos de predictores, el ajuste del modelopuede llegar a tardar demasiado. Para la selección de predictores, se pueden usar técnicas comoPrincipal Component Analysis (PCA), correlaciones de Pearson o similares.

3. Generación de modelos: En este paso la Figura presenta dos caminos posibles, el primero conmodelos tradicionales de ML, y el segundo con redes neuronales profundas. A la vez, el pasose divide en dos subtareas, la búsqueda de modelos, que ajusta distintos modelos a los datospara evaluar el mejor, y la optimización de los hiper-parámetros o arquitectura de los mismos.

4. Evaluación de modelos: Por ultimo, se debe hacer una evaluación de los modelos escogidospara las predicciones. Se trata de un paso fundamental para comprobar la eficacia de estos.Este paso puede ser recursivo, es decir, que si la evaluación del modelo genera un fallo, o lamétrica de error utilizada devuelve un valor insatisfactorio, se deberá retornar a la fase anteriorde optimización de modelos. Esto se hará de manera recursiva hasta alcanzar un umbral deerror, o hasta que haya transcurrido un límite de tiempo establecido.

3.2.1. Historia de AutoML

A partir de 1995 empiezan a surgir herramientas especializadas para tareas de ML, como puede serWeka [19], un framework para operaciones de data mining usando el lenguaje de Java. A Weka siguenotros que ya se han mencionado en este trabajo, como pueden ser Scikit-Learn (2007) o Keras (2015).Con la madurez de estas plataformas, se empieza a hacer aparente que extraer los modelos con mejorrendimiento usando las herramientas no es una tarea trivial, sino que requiere sendos conocimientosy experiencia para saber realizar la optimización de hiper-parámetros o arquitecturas [20], Surgeentonces la idea del AutoML (sección 3.2).

El inicio de la investigación y la creación de software de AutoML fue impulsado por la comunidadacadémica, creando herramientas como Auto-Weka [21] o Auto-Sklearn [22]. Poco después, algunasstartups empezaron a crear herramientas comerciales, como H2O-AutoML [23], creada por el equipode h2o.ai. Siguiendo los pasos de las startups, los gigantes del sector de cloud computing (GoogleCloud, Microsoft Azure y Amazon Web Services) empiezan a desarrollar sus propias herramientas,facilitando la experimentación y desarrollo rápidos de modelos para sus clientes [20].

15


3.2.2. Ejemplos de librerias de AutoML en Python

En esta sección se van a presentar varios ejemplos de librerías o implementaciones de AutoMLdisponibles en Python, las cuales se han probado en las fases iniciales del proyecto, y de las que se hatomado inspiración para decidir la trayectoria del mismo:

AutoKeras Auto-keras, como su nombre indica, es una herramienta basada en el frameworkde redes neuronales de Keras, que a su vez está basado en Tensorflow [24]. Por ello, todossus modelos están basados en redes neuronales. La diferencia con utilizar simplemente Keras,como era de esperar, es que no se requiere ningún tipo de conocimiento previo en redes neuro-nales, pudiéndose utilizar la herramienta sin siquiera saber que se estén aplicando este tipo demodelos.

La librería es bastante completa, e incluye modalidades para las principales tareas en las quetradicionalmente han funcionado bien las redes neuronales, como clasificación o regresión deimágenes o texto, o predicción de series temporales. Donde falla es en su facilidad de uso, porejemplo, en la Figura 3.3 se aprecia que se deben aportar parámetros a la hora de lanzar laspredicciones, como la cantidad de datos en el pasado que se utilizan para predecir el siguien-te lookback. También deja en manos del usuario la importación de datos y su estructuracióncorrecta, tarea que puede no ser trivial para modelos como los de redes LSTM.

1 predict_from = 1

2 predict_until = 10

3 lookback = 3

4 clf = ak.TimeseriesForecaster(

5 lookback=lookback ,

6 predict_from=predict_from ,

7 predict_until=predict_until ,

8 max_trials=1,

9 objective="val_loss",

10 )

11 # Train the TimeSeriesForecaster with train data

12 clf.fit(

13 x=data_x,

14 y=data_y,

15 validation_data=(data_x_val , data_y_val),

16 batch_size=32,

17 epochs=10,

18 )

19 # Predict with the best model(includes original training data).

20 predictions = clf.predict(data_x_test)

21 print(predictions.shape)

22 # Evaluate the best model with testing data.

23 print(clf.evaluate(data_x_val , data_y_val))

Fig. 3.3. Ejemplo de entrenamiento y predicción de serie temporal con AutoKeras [24]

16


Un punto fuerte de AutoKeras es que permite la exportación fácil de los modelos, y al estarbasada en Tensorflow, una de las librerías más utilizadas para redes neuronales, estos son fácil-mente adaptables a un entorno de producción con pocas dependencias y en casi cualquier tipode arquitectura de máquina.

AutoSklearnAutoSklearn, al igual que AutoKeras es una librería de uso libre y de código abierto nacida enun entorno académico, se basa en la popular herramienta Scikit-Learn [4] y trata de agilizar losprocesos que permite realizar esta librería. Principalmente, se centra en las partes de seleccióny optimización de modelos de la pipeline de AutoML, dejando de lado la fase de introducción,aumentación y limpieza de datos (Figura 3.2).

La utilización de AutoSklearn es por tanto sencilla en el caso de que el usuario esté familiari-zado con Scikit-Learn. Esto puede facilitar el trabajo a gente con conocimiento medio de ML,pero no a aquellos que sean completamente noveles. LA Figura 3.4 muestra un ejemplo de uti-lización, donde se aprecia que se trata de una implementación drop-in, en la que basta cambiarel clasificador utilizado en la implementación con Sci-kit Learn por el de la implementación deAutoML. El meta-modelo elegirá entonces el enfoque más correcto de predicción y lo aplicaráa los datos de entrenamiento.

1 from autosklearn.classification import AutoSklearnClassifier

2

3 automl = AutoSklearnClassifier()

4 automl.fit(X_train, y_train)

5 y_hat = automl.predict(X_test)

Fig. 3.4. Ejemplo de entrenamiento de modelo y predicción con AutoSklearn [22]

A diferencia de AutoKeras, no hay parámetros necesarios que aportar para las tareas, aunque sique hay parámetros opcionales como el tiempo de procesamiento o el error máximo admitidoa la hora del entrenamiento del modelo. Tambien destaca sobre AutoKeras con respecto a lacantidad de procesos que están implementados, lo cual es normal al ser Scikit-Learn una libreríamás generalista que Keras.

17

4. DESARROLLO

4.1. Convenciones de estilo

En el lenguaje de programación Python, existen las llamadas Python Enhancement Proposals(PEP), que son documentos de diseño para el lenguaje destinados a la comunidad. Su objetivo esel de informar de nuevos cambios, su uso y de manejar propuestas de mejora del lenguaje [25] porparte de los usuarios. Hay tres tipos de PEPs en Python, los standard track, que describen procesos,los informational, que aportan información general, o los process, que proponen cambios a sistemasinternos de Python o los describen. Para este trabajo conciernen principalmente dos PEP. EL PEP8[3] indica las normas de estilo y formato de scripts en Python, y el PEP257 hace la misma labor parala documentación que acompaña a los distintos elementos de los scripts.

4.1.1. PEP8 - Guía de estilo en Python

La PEP8 [3] indica las pautas a seguir para garantizar la legibilidad y simplicidad que caracteriza aPython. Cuenta con una gran variedad de epígrafes correspondientes a todos los aspectos del lenguajede Python, Entre otras cosas, la directiva trata de limitar la complejidad del código, por ejemploestableciendo la longitud máxima de cada línea de código a 80 caracteres. Para la comprobaciónde que el código se adhiera a las restricciones de esta PEP se utilizó Flake8 [26], una librería quecomprueba el código y encuentra cualquier problema con respecto a PEP8 a la hora de guardar losarchivos.

4.1.2. PEP257 - Docstrings

Para documentar la librería, es necesario incluir descripciones para las funciones y clases quecontiene. De esta manera, se facilita la comprensión del funcionamiento del código a simple vista. Ladirectiva PEP257 [27] aporta las convenciones de estilo básicas para la composición de docstrings. LaPEP257 explica dos tipos de docstrings o documentaciones; La primera es la de una linea, que debesimplemente resumir el objetivo de la función. Para explicaciones más detalladas, se pueden añadirapartados, como los parámetros que acepta el tipo de dato que devuelve su ejecución. Aparte de lasconvenciones de la PEP257, y con el objetivo de homogeneizar la estructura de las descripciones aúnmás, se toma inspiración de la documentación de una de las librerías más usadas en Python, NumPy[28]. En la Figura 4.1 se representa la estructura básica de la documentación de una clase acorde aeste estilo.

18

CAPÍTULO 4. DESARROLLO

1 """

2 Descripcion en una linea del objeto de Python

3

4 Descripcion mas detallada en

5 varias lineas

6

7 Parameters

8 ----------

9 X: str

10 Descripcion del parametro X

11

12 Returns

13 -------

14 str

15 Descripcion de la variable de salida de la funcion

16 """

Fig. 4.1. Ejemplo de Docstring usando el estilo NumPy

4.2. Organización de los módulos de la librería

Para mejorar la legibilidad, comprensibilidad y escalabilidad de la librería, se ha optado por di-vidir las distintas partes del proceso de análisis y predicción en módulos. De esta manera, se permiteacceder a las distintas partes y funciones del modulo por separado para usuarios más avanzados quequieran customizar sus predicciones, preservando las capacidades de AutoML para otras aplicaciones.

4.2.1. Importación de datos data_input.py

La importación de datos engloba dos procesos, el primero es la lectura e interpretación de datosde archivos CSV (Comma-Separated Values) o XLS (Microsoft Excel), en este proceso se construyela serie temporal en formato de DataFrame de Pandas, aprovechando las capacidades de la libreríade pandas para la interpretación de fechas. Despues de esto, la serie se convierte a una de frecuenciaconstante, interpolando los valores si es necesario cubrir huecos donde falten datos o remuestrando sila frecuencia es distinta a la de los datos de origen. Una vez estos pasos se han completado, se puedeproceder a transformar y preprocesar la serie para las predicciones.

4.2.2. Preprocesado de series temporales preprocessing.py

En el preprocesado de la serie, se transforman los datos univariados iniciales en un dataset mul-tivariado mediante la generación de características y de lags para cada punto de datos temporal. Elobjetivo es aprovechar al máximo la información que pueda aportar la serie. Por ello, se calculanvarios tipos de características:

Variables de Calendario: Son las que corresponden a hitos en el calendario, pueden ser días de

19


la semana, o meses del año, o si el momento de la serie corresponde a un evento en específico,como puede ser la navidad. Estas características permiten explicar cambios de tendencia como,por ejemplo, la reducción de fabricación en el mes de diciembre.

Variables estadísticas: Estas son características calculadas en rolling windows o ventanas desli-zantes. Por ejemplo pueden ser la media o la desviación estándar de las ventanas.

Tambien se efectúa en este módulo un escalado del dataset de entrenamiento, de forma que la impor-tancia de las características generadas no se vea afectada por sus órdenes de magnitud. Este paso esespecialmente importante a la hora de utilizar el algoritmo kNN, al depender de la distancia euclideaentre puntos.

4.2.3. Predicción prediction.py

En este módulo se definen los modelos de predicción, así como el método de predicción recursiva.Los modelos ML se entrenan de manera convencional, mediante los datos tabulados, incluyendo loslags y las características generadas. Se trata de un entrenamiento supervisado al existir una variableobjetivo; el valor en el momento t con respecto a todas las características calculadas con los datosanteriores. En el momento de realizar las predicciones surgen las particularidades de la predicción re-cursiva. Esta es la parte que presenta más ineficiencias del código, y por lo tanto la que más potencialde mejora tiene. A cada iteración de la predicción, se debe incluir el valor predicho en los predictoresdel siguiente paso, reconstruyendo dinámicamente el dataset con observaciones artificiales. Las fun-ciones rec_forecast y rec_forecast_np realizan la reconstrucción iterativa del dataset para modeloscompatibles con estructuras de datos pandas (LightGBM, KNN) o NumPy (Keras, GLM) respectiva-mente.

Los modelos de predicción incluidos se enumeran a continuación, en orden de tiempo de proce-samiento necesario ascendente:

1. Modelo Lineal Generalizado (GLM)Es el más rápido de los modelos, para implementarlo se ha hecho uso de la librería StatsModels[29], la cual añade varios modelos y métodos estadísticos a Python. Entre ellos usamos el GLM,que trata de hallar la relación entre la variable objetivo y y los predictores x1, x2, ..., xn medianteuna combinación lineal de estos. Los GLM se diferencian de un modelo lineal tradicional enque se calculan de forma iterativa y en que permiten variables de respuesta con distribucionesde errores distintos a la gaussiana [30]. En este caso se utiliza la familia sm.families.Gamma(),la cual utiliza una distribución de error Gamma para la optimización de la función de coste. Altratarse de una combinación lineal, no hay hiper-parámetros que optimizar en este modelo.

2. Modelo de vecinos cercanos (kNN)Para implementar el modelo de vecinos cercanos, se optó por la librería Scikit-Learn, al tratarsede una de las librerías más utilizadas en ML. La ventaja de esto es que otras librerías suelen estarconstruidas por encima, o diseñadas para funcionar en conjunción con ella. Para el modelo de

20


vecinos cercanos, es importante la optimización de hiper-parámetros, principalmente el númerode vecinos n_neighbors para mejorar el ajuste y evitar el overfitting

3. Modelo de Arboles de decisión con gradient boosting (LightGBM)Para el modelo basado en arboles de decisión se utiliza el algoritmo LightGBM LGBRegressor(),de código abierto y mantenido por Microsoft [31]. Principalmente se elige este modelo por suubiquidad y soporte. Existen otros dos modelos de arboles de decisión con niveles parecidos desofisticación y soporte, XGBoost y CatBoost. Se elige utilizar LightGBM por ser el más rápidode los tres sin sacrificar demasiado la exactitud de sus predicciones [32]. Esta optimización detiempos es importante para poder trabajar con altos volúmenes de datos. Este modelo sí queda pie a la optimización, contando con una decena de parámetros ajustables para mejorar laspredicciones.

4. Red Neuronal (LSTM)Por último, como modelo más sofisticado, se utiliza una red neuronal recurrente. Como marco(framework) para la arquitectura de la red se utiliza Keras [33]. Keras es una interfaz de altonivel que funciona sobre Tensorflow y permite la creación de redes básicas usando Python. Lared utilizada en este caso cuenta con siete capas de 256 neuronas cada una de tipo LSTM,con función de activación ReLU al tratarse de regresión. Se ha elegido este número de capasy de neuronas para asegurar que la red se pueda entrenar en hardware poco potente comoordenadores portátiles sin que tarde demasiado tiempo (5-10 minutos) manteniendo un nivel deabstracción adecuado.

Como se ha mencionado, algunos de los modelos dan pie a la optimización de sus hiper-parámetros.Habitualmente, esto se hace de forma metódica mediante un sistema denominado Grid Search, al quese le dan posibles valores para los hiper-parámetros y una métrica a optimizar (por ejemplo la Re-call). El algoritmo entonces itera el ajuste del modelo y elige la mejor combinación de valores paralos hiperparámetros. Puede implementarse con la librería Scikit-Learn [4]. EL problema que tiene elGrid Search es que, al iterar muchas veces sobre los datos, requiere mucho tiempo de computación yno es óptimo para modelos rápidos como puede haber en esta librería. Para la optimización de hiper-parámetros en esta librería se utiliza HyperOpt [17], una librería de optimización bayesiana, la cualelige los mejores parámetros para el paso siguiente de optimización en función de los mejores en elanterior.

4.2.4. Cálculo de errores metrics.py

Este modulo permite calcular, mediante una fracción de datos de validación en los datos de entre-namiento, la robustez o confianza que tienen las predicciones. Se han implementado dos métodos deevaluación.

Errores absolutos: Son los cálculos de error más tradicionales, para incluirlos en la libreríase hace uso de la librería Scikit-Learn [4]. Se han incluido un total de cinco, en concreto

21


mean-square error mse, root mean-square error rmse, r-squared rsquare, exponential varian-ce exp_var, y por último mean absolute percentage error mape, especialmente útil ya que, al serun porcentaje, es más simple de interpretar sin conocimientos previos.

Error relativo: En este caso, el error se calcula con respecto a una predicción Naïve. Para calcu-larlo se lanza primero la predicción con el modelo ML, después el modelo Naïve. A continua-ción se calcula el mse para cada uno de ellos y se computa el porcentaje de error conseguidopor el modelo más sofisticado con respecto al básico. Los valores más cercanos a 0 son portanto mejores.

4.2.5. Representación de datos plotting.py

Para la representación de los valores tanto de la serie original como de las predicciones, se optapor utilizar la librería Plotly [34]. Esta permite dibujar gráficos en formato html, de forma que puedanser interactivos. Plotly permite, entre otros, acercar o alejar los gráficos mediante una interfaz intuitivapara usuarios inexpertos. Para dibujar los gráficos pertenecientes a una ejecución de una predicción,basta con incluir el hiper-parámetro opt=True al lanzar el comando. De esta manera se abrirá unapagina en el navegador web por defecto del sistema operativo con el gráfico. Por defecto, este gráficocomparará la fracción de test de la serie con las predicciones correspondientes, de forma que se puedaapreciar visulamente la calidad del modelo y su ajuste a la predicción.

4.2.6. Pipelines pipelines.py

Por ultimo queda el modulo de pipelines de predicción, este tiene como objetivo aportar una seriede flujos de trabajo prediseñados para facilitar la predicción de series sin necesidad de conocimientosprevios en el tema. Estos flujos contienen todos los pasos que contiene la librería y han sido descri-tos en los módulos anteriores. Debido a la complejidad de automatizar algunos procesos de analísisde los datos de entrada, se piden explícitamente algunos detalles de las series al usuario, como lasfrecuencias a las que se deben analizar o el formato de la columna de marcas de tiempo de los datosobligatoriamente. Otros parámetros como el horizonte a predecir o las métricas de error a utilizar seproporcionan con valores por defecto, de manera que se permita la customización de las prediccionessi es necesario. Los distintos flujos de predicción se detallan a continuación, en orden de complejidad.

Predicción Naive naive_prediction()Este flujo, como su nombre indica, lanza una predicción Naïve sobre los datos de partida, enconcreto estima los próximos puntos en el tiempo como la media de los 50 puntos anteriores.Es extremadamente rápida, utilizando un modelo extraído de la librería Sktime [2]. El objetivode esta predicción es la comparación con otras, de modo que se pueda apreciar si los modelosmás sofisticados mejoran con respecto al más básico.

Predicción rápida type = ’fast’En este caso, se hace uso del modelo KNeighborsRegressor, extraido de la librería sklearn [4].Es una aplicación del KNN convencional a regresiones. La predicción mediante este método

22


es bastante rápida, demorando alrededor de 10 segundos incluyendo la importación de datos.También es el primer caso en el que se incluye la opción de optimización de hiper-parámetrosutilizando métodos bayesianos con HyperOpt [17]. Añadiendo el parámetro opt=True al co-mando inicial, el script lanzará los dos modelos, que luego comparará por medio de su errorcuadrático medio (mse). Si el KNN tiene un error medio menor de partida, se procederá a a laoptimización del mismo durante 50 iteraciones por defecto, aunque el número de evaluacionesde HyperOpt se puede establecer mediante el parámetro opt_runs del comando inicial.

Predicción moderada type = ’balanced’Este caso incluye los modelos del anterior, pero añade además el algoritmo de predicciónLightGBM [31] de árboles de decisión con Gradient Boosting. Al entrenar más modelos, lademora de predicción es mayor, la predicción final se realizará con el modelo que menor erroraporte de partida, el cual se optimizará por defecto en HyperOpt con 50 evaluaciones.

Predicción lenta type = ’slow’A los anteriores se añade un modelo de red neuronal recurrente (RNN) Long Short-Term Me-mory (LSTM) mediante el paquete Keras [33]. El entrenamiento de la red se realiza durante 50épocas, tomando como datos de entrada un máximo de los 5000 últimos puntos de la serie, Altratarse de una arquitectura estándar, puede no adaptarse bien dependiendo de las característi-cas de la serie a estudiar, por lo que se toman también predicciones con los otros modelos, y seutiliza finalmente la que menor mse presente en los datos de validación.

Para realizar las predicciones, el comportamiento es similar al de Scikit-Learn, primero se debeinicializar un modelo creando una instancia de la clase Pipeline, para luego llamar a los distintosmétodos de ésta. Primero al fit o fit_opt() para entrenar el modelo y obtener métricas de error sobrela sección de test (sin o con optimización de hiper-parámetros respectivamente), y después predictpara realizar predicciones de momentos futuros. Utilizando esta jerarquía de comandos, se permiteuna predicción fiable desde el modelo rápido, que tiene oportunidad de mejorar conforme más tiempose otorgue al procesamiento. No se garantiza que la predicción lenta de mejores resultados que larápida, pero sí que este comando haya explorado más opciones y ha seleccionado el mejor modelodisponible para la serie en cuestión.

4.3. Integración continua y desarrollo continuo en git

En desarrollo de software existe el concepto de integración continua y desarrollo continuo (CI/CD),la cual es análoga a un control de calidad continuo sobre el código. El objetivo principal es de evitaren la medida de lo posible publicar una versión con errores o no funcional del código de un proyecto.

En el caso de este proyecto, se ha optado por utilizar la plataforma de CI/CD incluida con GitHub,GitHub Actions [35], principalmente por la facilidad que presenta al estar ya integrado con el reposi-torio desde el cual se distribuye el software. En este caso, el CI/CD del proyecto integra dos partes, elcontrol de licencia y el testado de componentes del código.

23


4.3.1. Licencia de código abierto

El proyecto al que corresponde este trabajo depende de una multitud de librerías y proyectos decódigo abierto para su correcto funcionamiento. A menudo, las licencias de las que vienen acompaña-dos estos proyectos son restrictivas en cuanto a los derechos de redistribución de trabajos derivados.En un proyecto con pocas dependencias, esto es fácil de gestionar, pero en proyectos como este, quedepende de más de 50 otros proyectos, comienza a ser más difícil.

Para facilitar el trabajo de análisis de dependencias y estudio de compatibilidad de la licencia delproyecto, se utiliza la herramienta gratuita FOSSA [36], la cual se encarga, en cada commit hecho enGitHub, de analizar los paquetes que usa la librería, desde un archivo requirements.txt, recopilandola información de cada uno e informando si existen conflictos.

De acuerdo con la información obtenida a partir del informe de FOSSA, se decide utilizar lalicencia MIT [37], la cual es una licencia permisiva, que permite la redistribución y modificación delcódigo mientras se preserve la licencia original junto al trabajo derivado, además de una notificacióndel copyright. Los detalles de la licencia se detallan a continuación:

Permitido el uso comercial o privado del código sin obligaciones en cuanto a la liberación delcódigo fuente.

Permitidas la redistribución y modificación del proyecto original.

Se debe incluir información del copyright original junto a cualquier modificación o redistribu-ción del proyecto, además del archivo de licencia original que cubre la sección del código queno haya sido modificada a posteriori.

El software se distribuye sin obligaciones y sin garantía, no se ofrece soporte de ningún tipoasociado a él.

4.3.2. Testado de componentes del código

Para distribuir el código, es importante haberse cerciorado de que funciona cada uno de los com-ponentes del proyecto. Para ello, se hace uso de GitHub Actions para crear un flujo de trabajo con cadacommit a la rama principal del repositorio. En este caso, los tests se ejecutan mediante el paquete Py-test [38], el cual comprueba que cada una de las pipelines de predicción presenta mejoras con respectoa una predicción Naïve. En este caso, los tests corresponden a lanzar una predicción sobre cada seriecon cada modelo, y analizar que se consigue un error menor al 100 % del obtenido por la predicciónNaïve. También hay tests correspondientes a componentes específicos, como la importación de datoso la creación de todas las cracterísticas y lags a partir de los datos de entrada.

También se comprueba la métrica asociada del code coverage, que representa la proporción delcódigo total que se ha testado. Esta métrica se presenta como un porcentaje, que representa la fracciónde elementos del código que se han comprobado por los tests. Para la representación de los gráficos deesta métrica, junto con los informes asociados, se utiliza la plataforma CodeCov.io [39], que generaun informe para cada commit en la rama master del repositorio git.

24


4.4. Interfaz gráfica utilizando FastAPI y SwaggerUI

En la filosofía del AutoML, para facilitar el acceso a la generación de predicciones a personasinexpertas, sería recomendable evitar la necesidad de utilizar directamente un lenguaje de programa-ción. Para hacer esto, se debe implementar una Application Programming Interface (API) de formaque se puedan lanzar predicciones directamente desde un navegador web.

Para construir la API, se propone FastAPI por su velocidad y ligereza, además de poder ser pro-gramada desde un script Python, lo que permite incluirla como un módulo más en la librería. Paralos métodos de esta API, se proponen 4, uno de importación de datos, con la instrucción POST ymediante el que subir un archivo csv al servidor, y dos GET correspondientes a las instrucciones fit ypredict, cada uno teniendo una series de parámetros opcionales según el modelo que se quiera utilizary el horizonte que se quiera predecir.

La Figura 4.2 muestra un ejemplo de la interfaz de usuario utilizando Swagger UI, accesiblemediante el url “/docs” de la api, la cual se compone de cuatro métodos, uno de tipo POST, paraenviar datos, y tres de tipo GET, para solicitar datos:

Fig. 4.2. Imagen de la interfaz de usuario de la API (Swagger UI)

GET / - Read RootEste método sirve para devolver información sobre la API a la hora de conectarse a ella. Noacepta ningún tipo de parámetro ni envio de datos, la respuesta que devuelve es constante y esel título de la API.

POST /UploadTraining/Sirve para subir el archivo y dar todos los parámetros necesarios. Cuando se lanza esta petición

25


al desde el cliente, el servidor inicializa la clase Pipeline con los parámetros que se indiquen.De esta forma ya se hacen la importación y la transformación de los datos con la inclusión decaracterísticas y lags generados. Por ello acepta como parámetros todos los argumentos que sepueden asignar a esa clase. La respuesta de este método devuelve información sobre los datosde test, así como la lista de características generadas y las que se han elegido por su importanciaentre las disponibles en formato json.

GET /Fit/ - Model FittingCuando se ejecuta este comando, se activa el método fit del modelo, entrenándolo con los datosde entrenamiento aportados en el método anterior. Por tanto, este método solo proporcionaráuna respuesta correcta si se ha ejecutado antes el /UploadTraining/. Si el proceso se puedeejecutar correctamente, se devolverán los datos predichos de test, así como los resultados de lasmétricas de error sobre los datos de test que se hayan elegido en el método anterior.

GET /Predict/ - Model PredictEn este método se lanzan las predicciones, el parámetro que acepta es la longitud del horizonte apredecir, un número entero. Las predicciones se lanzarán sobre la totalidad de los datos subidos,y a partir del último momento del que se disponga. La respuesta de éste método será una listacon la predicción al horizonte elegido (por defecto 50 periodos en el futuro).

26

5. RESULTADOS Y DISCUSIÓN

Para evaluar el funcionamiento de la librería asociada a este proyecto, se hacen pruebas con seriesde ejemplo, en la que se comprueba el comportamiento de los distintos estilos de predicción.

Sí que se puede evaluar la efectividad de las predicciones de la librería en el contexto de la inte-gración continua (CI), incluyendo en la librería pruebas de funcionamiento que se ejecuten cada vezque se actualice de forma sustancial el código. Para ello, en el repositorio de la librería se incluyencuatro series temporales distintas, todas obtenidas a partir de señales industriales para evaluar el com-portamiento de los algoritmos. Para automatizar las pruebas en para la integración continua se utilizala librería Pytest [38].

Las cuatro series se muestran en la Figura 5.1, se ha tratado de elegir cuatro series con perfilesdistintos para emular la diversidad de datos.

Para preservar el anonimato, al ser datos reales de compañías reales, se han eliminado los meta-datos de las series. Se ha preservado únicamente la fecha de adquisición de datos, ya que no se haconsiderado que sea información identificable. También se han interpolado cada una de ellas a unafrecuencia distinta, para poder comprobar el buen funcionamiento de la función de importación dedatos. Para ayudar a la identificación de las series a lo largo del apartado, se detallan algunas de suscaracterísticas en la Tabla 5.1, incluyendo la frecuencia de muestreo a la que han sido interpoladas.

Número de serie Rango de datos Frecuencia1 (2, 5) 10 minutos2 (0.2, 0.4) 1 minutos3 (0, 500) 15 minutos4 (0, -1) 5 minutos

Tabla 5.1. Información de las series temporales de ejemplo

27

CAPÍTULO 5. RESULTADOS Y DISCUSIÓN

Fig. 5.1. Series de ejemplo incluidas con TS-AutoML

5.1. Metodología de obtención de resultados

Una vez definidas las series de ejemplo es necesario caracterizar la metodología de validaciónde la efectividad de la librería. Para ello, es fundamental definir una problemática; "£Son mejoreslas predicciones tomadas por la librería que las tomadas de forma Naïve?". Para responder a estapregunta se decide implantar una métrica de error relativo, de forma que no dependa de los órdenesde magnitud de las series analizadas. Esta métrica compara el MSE de la predicción con los modelosML a una predicción Naïve que toma los 50 próximos puntos de la serie como la media de los 50anteriores. La expresión de esta métrica de error está descrita en la Ecuación 5.1 y se expresa como

28


un porcentaje.

ϵrel =MS Epred

MS Enaive∗ 100 [ %] (5.1)

Se ha establecido que un valor de error relativo menor al 100 % significa que las predicciones hanaportado una mejora con respecto a no haberlas lanzado, con lo que el funcionamiento de la libreríasería satisfactorio.

Para evaluar los resultados, se han lanzado las predicciones por cada modelo y serie, y se han reco-pilado los modelos de ML que se han tomado para cada una de las ejecuciones, y si su funcionamientopresenta una mejora con respecto al método Naïve.

5.2. Inspección numérica de resultados

Para evaluar los resultados, se han lanzado las predicciones para cada modelo y serie, y se hanrecopilado los modelos de ML que se han tomado para cada una de las ejecuciones, y si pasan laprueba de funcionamiento.

5.2.1. Predicción rápida

En el caso de las predicciones rápidas, solo estaban disponibles el modelo GLM y el modelo KNNpara las predicciones. Tras haber ejecutado las pruebas, descritas en la Tabla 5.2, se puede concluirque estos modelos son especialmente efectivos en las series de ejemplo 3 y 4.

En las cuatro series de datos se ha notado mejoría en lanzar las predicciones con respecto al mo-delo Naïve. Especialmente en la primera, en la que no se notaba estacionalidad ni tendencia a simplevista, se constata que ninguno de los dos modelos ha podido generar una predicción satisfactoria,siendo solo ligeramente mejor que la Naïve.

Número de serie Mejor Modelo Error relativo de test1 kNN 90.54 %2 kNN 78.80 %3 kNN 7.23 %4 kNN 16.26 %

Tabla 5.2. Relación de resultados para cada serie del modelo medio de predicción

La segunda serie de datos destaca por sus malos resultados, ya que a simple vista se observauna estacionalidad clara. Esto puede deberse a que la variación de la serie sea menor con respectoa su orden de magnitud, lo que haga que diferencias entre el valor real y el predicho tengan másimportancia relativo al valor de la serie. También se puede observar en la Figura 5.1 que el 3 de marzoa las 12:00, ocurrió una anomalía en la señal que puede haber proporcionado información errónea

29


al modelo. Esto se podría solucionar con una detección de anomalías, o un suavizado de las señalesantes de proceder a la fase de predicción.

5.2.2. Predicción media

Para la predicción a tiempo medio (Tabla 5.3), se puede ver que en tres de los cuatro casos,los errores de predicción se han mantenido constantes. Esto es acorde a la filosofía tomada para lalibrería, en la que más tiempo de procesamiento significa que se han explorado más modelos, pero nonecesariamente que la predicción de esa serie temporal en específico vaya a ser mejor que el modelorápido. En el caso en el que el modelo kNN o GLM tengan un mejor rendimiento que el LightGBM,la predicción óptima seguirá siendo la rápida, aunque se haya “perdido” tiempo en ajustar y predecircon otro modelo.

Número de serie Mejor Modelo Error relativo de test1 kNN 90.54 %2 LightGBM 73.99 %3 kNN 7.23 %4 kNN 16.26 %

Tabla 5.3. Relación de resultados para cada serie del modelo medio de predicción

Solo se ha notado mejoría en un caso, la serie 2, en la cual la mejora ha sido de un 4 % aproxima-damente. Se trata de una mejora sutil, pero sí que demuestra que la exploración de más modelos MLpresenta efectos positivos sobre las predicciones.

5.2.3. Predicción lenta

Finalmente, el comando de predicción lento, como se ha visto anteriormente, añade el modelode LSTM al repertorio. La inicialización de los pesos en este caso es aleatoria, por lo que éste tipode modelos pueden ser más impredecibles a la hora del entrenamiento. La Tabla 5.4 presenta losresultados de las predicciones hechas con slow_prediction() sobre las cuatro series de ejemplo.

Número de serie Mejor Modelo Error relativo de test1 LSTM 35.92 %2 LightGBM 73.99 %3 kNN 7.23 %4 kNN 16.26 %

Tabla 5.4. Relación de resultados para cada serie del modelo lento de predicción

En este caso, solo se ha cambiado la predicción para la primera serie, en la que se ha aplicado elmodelo LSTM. En este caso la mejoría es muy pronunciada con respecto a kNN. Se pasa de 90.54 %

30


de error relativo de test a tan solo un 35.92 %. Esto muestra que la serie LSTM ha sido capaz de captarmás patrones en los predictores, y ha sido capaz de captar una tendencia y estacionalidad en los datos.

5.2.4. Predicción rápida con optimización de hiper-parámetros

Una vez analizados los resultados de cada una de las pipelines de predicción, es momento deevaluar la efectividad de la optimización de hiper-parámetros sobre las predicciones, para ello, enprimer lugar se ejecuta la optimización sobre los modelos de la predicción rápida. De acuerdo con lafilosofía de esta predicción, se limita el número de conFiguraciones a 50. La Tabla 5.5 presenta losresultados de esta optimización.

Número de serie Mejor Modelo Error relativo de test1 kNN 87.96 %2 kNN 71.95 %3 kNN 6.04 %4 kNN 10.98 %

Tabla 5.5. Relación de resultados para cada serie del modelo rápido de prediccióncon 30 conFiguraciones de optimización de hiper-parámetros

En la Tabla se puede observar que la mejora dada por la optimización de hiper-parámetros sueleser pequeña, al menos con tan solo 50 conFiguraciones, siendo de media de alrededor de un 5 % conrespecto al error del modelo de inicio. en todos los casos se ha notado mejoría con respecto al modelode base, con lo que sigue siendo una buena opción una vez encontrado el modelo correcto, en el casode que se disponga de tiempo suficiente para su ejecución.

5.2.5. Predicción media con optimización de hiper-parámetros

En el caso de la optimización de hiper-parámetros con el modelo de predicción medio, cuyosresultados se presentan en la Tabla 5.6, la narrativa es similar. Las mejoras con respecto al modelosin optimización son marginales o bajas, pero siempre existe algún tipo de mejora, con lo que si sedispone de tiempo de optimización es recomendable utilizar la funcionalidad.

Número de serie Mejor Modelo Error relativo de test1 kNN 89.4 %2 LightGBM 71.22 %3 kNN 5.45 %4 kNN 12.88 %

Tabla 5.6. Relación de resultados para cada serie del modelo medio de prediccióncon 50 conFiguraciones de optimización de hiper-parámetros

31


De la Tabla de resultados destaca el comportamiento con respecto a la predicción rápida conoptimización de la serie 4. En la Tabla 5.5 el error obtenido es menor, aunque se prueben menosconFiguraciones de optimización con el mismo modelo de partida. Esto se debe a que HyperOpt tieneuna componente de aleatoriedad en su funcionamiento.

5.3. Inspección visual de los resultados

Los valores de las métricas de error de las predicciones con respecto a la sección de datos de testde las series no muestran toda la información. Para determinar la fiabilidad de los modelos, además dehacer un análisis cuantitativo, es necesario realizar otro cualitativo. en esta caso, el análisis cualitativoconsiste en una inspección de las series obtenidas con los modelos en comparación con los datosreales obtenidos.

5.3.1. Predicciones de la serie 1

Los valores predichos para la serie 1 se representan en la Figura 5.2. Como ya se vio en el análisiscuantitativo de resultados, se trata de una serie bastante difícil de predecir con exactitud, al carecer detendencia o estacionalidad clara.

Fig. 5.2. Datos reales vs predicciones de TS-AutoML sobre la serie 1 de ejemplo

En la Figura se puede ver que los modelos rápido y medio de predicción sin optimización de hiper-parámetros son equivalentes en este caso, siendo los dos usando el algoritmo kNN. Aunque se apreciaque algunos de los picos de la serie original son imitados en menor medida por las predicciones, engeneral tanto la tendencia como los picos no han sido bien capturados por el modelo ML.

32


En el caso de la predicción lenta, se puede observar que la tendencia es mejor captada que para losotros algoritmos, lo que se observa también en la reducción del valor del error relativo de la prediccióncon LSTM. Esto indica que el modelo de red neuronal recurrente podría ser más efectivo para datosmás abstractos.


En la serie 2 es en la única en la que se ha elegido utilizar el modelo LightGBM por encima dekNN en el momento de pasar a la predicción media, como se puede observar en la Figura 5.3.

En este caso, se puede ver que el modelo de kNN ha sido especialmente inadecuado para capturarinformación de la serie, aproximando la predicción de la serie como un valor constante con varia-ciones mínimas. La predicción presenta algún pico, los cuales siguen algunos de los presentes enlos datos de test, pero predice una serie con bastante variabilidad pero tendencia constante de forma“conservadora ”.


En las predicciones media y lenta, la predicción con LightGBM demuestra ser más potente en estecaso, aún teniendo potencial de mejora, ya sea optimizando los datos de entrada con un preprocesado ofiltrado de la señal, o mediante la optimización de hiper-parámetros del modelo. En general se observaque la predicción de LightGBM no es una linea recta, sino que tiene bastante más variabilidad que elkNN, y algunos de los picos de loa predicción se corresponden en menor medida con los de la seriede test.

33



La serie número 3 es un ejemplo de uno de los mejores casos que pueden ser dados a la librería,esta tiene una estacionalidad clara, con tendencia clara y en general es fácilmente predecible. Esto sedemuestra en la Figura 5.4, donde la predicción, desde la aplicación del modelo rápido, se asemejamucho a los datos reales de la serie. Tan solo al final de los 50 periodos de predicción se ve que elperfil de la predicción se desacopla de la serie de ejemplo.

Cabe destacar que la predicción más satisfactoria se ha conseguido con el modelo más “simple”,tanto LightGBM como LSTM no han conseguido alcanzar un valor de error menor a éste, a pesar detratarse de modelos más complejos que deberían poder extraer más información de los predictores.



En la Figura 5.5, se puede observar que las predicciones sobre la serie 4 se mantienen otra vez enlos tres niveles de procesamiento, es decir que el modelo kNN es el óptimo de partida en este caso.

34



Se puede ver que el algoritmo elegido ha conseguido capturar correctamente la tendencia de laserie al alza, aunque no tiene precisión en cuanto a la exactitud de los valores. También se puede ver,en algunos puntos de datos, como el de las 06:30, que se ha conseguido predecir algunos eventos enconcreto de la serie, y que el perfil diferencial de la serie (si sube o baja en un momento concreto)suele coincidir con los datos de test. Esto nos lleva a pensar que las predicciones sobre esta seriepodrían mejorar con la optimización de hiper-parámetros.

En este caso, los valores de error numéricos obtenidos son bastante bajos, sin embargo, a la horade inspeccionar los datos se puede ver que las predicciones podrían mejorar bastante, al menos en estasección de test. Aún así, según la aplicación que se le quiera dar al modelo elegido, las prediccionespodrían ser suficientemente fiables.

5.3.5. Mejoras de predicción con optimización de hiper-parámetros

En esta sección se van a tomar las predicciones de la serie de ejemplo con mayor potencial deoptimización de predicción, en concreto la cuarta. Además, esto permitirá observar los efectos de laoptimización de hiper-parámetros en el algoritmo kNN a dos niveles, con 30 y 50 conFiguraciones deoptimización. Para ello, se toman las mejores predicciones tomadas con los algoritmos no optimiza-dos, y se comparan a los resultados con 30 y 50 conFiguraciones de optimización. Esto se puede veren la Figura 5.6.

35


Fig. 5.6. Comparaciones de la mejoría de predicción con optimización en la serie 4

En la gráfica de la Figura 5.6 se ve que la optimización, al menos en su iteración actual es impre-decible. El algoritmo de optimización de HyperOpt tiene una componente aleatoria, por lo que, comose ve en la Figura y en los datos de las Tablas 5.6 y 5.5. Se puede ver que, aunque en los dos casos sehaya reducido el error en comparación con el modelo sin optimizar, no necesariamente se mejora lapredicción con un mayor número de iteraciones, al menos siendo el número relativamente bajo comoen este caso. También se puede ver que HyperOpt añade variabilidad a las predicciones, lo cual sueleser indeseado si se quiere garantizar un comportamiento fiable de la librería.

En la Figura se aprecia que en las predicciones con solo 30 iteraciones, la zona media de lapredicción se ha adaptado muy bien a los datos reales, a costa de tener más error la zona inicial yfinal del test. En la segunda iteración se observa que la optimización es mas sutil, se ha desuavizadola curva del kNN inicial, habiéndose captado más información de los picos de la serie además de dela tendencia.

36

6. CONCLUSIÓN

La motivación para la elaboración de este trabajo fue, desde el principio, reducir la barrera deentrada de la predicción de series temporales para personas inexpertas en la ciencia de datos. En estosmomentos del desarrollo de la herramienta TS-AutoML, se considera que esto se ha conseguido,aunque todavía haya pasos a seguir para aumentar la facilidad de uso y las capacidades de la libreríaen el futuro, como se muestra en el capítulo 7.

En concreto se han eliminado algunas labores del perfil de científico de datos, automatizándolastras un entorno low-code [40]. En primer lugar se ha automatizado la importación y la interpolaciónde los datos temporales a una frecuencia constante, que a su vez puede eliminar valores inválidosen la serie o datos que falten. Se ha optado por no hacer suavizado de las series para evitar posiblespérdidas de información o no afectar a las predicciones de datos muy variables. Principalmente se haeliminado la necesidad de elegir un modelo de predicción adecuado a los datos mediante los tres tiposde predicción de la librería (fast, balanced y slow), los cuales permiten explorar distintos algoritmosML en función del tiempo de computación del que se dispone, eligiendo el mejor de acuerdo con elerror medio de ajuste que genera cada uno sobre una porción de validación de la serie. Para mejorar lacomprensibilidad de la bondad de ajuste de los modelos de la librería, se utiliza una medida agnósticaa la escala y variabilidad de la serie, que sea fácilmente entendible para una persona no especializada.Se introduce como métrica un error relativo a la predicción Naïve. En general, un porcentaje de mejoraserá más fácil de entender que una cifra dependiente de la escala de los datos. Finalmente tambiénse ha automatizado en parte la analítica de datos, mediante el módulo plotting.py, el cual permitevisualizar en gráficas interactivas los datos de entrenamiento de la serie, o el detalle del ajuste de laserie en los datos de validación.

TS-AutoML como trabajo de fin de máster ha permitido explorar todo el ciclo de vida de un pro-yecto en ciencia de datos. Se realizó la prueba de distintos algoritmos, en la que se probaron distintosalgoritmos caracterizando sus parámetros para conseguir las configuraciones óptimas por defecto pa-ra cada uno, además de los métodos de optimización mediante HyperOpt. También se han exploradolas tareas de desarrollo de proyectos informáticos, mediante el uso de la herramienta de versionadoGit, el aseguramiento de calidad continuo utilizando PyTest y GitHub Actions, o el empaquetado delsoftware en un paquete de Python instalable, que incluya información de sus dependencias usando laherramienta Poetry. También se han podido explorar las formas de facilitar la exploración de código,como puede ser la división de la librería en módulos, o las descripciones o docstrings en las funcionesy clases.

37

7. PRÓXIMOS PASOS

Durante la elaboración de este proyecto, se han hecho aparentes posibles adiciones para su me-jora. Estas ediciones van desde mejoras de rendimiento a nuevas funcionalidades, y se detallan acontinuación:

Mejora de rendimiento - Numpy.En su iteración actual, la librería depende de dos librerías básicas para las estructuras de datos yoperaciones básicas, NumPy [28] y Pandas [41]. El problema surge de la utilización de Pandas,que, aunque aporta muchas facilidades para análisis temporal, ofrece un peor rendimiento engeneral a la hora de modificar sus estructuras (DataFrames) debido a su mayor complejidad.

Reducir la dependencia de la librería de las estructuras de pandas podrá probablemente reducirel tiempo de procesamiento para creación de características y, por tanto, para hacer las pre-dicciones. También abriría la puerta a la aplicación de computación distribuida para continuarmejorando el rendimiento.

Mejora de Rendimiento - Compilado Just-in-Time con Numba.Los lenguajes de programación dinámicos interpretados como Python o R son atractivos parael prototipado rápido y elaboración de pruebas con modelos fácilmente, pero en entornos deproducción carecen de la velocidad de lenguajes compilados como C. Esto no significa quesea necesario migrar todo el código de la librería a un lenguaje compilado, existe una libreríallamada Numba para asemejar el rendimiento al de otros lenguajes más rápidos [42].

Esta librería utiliza un sistema llamado compilado “Just in Time” (JIT), en vez de hacer el com-pilado de una función cada vez que se realiza una llamada, la función se compila únicamenteen la primera llamada, acelerando todas las llamadas siguientes. Esto aceleraría especialmentela fase de creación de características, donde la función create_sample_feat, encargada de crearla matriz de datos de entrenamiento, es llamada cientos de veces antes de una predicción.

Mejora de Rendimiento - Computación distribuida con Dask.Los tres comandos de predicción de la librería, lento, medio y rápido, tienen cada uno variosmodelos ML que se ejecutan antes de elegir el mejor. En la iteración actual, estos modelos seentrenan y ejecutan en serie. En la actualidad, los ordenadores suelen tener varios núcleos deprocesamiento, los cuales en ocasiones se quedan inactivos para algunos algoritmos.

Para acelerar los tres métodos de predicción, es necesario implementar una forma de compu-tación distribuida para entrenar los modelos de forma simultanea. Para problemas de big data,existe Apache Spark [43], que distribuye un trabajo grande en tareas, las cuales se procesan enun cluster de trabajadores paralelos. Spark está diseñado para funcionar en una colección desistemas interconectados entre sí, por lo que es una solución excesivamente compleja para estautilización.

38

CAPÍTULO 7. PRÓXIMOS PASOS

En Python, existe la librería Dask [44], la cual tiene una funcionalidad muy similar a Spark,pero se integra fácilmente con Python y permite la paralelización de tareas dentro de una mismamáquina. La integración de este sistema permitiría la aceleración de la tarea de entrenamientoy predicción de modelos en la librería.

Mejora de predicción - Adición de modelos.Para mejorar la calidad de las predicciones, se ha dado pie para añadir fácilmente otros modelosde regresión a la librería. Un primer paso sería introducir otro modelo de redes además de laLSTM, por ejemplo una Temporal Convolutional Network (TCN) [45]. También se podríanañadir otros modelos de Gradient Boosting de árboles de decisión, como CatBoost o XGBoost,así como otro de Random Forest con Scikit-Learn.

Mejora de predicción - Adición de características.Se propone también la adición de más características para la aumentación de datos previa alentrenamiento de los modelos. Esto se podría hacer tomando como inspiración librerías espe-cializadas para cálculo de características como pueden ser TSFresh [16]. Hacer esto permiteexprimir más la información disponible en los datos de entrada.

Mejora de funcionalidad - Otras operaciones de análisis de series temporales.Por ultimo, se propone la adición de otras operaciones con series temporales para añadir alrepertorio de la librería, como pueden ser soporte para clasificación, de modo que se puedautilizar, por ejemplo, para detección de anomalías o análisis de las series.

39

BIBLIOGRAFÍA

[1] S. J. Taylor y B. Letham, “Forecasting at scale,” The American Statistician, vol. 72, n.o 1,pp. 37-45, 2018.

[2] M. Löning et al., “sktime: A Unified Interface for Machine Learning with Time Series,” enWorkshop on Systems for ML at NeurIPS 2019, 2019.

[3] G. Van Rossum, B. Warsaw y N. Coghlan, “PEP 8: style guide for Python code,” Python. org,vol. 1565, 2001.

[4] F. Pedregosa et al., “Scikit-learn: Machine Learning in Python,” Journal of Machine LearningResearch, vol. 12, pp. 2825-2830, 2011.

[5] R. De Arce y R. Maha, “Modelos Arima,” Programa CITUS: Técnicas de Variables Financie-ras, 2003.

[6] E. B. Dagum y S. Bianconcini, Seasonal adjustment methods and real time trend-cycle estima-tion. Springer, 2016.

[7] P. Bloomfield, Fourier analysis of time series: an introduction. John Wiley & Sons, 2004.

[8] R. J. Hyndman y G. Athanasopoulos, Forecasting: principles and practice. OTexts, 2018.

[9] L. Herrera et al., “Recursive prediction for long term time series forecasting using advancedmodels,” Neurocomputing, vol. 70, n.o 16, pp. 2870-2880, 2007, Neural Network Applicationsin Electrical Engineering Selected papers from the 3rd International Work-Conference on Ar-tificial Neural Networks (IWANN 2005). doi: https://doi.org/10.1016/j.neucom.2006.04.015. [En línea]. Disponible en: https://www.sciencedirect.com/science/article/pii/S0925231207001622.

[10] I. El Naqa y M. J. Murphy, “What is machine learning?” En machine learning in radiationoncology, Springer, 2015, pp. 3-11.

[11] J. H. Friedman, “Stochastic gradient boosting,” Computational statistics& data analysis, vol. 38,n.o 4, pp. 367-378, 2002.

[12] G. P. Zhang, “Neural Networks for Time-Series Forecasting,” en Handbook of Natural Compu-ting, G. Rozenberg, T. Bäck y J. N. Kok, eds. Berlin, Heidelberg: Springer Berlin Heidelberg,2012, pp. 461-477.

[13] C. Olah, “Understanding lstm networks,” 2015.

[14] S. Hochreiter y J. Schmidhuber, “Long short-term memory,” Neural computation, vol. 9, n.o 8,pp. 1735-1780, 1997.

[15] S. Siami-Namini, N. Tavakoli y A. S. Namin, “A comparison of ARIMA and LSTM in fore-casting time series,” en 2018 17th IEEE International Conference on Machine Learning andApplications (ICMLA), IEEE, 2018, pp. 1394-1401.

40

https://doi.org/https://doi.org/10.1016/j.neucom.2006.04.015

https://doi.org/https://doi.org/10.1016/j.neucom.2006.04.015

https://www.sciencedirect.com/science/article/pii/S0925231207001622

https://www.sciencedirect.com/science/article/pii/S0925231207001622

BIBLIOGRAFÍA

[16] M. Christ, N. Braun, J. Neuffer y A. W. Kempa-Liehr, “Time series feature extraction on basisof scalable hypothesis tests (tsfresh–a python package),” Neurocomputing, vol. 307, pp. 72-77,2018.

[17] B. Komer, J. Bergstra y C. Eliasmith, “Hyperopt-sklearn: automatic hyperparameter configu-ration for scikit-learn,” en ICML workshop on AutoML, Citeseer, vol. 9, 2014, p. 50.

[18] X. He, K. Zhao y X. Chu, “AutoML: A Survey of the State-of-the-Art,” Knowledge-BasedSystems, vol. 212, p. 106 622, 2021.

[19] G. Holmes, A. Donkin e I. H. Witten, “Weka: A machine learning workbench,” en Proceedingsof ANZIIS’94-Australian New Zealnd Intelligent Information Systems Conference, IEEE, 1994,pp. 357-361.

[20] A. Truong et al., “Towards automated machine learning: Evaluation and comparison of Au-toML approaches and tools,” en 2019 IEEE 31st International Conference on Tools with Arti-ficial Intelligence (ICTAI), IEEE, 2019, pp. 1471-1479.

[21] L. Kotthoff, C. Thornton, H. H. Hoos, F. Hutter y K. Leyton-Brown, “Auto-WEKA: Auto-matic model selection and hyperparameter optimization in WEKA,” en Automated MachineLearning, Springer, Cham, 2019, pp. 81-95.

[22] M. Feurer et al., “Auto-sklearn: efficient and robust automated machine learning,” en Automa-ted Machine Learning, Springer, Cham, 2019, pp. 113-134.

[23] E. LeDell y S. Poirier, “H2o automl: Scalable automatic machine learning,” en Proceedings ofthe AutoML Workshop at ICML, vol. 2020, 2020.

[24] H. Jin, Q. Song y X. Hu, “Auto-keras: Efficient neural architecture search with network morphism,”arXiv preprint arXiv:1806.10282, vol. 5, 2018.

[25] B. Warsaw, J. Hylton, D. Goodger y N. Coghlan, “PEP Purpose and Guidelines,” Python En-hancement Proposals, vol. PEP 1, jun. de 2000. [En línea]. Disponible en: http://www.python.org/dev/peps/pep-0001/.

[26] PyCQA, PyCQA/flake8. [En línea]. Disponible en: https://github.com/PyCQA/flake8.

[27] D. Goodger y G. van Rossum, PEP 257 – Docstring Conventions, mayo de 2001. [En línea].Disponible en: https://www.python.org/dev/peps/pep-0257/.

[28] C. R. Harris et al., “Array programming with NumPy,” Nature, vol. 585, pp. 357-362, 2020.doi: 10.1038/s41586-020-2649-2.

[29] S. Seabold y J. Perktold, “Statsmodels: Econometric and statistical modeling with python,” enProceedings of the 9th Python in Science Conference, Austin, TX, vol. 57, 2010, p. 61.

[30] J. A. Nelder y R. W. Wedderburn, “Generalized linear models,” Journal of the Royal StatisticalSociety: Series A (General), vol. 135, n.o 3, pp. 370-384, 1972.

[31] G. Ke et al., “Lightgbm: A highly efficient gradient boosting decision tree,” Advances in neuralinformation processing systems, vol. 30, pp. 3146-3154, 2017.

41

http://www.python.org/dev/peps/pep-0001/

http://www.python.org/dev/peps/pep-0001/

https://github.com/PyCQA/flake8

https://www.python.org/dev/peps/pep-0257/

https://doi.org/10.1038/s41586-020-2649-2

BIBLIOGRAFÍA

[32] E. Al Daoud, “Comparison between XGBoost, LightGBM and CatBoost using a home cre-dit dataset,” International Journal of Computer and Information Engineering, vol. 13, n.o 1,pp. 6-10, 2019.

[33] F. Chollet et al. (2015). “Keras,” [En línea]. Disponible en: https://github.com/fchollet/keras.

[34] P. T. Inc. (2015). “Collaborative data science,” [En línea]. Disponible en: https://plot.ly.

[35] T. Kinsman, M. Wessel, M. A. Gerosa y C. Treude, “How Do Software Developers Use GitHubActions to Automate Their Workflows?” arXiv preprint arXiv:2103.12224, 2021.

[36] Scalable Open Source Management, 2021. [En línea]. Disponible en: https://fossa.com/.

[37] O. Initiative et al., “The MIT License (MIT),” online] Available: http://opensource.org/license-s/MIT.[Accessed: June 2021], 2006.

[38] A. Pajankar, “pytest,” en Python Unit Test Automation, Springer, 2017, pp. 87-100.

[39] The Leading Code Coverage Solution, abr. de 2021. [En línea]. Disponible en: https://about.codecov.io/.

[40] R. Sanchis, Ó. Garca-Perales, F. Fraile y R. Poler, “Low-code as enabler of digital transforma-tion in manufacturing industry,” Applied Sciences, vol. 10, n.o 1, p. 12, 2020.

[41] J. Reback et al., “pandas-dev/pandas: Pandas 1.0. 3,” Zenodo, 2020.

[42] S. K. Lam, A. Pitrou y S. Seibert, “Numba: A llvm-based python jit compiler,” en Proceedingsof the Second Workshop on the LLVM Compiler Infrastructure in HPC, 2015, pp. 1-6.

[43] A. Spark, “Apache spark,” Retrieved January, vol. 17, p. 2018, 2018.

[44] M. Rocklin, “Dask: Parallel computation with blocked algorithms and task scheduling,” enProceedings of the 14th python in science conference, Citeseer, vol. 126, 2015.

[45] R. Wan, S. Mei, J. Wang, M. Liu y F. Yang, “Multivariate temporal convolutional network:A deep neural networks approach for multivariate time series forecasting,” Electronics, vol. 8,n.o 8, p. 876, 2019.

42

https://github.com/fchollet/keras

https://github.com/fchollet/keras

https://plot.ly

https://fossa.com/

https://about.codecov.io/

https://about.codecov.io/

ANEXO I: GLOSARIO DE TÉRMINOS

API REST Conjunto de protocolos e instrucciones para facilitar la comunicaciónentre aplicaciones informáticas.

ARIMA Modelo de predicción de series temporales que integra componenteauto-regresivo con la media móvil.

AutoML Acción de automatizar la tarea de aplicar modelos de ML a problemasreales.

FastAPI Framework para la construcción de APIs en el lenguaje de programa-ción Python.

Framework Entorno de trabajo para tratar una problemática (en contexto de infor-mática).

GitHub Plataforma online para desarrollo colaborativo de proyectos de progra-mación.

HyperOpt Librería de Python para optimización bayesiana de hiper-parámetros.Keras Framework basado en TensorFlow para la creación de arquitecturas de

redes neuronales.LightGBM Modelo de predicción basado en árboles de decisión con gradient boos-

ting.Machine Learning Automatización de la generación de modelos para el análisis de datos.Media Movil (En una serie de datos) Media de los datos tomada en grupos consecu-

tivos de una longitud concreta.Overfitting (De un modelo) Cuando el error de ajuste es muy bajo en la sección de

entrenamiento, pero alto en la de test.Pandas Librería de Python para manjear datos tabulados.Pipeline Estructura que engloba todas las fases de una tarea de ML.Predicción Naïve Predicción de una serie temporal tomando un criterio simple.Prophet Librería de python para predicción de series temporales elaborada por

Facebook.Python EnhancementProposals

Documentación de Python indicando sus usos o mejoras a lo largo deldesarrollo.

SciKit-Learn Librería general de Python que engloba métodos de data science.Serie Temporal Univa-riada

Serie temporal la cual solo cuenta con una serie de datos además deltiempo.

Swagger UI Interfaz web para documentación de APIs.Ventana Deslizante Intervalo de datos para el cual se calcula una carácterística.Dataset Conjunto de datos.lag Valores pasados de una variable de una serie temporal.

Tabla 7.1. Glosario de términos referenciados a lo largo del trabajo

ANEXO II: ACRÓNIMOS

API Application Programming InterfaceARIMA Auto-Regressive Integrated Moving AverageCI/CD Continuous Integration / Continuos DeliveryCIC Consulting Informático de Cantabria

GLM Generalized Linear ModelIA (ML) Inteligencia Artifical (Machine Learning)

JIT Just In TimeLSTM Long Short Term MemoryMAPE Mean Average Percentage ErrorMSE Mean Square ErrorODS Objetivos de Desarrollo Sostenible

ONU (UN) Organización de las Naciones Unidas (United Nations)PEP Python Enhancement ProposalRNN Recurrent Neural Network

RMSE Root Mean Square ErrorTCN Temporal Convolutional NetworkUC Universidad de Cantabria

kNN k-Nearest Neighbors

Tabla 7.2. Lista de Acronimos (En orden alfabético)

ANEXO III: ENLACES

Repositorio de GitHub https://github.com/MMurilloGlez/ts-automlPágina GitHub pages https://mmurilloglez.github.io/ts-automl/Página del repositorio en codecov.io https://codecov.io/gh/MMurilloGlez/ts-automlDOI (Zenodo) 10.5281/zenodo.5040064

Tabla 7.3. Enlaces a recursos del trabajo

CREACIÓN DE LIBRERÍA PARA PREDICCIÓN DE SERIES …

Documents

Transcript of CREACIÓN DE LIBRERÍA PARA PREDICCIÓN DE SERIES …