Generación de una herramienta de machine learning para apoyar a depertistas

GENERACIÓN DE UNA HERRAMIENTA DE MACHINE LEARNING QUE SIRVA COMO APOYO A DEPORTISTAS. GENERATION OF A MACHINE LEARNING TOOL TO SUPPORT ATHLETES. TRABAJO FIN DE GRADO CURSO 2023-2024 AUTORES JUAN ISRAEL BAROFFI GONZÁLEZ JAVIER MARÍA PARRA GONZÁLEZ DIRECTOR ISMAEL SAGREDO OLIVENZA GRADO EN INGENIERÍA DE COMPUTADORES FACULTAD DE INFORMÁTICA UNIVERSIDAD COMPLUTENSE DE MADRID GENERACIÓN DE UNA HERRAMIENTA DE MACHINE LEARNING PARA APOYAR A DEPORTISTAS. GENERATION OF A MACHINE LEARNING TOOL TO SUPPORT ATHLETES. TRABAJO DE FIN DE GRADO EN INGENIERÍA DE COMPUTADORES AUTORES JUAN ISRAEL BAROFFI GONZÁLEZ JAVIER MARÍA PARRA GONZÁLEZ DIRECTOR ISMAEL SAGREDO OLIVENZA CONVOCATORIA: SEPTIEMBRE 2024 GRADO EN INGENIERÍA DE COMPUTADORES FACULTAD DE INFORMÁTICA UNIVERSIDAD COMPLUTENSE DE MADRID 12 DE SEPTIEMBRE DE 2024 2 DEDICATORIA A mi familia y amigos, por su constante apoyo y aliento. Y, sobre todo, a aquellas personas que buscan mejorar continuamente; este trabajo está dedicado a vosotros. - Juan Israel Baroffi González A mi familia por confiar y apoyarme durante todo el desarrollo del proyecto, os lo decido. - Javier María Parra González 3 AGRADECIMIENTOS JUAN ISRAEL BAROFFI GONZÁLEZ En primer lugar, quiero agradecer a nuestro tutor, Ismael Sagredo Olivenza, por su constante apoyo y sus valiosos consejos durante este proyecto de fin de grado. Gracias a él y a su manera de enseñar, me sentí realmente motivado a realizar este trabajo relacionado con la inteligencia artificial. Trabajar con él ha sido una experiencia realmente gratificante. También quiero agradecer a mis amigos y a mi familia, quienes me han brindado su apoyo incondicional a lo largo de todo este proceso. Sin ellos, sin duda, no estaría donde estoy hoy. Gracias de corazón. Por último y no menos importante, quiero agradecer a Javier María Parra González, mi compañero en este arduo trabajo. Hemos pasado por muchas cosas juntos durante este proceso, y ha sido un verdadero placer trabajar a su lado. JAVIER MARÍA PARRA GONZÁLEZ Quiero aprovechar esta oportunidad para agradecer a todas las personas que, de forma directa o indirecta, han sido parte de este proceso. En particular a nuestro tutor Ismael Sagredo Olivenza, por el contante apoyo y esfuerzo para que este trabajo de fin de grado pudiera salir adelante. Del mismo modo, quiero agradecer a mi familia por confiar en mí, y especialmente a mi abuelo Pepe, por su valiosos consejos e ideas durante el desarrollo del proyecto. Finalmente, agradecer a mi compañero Juan Israel Baroffi González, por confiar en mi para desarrollar juntos el proyecto, así como por sus importantes contribuciones al mismo. 4 RESUMEN GENERACIÓN DE UNA HERRAMIENTA DE MACHINE LEARNING PARA APOYAR A DEPORTISTAS En este trabajo final de grado hemos creado una aplicación útil diseñada para los deportistas. Se trata de una aplicación en la que el uso de Machine Learning está presente con el que nos ayudará a predecir en el futuro distintos valores que el usuario desee, ya sea ritmo cardiaco, calorías, pasos, entre otros. Con esto, el usuario puede ver y analizar los datos para su mejor rendimiento deportivo. La aplicación funciona gracias a la recopilación de datos facilitada por la plataforma Fitbit. Mediante peticiones realizadas a la API de Fitbit, podemos obtener los datos necesarios mediante una pulsera para su futuro procesamiento. Se recopilan todos los datos necesarios para predecir valores futuros según las preferencias del usuario. Una vez recopilados los datos, la aplicación permite gestionar estos datos, mostrando gráficos y estadísticas, así como el estado futuro del deportista en un intervalo de tiempo. De esta manera, se puede evaluar si el deportista está logrando sus metas, si debiese aumentar o disminuir el ritmo, y hacer un seguimiento detallado del ejercicio que está realizando. Palabras clave Machine learning, deporte, aplicación, regresión, resultados, API, pulsera de actividad, ritmo cardiaco, predicción, inteligencia artificial. 5 ABSTRACT CREATION OF A MACHINE LEARNING TOOL TO SUPPORT ATHLETES In this final degree project, we have developed a useful application designed for athletes. This is an application where the use of Machine Learning is integrated to help predict various values the user desires in the future, such as heart rate, calories, steps, among others. With this, the user can view and analyse the data to improve their sports performance. The application works by collecting data provided by the Fitbit platform. Through requests made to the Fitbit API, we can obtain the necessary data via a wristband for future processing. All necessary data is collected to predict future values according to the user's preferences. Once the data is collected, the application allows users to manage this data by displaying graphs and statistics, as well as the athlete's future status within a specified time frame. This enables the user to assess whether they are meeting their goals, whether they need to increase or decrease their pace, and to track the details of the exercises they are performing. Keywords Machine learning, sports, application, regression, results, API, wearables, heart rate, prediction, artificial intelligence. 6 ÍNDICE DE CONTENIDOS Capítulo 1 - Introducción .................................................................................................14 1.1 Motivación ...........................................................................................................14 1.2 Objetivos ..............................................................................................................15 1.3 Plan de trabajo ....................................................................................................17 Capítulo 2 - Estado de la cuestión ..................................................................................20 2.1 Diferentes tipos de datos ....................................................................................20 2.2 Modelos de ML utilizados ...................................................................................23 2.2.1 Modelos de predicción para la base de datos de Kaggle ............................25 2.2.2 Modelos de predicción con datos reales. ........................................................34 2.3 Elementos de trabajo ..........................................................................................35 2.3.1 Lenguaje de programación. ..............................................................................35 2.3.2 Entorno de desarrollo. .........................................................................................37 2.3.3 Control de versiones. ..........................................................................................38 2.4 Trabajos relacionados .........................................................................................38 Capítulo 3 - Investigación, Manipulación de Datos y Desarrollo de la Aplicación ....43 3.1 Investigación Inicial del Proyecto ......................................................................43 3.1.1 Base de datos de Kaggle ...................................................................................43 3.1.2 Estudio de las variables de los CSV de Kaggle .................................................47 3.2 Manipulación de datos y primeros modelos predictivos .................................49 3.2.1 Unificación de datos para los modelos de ML .................................................49 3.2.2 Análisis de los modelos predictivos de ML ........................................................51 3.2.3 Conclusión de los análisis de los modelos predictivos .....................................57 7 3.3 Integración de la Pulsera Fitbit y uso de la API .................................................58 3.3.1 Primeras investigaciones .....................................................................................58 3.3.2 Primeras llamadas a la API .................................................................................59 3.3.3 Adquisición de dispositivo ..................................................................................60 3.3.4 Recopilación de datos .......................................................................................61 3.3.5 Unificación de los datos .....................................................................................68 3.4 Análisis de los modelos predictivos de ML con datos extraídos con la API ...69 3.5 Implementación y Desarrollo de la Aplicación HeartPred’it ...........................75 3.5.1 Diseño de la aplicación ......................................................................................75 3.5.2 Arquitectura de la aplicación ............................................................................83 3.5.3 Lógica de los propósitos .....................................................................................87 Capítulo 4 - Conclusiones y trabajo futuro .....................................................................91 4.1 Conclusiones ........................................................................................................91 4.2 Trabajos futuros ....................................................................................................92 Introduction .............................................................................................................................94 Motivation ...........................................................................................................................94 Goals ....................................................................................................................................95 Work plan ............................................................................................................................96 Conclusions and future work .................................................................................................98 Conclusions .........................................................................................................................98 Future Work .........................................................................................................................99 Bibliografía............................................................................................................................. 106 8 ÍNDICE DE FIGURAS Figura 1-1: Esquema proceso SCRUM. ..................................................................................17 Figura 2-1: Logotipo de Kaggle. Fuente: (Databuff, 2011) .................................................20 Figura 2-2: Ejemplo de un archivo CSV donde cada fila contiene datos estructurados según los encabezados definidos en la primera línea. ...............................................21 Figura 2-3: Esquema donde se muestra el flujo desde la recopilación de datos de la pulsera hasta la aplicación HeartPred’it. .....................................................................22 Figura 2-4: Ejemplo de la respuesta en formato JSON a una solicitud de datos de frecuencia cardíaca. .....................................................................................................23 Figura 2-5: Logotipo de pandas. Fuente: (Garcia, 2019) ....................................................24 Figura 2-6: Esquema representativo del modelo predictivo MLP Regressor. Fuente: (Spotfire, s.f.) ....................................................................................................................26 Figura 2-7: Esquema representativo del modelo predictivo XGBoost. Fuente: (mariajesusbigml, 2017) ..................................................................................................27 Figura 2-8: Logo de LightGBM. Fuente: (Microsoft, LightGBM, 2023) .................................27 Figura 2-9: Esquema representativo del modelo predictivo LSTM. Fuente: (Shenfield & Howarth, 2020) ................................................................................................................28 Figura 2-10: Ejemplo de métricas de distancia de un punto Xa a un punto Xb. Fuente: (Fu & Yang, 2021) ..................................................................................................................29 Figura 2-11: Esquema representativo del modelo predictivo KNN Regressor. Fuente: (Bacallado & Taylor, 2022) .............................................................................................30 Figura 2-12: Un ejemplo de un esquema representativo de un árbol de decisión de regresión. Fuente: (Hui & Ming, 2023) ............................................................................31 Figura 2-13: Un ejemplo de un esquema representativo de un SVR. Fuente: (Maulana Achsan, 2019) ..................................................................................................................32 15 1.2 Objetivos Nuestro principal objetivo en este trabajo es desarrollar una aplicación que permita a los deportistas mejorar su rendimiento deportivo a través del análisis de datos recopilados mediante la pulsera. 1. Definir y planificar el proyecto. • Especificar las propuestas y objetivos del trabajo de fin de grado. • Elaborar un plan de las fases del proyecto y los resultados esperados en cada una. 2. Analizar cómo procesar los datos para su posterior uso Machine Learning. • Investigar los distintos tipos de datos que se pueden obtener, utilizando una base de datos existente con información como ritmo cardíaco, calorías quemadas, intensidad del ejercicio, etc. • Estudiar y trabajar con la base de datos obtenida desde Kaggle, desarrollando diferentes algoritmos predictivos para encontrar el modelo más adecuado para los datos de nuestro propio dispositivo de recopilación. 3. Analizar la adquisición de dispositivo para la recopilación de datos de los deportistas. • Basándonos en la base de datos de Kaggle, buscar dispositivos capaces de recopilar datos similares. • Buscar dispositivos con los que se pueda obtener los datos mediante una API abierta. 4. Estudiar el uso de la API de Fitbit para recopilar datos mediante dispositivos wearables, utilizando librerías de Python. • Antes de adquirir el dispositivo, explorar cómo utilizar la API de Fitbit mediante la documentación disponible, haciendo peticiones sencillas como la obtención de datos de usuario. • Adquirir un dispositivo Fitbit y realizar las primeras peticiones API para obtener datos reales, como las pulsaciones por minuto del deportista, las calorías, etc. 5. Analizar los diferentes algoritmos de predicción con los datos reales obtenidos. • Realizar la limpieza de los datos obtenidos. 16 • Probar diferentes modelos predictivos y seleccionar los que ofrecen mejores resultados. 6. Crear una aplicación para el procesamiento y visualización de datos para los usuarios, permitiéndoles mejorar su rendimiento deportivo. • Desarrollar una aplicación de escritorio en Python capaz de visualizar y predecir los diferentes datos recopilados. 17 1.3 Plan de trabajo En cuanto al plan de trabajo, hemos seguido el modelo Scrum. Este modelo tiene un enfoque ágil que se utiliza mayoritariamente en el desarrollo de software. Hemos optado por este método ágil debido a nuestra familiaridad con él, adquirida a lo largo de la carrera. También porque permite ver los resultados al finalizar cada Sprint, esto ayuda a que se haga entregas incrementales y seguimiento del progreso del proyecto. Figura 1-1: Esquema proceso SCRUM. Antes de cada Sprint, planificamos las tareas y los objetivos que queremos cumplir antes de cada Sprint Review, donde en este punto se revisa todos los progresos que se han hecho. Estos son los pasos que hemos seguido para cada Sprint: 1. Definir las tareas y objetivos. • Realizamos una reunión donde abordamos todas las tareas necesarias para cumplir varios objetivos. Una vez terminada la lista de objetivos, realizamos una reunión con el profesor para validar y asegurarnos de que los objetivos sean adecuados. 2. Weekly Scrum. • Cada semana, realizamos una reunión donde revisamos los progresos realizados a lo largo del Sprint, ajustando las tareas según las necesidades del momento. 3. Sprint Review. 18 • Al finalizar el Sprint (aproximadamente cada 3 semanas), revisamos el trabajo completado para evaluar el progreso y determinar qué caminos seguir y qué cosas mejorar. En relación con el apartado anterior1.2], cada objetivo ha sido planificado por sprint, siguiendo el siguiente cronograma: • Sprint 1: - Objetivo: Definir y planificar el proyecto. • Sprint 2: - Objetivo: Buscar información y datos relevantes para el estudio. • Sprint 3: - Objetivo: Analizar cómo procesar los datos obtenidos para su posterior uso con Machine Learning. • Sprint 4: - Objetivo: Analizar la adquisición de dispositivos para la recopilación de datos de los deportistas • Sprint 5: - Objetivo: Estudiar el uso de la API de Fitbit para recopilar datos mediante dispositivos wearables, utilizando librerías de Python. • Sprint 6: - Objetivo: Analizar los diferentes modelos de predicción con los datos obtenidos. Obtener los mejores modelos en cuanto a resultado de predicción se refiere. • Sprint 7: - Objetivo: Crear una aplicación de escritorio para el procesamiento y visualización de datos para los usuarios, permitiéndoles mejorar su rendimiento deportivo. 19 20 Capítulo 2 - Estado de la cuestión En este capítulo daremos paso a definir y aclarar algunos conceptos que iremos exponiendo a lo largo del trabajo. Hablaremos sobre los datos obtenidos y sus distintos tipos. También hablaremos sobre los diferentes modelos de aprendizaje que se han ido utilizando a lo largo de la investigación para su posterior evaluación y para saber el nivel de fiabilidad de estos. 2.1 Diferentes tipos de datos En primer lugar, hablaremos sobre los diferentes datos con los que trabajaremos en este proyecto. Inicialmente, trabajamos con datos obtenidos de una base de datos pública en Kaggle ofrecido por un usuario con licencia pública. Kaggle es una plataforma en línea cuya principal función es facilitar el acceso a diversos conjuntos de datos públicos a personas con conocimientos en ciencia de datos, para poder consultar y experimentar con los distintos datos que ofrece. Además de esta función hay diferentes cursos para aprender y otras actividades educativas. Además, ofrece recursos para el análisis de datos y el desarrollo de modelos, convirtiéndose en un espacio donde los usuarios pueden compartir conocimientos y resolver problemas en el campo de la ciencia de datos. Figura 2-1: Logotipo de Kaggle. Fuente: (Databuff, 2011) 21 La base de datos, proveniente de Kaggle, que utilizamos inicialmente, contenía información anónima de varios usuarios recopilada por dispositivos Fitbit 1 . Estos datos son recopilados en diferentes CSVs. CSV es un formato de archivo el cual es utilizado para guardar datos de forma tabular, donde cada línea del archivo corresponde a un registro (o fila) y cada campo dentro de un registro está separado por una coma (u otro delimitador como punto y coma o tabulación). En nuestro caso, los datos del CSV estaban separados por comas. Figura 2-2: Ejemplo de un archivo CSV donde cada fila contiene datos estructurados según los encabezados definidos en la primera línea. Mediante su API, Fitbit recoge diversos datos del usuario, como por ejemplo las pulsaciones por segundo o las calorías quemadas por minuto. Los datos se han unificado en archivos CSV separados, donde cada uno contiene un tipo específico de información recogida por la API. En cada CSV se recopila la información de todos los usuarios que han registrado ese tipo de dato. Posteriormente estos datos se han utilizado para poder estudiarlos y trabajar con los distintos modelos que se utilizarán en el aprendizaje automático. 1 https://www.fitbit.com/global/es/home 22 Tras la adquisición de la pulsera de Fitbit, en concreto el modelo Fitbit Inspire 3, pudimos recopilar nuestros datos personales gracias a la API. Una API facilita la comunicación entre aplicaciones mediante un tipo de mensajería que es enviado/recibido por los distintos sistemas. En nuestro caso lo utilizamos para poder conectarnos a los servidores de Fitbit, donde contienen los datos de los usuarios recopilados por la pulsera. El flujo de obtención de datos viene de la siguiente forma: Figura 2-3: Esquema donde se muestra el flujo desde la recopilación de datos de la pulsera hasta la aplicación HeartPred’it. Como podemos observar en la Figura 2-3, se puede ver cómo se obtiene los datos mediante la API. El primer paso para obtener los datos de la pulsera es sincronizar la pulsera con la aplicación de Fitbit, el cual significa que los servidores guardan toda la información recopilada de la pulsera en ellos. Una vez sincronizados los datos, se pueden obtener mediante solicitudes URL. Con cada solicitud que se hace al servidor, este nos devuelve una respuesta con los datos solicitados en la URL, estos datos vienen en formato JSON. 23 Figura 2-4: Ejemplo de la respuesta en formato JSON a una solicitud de datos de frecuencia cardíaca. Tras esto, una vez recopilado los datos estudiamos qué datos podríamos obtener para su posterior transformación a un tipo de datos en donde los modelos de aprendizaje automático puedan entenderlo. Esta transformación de datos se detallará en el capítulo 3. 2.2 Modelos de ML utilizados En este apartado describiremos los diferentes tipos de modelos de predicción que hemos ido utilizando a lo largo del trabajo. De entre todos ellos, hemos elegido los mejores según las necesidades que hemos detectado a lo largo del proyecto. 24 Un modelo de predicción es una herramienta computacional que se utiliza para prever resultados futuros basados en datos históricos o actuales (en nuestro caso los datos recopilados por los usuarios, como las calorías, las distancias, etc.). Estos modelos analizan patrones y relaciones dentro de los datos para hacer estimaciones o pronósticos sobre eventos o comportamientos futuros. Para poder simplificar los datos y tener una mejor comprensión de estos, se ha organizado de tal manera que los datos se encuentren en un solo fichero. Por lo tanto, antes del preprocesamiento, seleccionamos y transformamos los datos más relevantes, unificando la información en un único archivo CSV que permite ejecutar el algoritmo de predicción más fácilmente. Este proceso implicó la combinación de varios CSV, alineando los datos por tiempo para asegurar que cada fila correspondiera al mismo punto temporal. Este paso se realizó utilizando la librería pandas. Pandas es una librería de Python que es utilizada ampliamente en el análisis de datos. Proporciona estructuras de datos rápidas, flexibles y expresivas, principalmente en forma de DataFrames, que son tablas similares a las hojas de cálculo. Con esta librería se puede realizar operaciones como la manipulación, limpieza, transformación y análisis de grandes conjuntos de datos, como es nuestro caso, de manera eficiente. Pandas facilita la lectura y escritura de datos desde y hacia formatos como: CSV, Excel, SQL, etc. También ofrece herramientas para el manejo de datos faltantes, filtrado, agrupación y agregación, lo que la convierte en una herramienta esencial en la ciencia de datos en Python. Detallaremos más los usos de esta librería en el capítulo 3. Figura 2-5: Logotipo de pandas. Fuente: (Garcia, 2019) Para que los modelos de machine learning funcionen correctamente, es necesario transformar los datos en un formato que los modelos puedan interpretar y procesar de manera 31 2.2.1.6 Decision Tree Regressor: Regresor de Árbol de Decisión. El Decision Tree Regressor es un modelo de predicción basado en la construcción de un árbol de decisiones, donde cada nodo interno representa una decisión sobre una característica específica de los datos, y cada hoja representa una predicción de valor continuo. El modelo se construye mediante un proceso recursivo de partición de los datos de entrenamiento. En cada nodo del árbol, se selecciona la característica y el punto de corte que minimiza una métrica de error, como la suma de los errores cuadráticos (Mean Squared Error, MSE). Este criterio de partición busca reducir la variabilidad dentro de los subconjuntos resultantes, asegurando que cada división produzca grupos lo más homogéneos posible en términos de la variable objetivo. Una de las ventajas del árbol de decisión es que es un modelo relativamente simple y fácil de interpretar. Pero su principal defecto es que es propenso al sobreajuste (overfitting), especialmente cuando se permite que el árbol crezca sin restricciones e intenta modelar un problema que no es linealmente separable. En este contexto, el algoritmo intentará trocear las clases sobre-ajustando con mulitiples hiperplanos. Para mitigar este problema, se pueden aplicar técnicas como la poda (pruning), establecer una profundidad máxima del árbol (que evita el proceso descrito anteriormente), o limitar el número mínimo de muestras requeridas en cada hoja. Figura 2-12: Un ejemplo de un esquema representativo de un árbol de decisión de regresión. Fuente: (Hui & Ming, 2023) 32 En la Figura 2-12, podemos observar cómo el modelo toma decisiones secuenciales para minimizar el error en las predicciones. 2.2.1.7 Support Vector Machine Regressor (SVR). El Support Vector Machine Regressor (SVR) es un tipo de modelo de predicción que se basa en las máquinas de vectores de soporte (SVM) para realizar tareas de regresión. Este modelo se basa en el concepto de márgenes y vectores para hacer predicciones, funciona encontrando una función que mapea los datos de entrada a un espacio de características de mayor dimensión y luego determina un margen o “tubo” dentro del cual se espera que la mayoría de los datos de entrenamiento caigan. El margen se define en torno a la función objetivo. El objetivo del modelo es encontrar el margen más ancho posible que pueda contener la mayor cantidad de puntos de datos, minimizando al mismo tiempo el error de predicción para los puntos que quedan fuera de este margen. Figura 2-13: Un ejemplo de un esquema representativo de un SVR. Fuente: (Maulana Achsan, 2019) 33 2.2.1.8 Random Forest Regressor. El Random Forest Regressor es un modelo de predicción que utiliza múltiples árboles de decisión para mejorar la precisión y estabilidad de las predicciones. A diferencia de un solo árbol de decisión, que puede sobreajustar los datos, este modelo construye varios árboles usando diferentes subconjuntos del conjunto de datos original. Luego, promedia las predicciones de todos los árboles para obtener el resultado final. Además, selecciona aleatoriamente un subconjunto de características en cada división del árbol, lo que reduce la correlación entre los árboles y mejora el rendimiento del modelo. Figura 2-14: Esquema representativo del modelo predictivo de Random Forest Regressor. Fuente: (Rubino, 2023) 2.2.1.9 Regresión Linear. Para comparar los modelos y evaluar si la regresión lineal es adecuada para predecir los valores, utilizamos la regresión lineal como un modelo baseline. Es un modelo sencillo para comprobar si los modelos de machine learning ofrecen una mejora significativa en comparación con un enfoque más simple. La regresión lineal busca establecer una relación directa entre una variable dependiente (la que queremos predecir) y una o más variables independientes (las que usamos para hacer la predicción). El objetivo es ajustar una línea para minimizar la suma de las diferencias al cuadrado entre los valores observados y los predichos, proporcionando así una estimación de cómo cambian los valores de 𝑦 en función de 𝑥. 34 Figura 2-15: Un ejemplo de un esquema representativo de una regresión linear. Fuente: (Pimpale, 2023) 2.2.2 Modelos de predicción con datos reales. Una vez hecho los estudios con los datos de los usuarios de Kaggle, nos pusimos a quedarnos con los mejores modelos. Y esos fueron: • LGBM Regressor (Light Gradient Boosting Machine). Utilizado para tareas de regresión, es decir, para predecir valores continuos como es nuestro caso. Utiliza una técnica que combina múltiples árboles de decisión, donde cada árbol se construye sobre los errores del árbol anterior, así optimizando la predicción. Figura 2-16: Esquema de cómo se construye el árbol en LightGBM. Fuente: (Rezazadeh, 2020) 35 A diferencia de otros algoritmos de boosting que construyen árboles nivel por nivel (desde la raíz hasta las hojas), LightGBM crece los árboles en función de las hojas, lo que resulta en una reducción de pérdida más rápida. • XGBoost Regressor. También utilizado para tareas de regresión. XGBoost es una implementación optimizada de Gradient Boosting, que utiliza técnicas avanzadas como la regularización L1 y L2 para mejorar el rendimiento y prevenir el sobreajuste. Su enfoque se basa en la construcción de múltiples árboles de decisión donde cada árbol corrige los errores del anterior, de manera eficiente y rápida. Figura 2-17: Esquema de cómo se construye el árbol en XGBoost. Fuente: (Rezazadeh, 2020) A diferencia de otros algoritmos de boosting, XGBoost es conocido por su capacidad de manejar datos faltantes, su escalabilidad y su velocidad, logrando una predicción precisa con un uso optimizado de los recursos. • KNN Regressor. • Random Forest Regressor. • MLP Regressor. 2.3 Elementos de trabajo En este apartado, detallaremos todas las herramientas utilizadas a lo largo del proyecto, desde el uso inicial de Jupyter Notebook para realizar pruebas de futuras implementaciones, hasta la integración final del lenguaje Python en la aplicación. 2.3.1 Lenguaje de programación. Python es un lenguaje de programación de alto nivel, interpretado y de propósito general, que se ha convertido en una de las herramientas más populares para el desarrollo de aplicaciones 36 en diversas áreas, incluidas la ciencia de datos, el desarrollo web y, especialmente, el machine learning (aprendizaje automático). Figura 2-18: Logotipo de Python. Fuente: (Foundation, 2008) Para este proyecto hemos decido usar el lenguaje de programación Python por diversas razones: • Simplicidad y legibilidad. Sintaxis de Python es sencilla y clara, nos permite concentrarnos a resolver problemas en lugar de lidiar con la complejidad del lenguaje. • Bibliotecas y frameworks robustos Python tiene una gran colección de bibliotecas y frameworks específicos para machine learning que facilitan la construcción, entrenamiento y despliegue de modelos. Algunas de la que utilizamos son: • Scikit-learn: Ofrece herramientas simples y eficientes para análisis de datos y modelado predictivo. • Pandas y NumPy: Para la manipulación de datos y cálculos numéricos. • Matplotlib y Seaborn: Para la visualización de datos. • Tkinter: Para la representación de interfaz al usuario. • Amplia comunidad de usuarios Tiene una de las comunidades más grandes y activas en el mundo de la programación, esto hace que haya una gran cantidad de recursos disponibles, como tutoriales, documentación, foros y bibliotecas de código abierto. • Soporte para experimentación rápida 37 Gracias a su naturaleza interpretada y a herramientas como Jupyter Notebook, Python nos permite realizar pruebas y experimentos rápidos. Esto es crucial en machine learning, donde iterar sobre modelos y ajustar hiperparámetro requiere agilidad. 2.3.2 Entorno de desarrollo. Este proyecto lo hemos enfocado a desarrollarlo en un entorno de escritorio, más específicamente en el entorno de Windows. Para poder desarrollar la aplicación y hacer los respectivos estudios hemos utilizado Visual Studio Code. Figura 2-19: Logotipo de Visual Studio Code. Fuente: (Microsoft, Visual Studio Code, s.f.) Visual Studio Code (VS Code) es un editor de código fuente gratuito y de código abierto desarrollado por Microsoft. Se ha convertido en una de las herramientas más populares entre desarrolladores debido a su flexibilidad, rendimiento y características avanzadas. Soporta una amplia gama de lenguajes de programación. Aunque es un editor de texto, ofrece muchas características de un entorno de desarrollo integrado (IDE), lo que lo convierte en una poderosa herramienta para el desarrollo de software. Una de las extensiones que más hemos utilizado durante el desarrollo y las pruebas es la integración con Jupyter Notebook. Esta extensión nos ha facilitado la ejecución de modelos de predicción, ya que permite lanzar fragmentos de código de manera interactiva y obtener resultados de forma progresiva. Esto ha sido especialmente útil para probar y ajustar modelos de manera ágil y eficiente. 38 2.3.3 Control de versiones. Para hacer un seguimiento de los avances del proyecto y el control de versiones, hemos utilizado GitHub. GitHub es una plataforma de desarrollo colaborativo basada en la web que utiliza el sistema de control de versiones Git. Permite a los desarrolladores almacenar, gestionar y compartir código de manera eficiente. En GitHub, puedes crear repositorios, que son espacios donde se guarda el código, y trabajar en proyectos de forma colaborativa con otros desarrolladores mediante la creación de ramas (branches), revisiones de código (pull requests) y seguimiento de issues. Además, implementamos un seguimiento del proyecto mediante el uso de backlogs, donde registrábamos defectos, tareas pendientes por completar y las prioridades de estas. Esto nos permitió gestionar el flujo de trabajo de manera organizada y transparente. En VS Code, teníamos implementada la extensión de GitHub, lo que nos facilitó la integración con la plataforma. Desde el propio editor, podíamos realizar commits, crear y fusionar ramas, y resolver conflictos de código, todo sin necesidad de cambiar de entorno. Esta integración nos ayudó a mantener un flujo de trabajo ágil y a controlar las versiones de manera eficiente, optimizando la colaboración entre los miembros del equipo. Figura 2-20: Logotipo de Github. Fuente: (GitHub, s.f.) Todo el trabajo realizado se ha subido en el repositorio TFG-Analisis-fitbit 2 , donde se puede observar todos los cambios que se han ido realizando a lo largo del desarrollo. 2.4 Trabajos relacionados Una vez explicado todas las tecnologías involucradas en el desarrollo de este trabajo, haremos un repaso por otros trabajos relacionados relevantes. Cabe destacar que en esta sección solo citaremos algunos de los múltiples trabajos similares que hemos encontrado. 2 https://github.com/JuanBaroffi/TFG-Analisis-fitbit 39 • A Predictive Analysis of Heart Rates Using Machine Learning Techniques (Oyeleye, Chen, Titarenko, & Antoniou, 2022): Este estudio investiga el uso de técnicas de ML para predecir la frecuencia cardíaca a partir de datos generados por dispositivos de monitoreo portátiles, como los acelerómetros. El objetivo principal es, mejorar la detección temprana de anomalías en la frecuencia cardíaca. Aunque el objetivo sea distinto al nuestro, existen en común varios modelos usados, entre ellos destacamos: Linear Regressor, Support Vector Regressor (SVR), KNN, Decision Tree Regressor, Random Forest Regressor y LSTM. Una diferencia se encuentra en la forma que evaluamos el rendimiento de los modelos, en este trabajo se utilizan dos métricas; RMSE 3 y SI 4 (Índice de dispersión) En cambio, nuestro trabajo utiliza la métrica R2 score, un valor alto de esta métrica indica que el modelo explica bien la variabilidad de los datos. En conclusión, los modelos que resultaron más efectivos fueron los siguientes: modelo ARIMA y la regresión lineal, mientras que los otros modelos tienen limitaciones en duraciones más cortas o específicas. • Heart Rate Modeling and Prediction Using Autoregressive Models and Deep Learning (Staffini, Svensson, Chung, & Svensson, 2022) 3 El RMSE (Root Mean Squared Error) es una métrica en machine learning que mide la diferencia entre los valores reales y los valores predichos por un modelo. Se calcula como la raíz cuadrada del promedio de los errores cuadrados. El RMSE es útil porque penaliza más los grandes errores, dándonos una idea de cuán precisas son las predicciones del modelo. Cuanto más bajo sea el RMSE, mejor es el rendimiento del modelo en términos de predicción. (Willmott & Matsuura, 2006) 4 El Índice de Dispersión (SI) es una métrica que mide la dispersión de los errores de un modelo de predicción en relación con los valores observados. Es una relación entre la desviación estándar de los errores y la media de los valores reales. Un valor de SI cercano a 0 indica que el modelo tiene una buena precisión, mientras que un valor mayor indica mayor dispersión y, por lo tanto, menor exactitud. (Simpson & Huang, 2002) 40 Este estudio tiene como objetivo investigar la predicción de la frecuencia cardíaca, similar a nuestro proyecto. Utilizan tres modelos: Autoregressive Process, Convolutional Long ShortTerm Memory Network (ConvLSTM) y Long Short-Term Memory Network (LSTM), este último también empleado en nuestro trabajo. Además, al igual que nosotros, emplean la técnica de forecaster para predecir valores continuos y usan el error MSE para evaluar la precisión de los modelos. En conclusión, este estudio está orientado a la detección de anomalías, mientras que nuestro enfoque está más relacionado con el análisis deportivo y accesible a un público más general. Además de utilizar más modelos para obtener mejores resultados en cuanto a la predicción de valores. • Heart rate modeling and prediction of construction workers based on physical activity using deep learning (Ghafoori, Clevenger, Abdallah, & Rens, 2023): El objetivo de este trabajo es analizar cómo la tasa de respiración, la postura de torso y otras señales fisiológicas afectan a la frecuencia cardíaca de los trabajadores de construcción. Para ello, se utilizan modelos de aprendizaje profundo para predecir la frecuencia cardíaca por minutos, incluyendo: CNN 5 , LSTM 6 , CNN-LSTM, BiLSTM 7 , GRU 8 , CNN-GRU y BiGRU 9 . En conclusión, el trabajo destaca la necesidad de integrar modelos predictivos de frecuencia cardíaca en entorno de la construcción para gestionar la carga física y prevenir incidentes de salud. Como hemos podido observar, en la mayoría de los anteriores trabajos, encontramos que se usa los modelos LSTM y los CNN y modelos de regresión por votación como Random Forest 5 https://www.analyticsvidhya.com/convolutional-neural-networks-cnn/ 6 (Hochreiter & Süchmidhuber, 1997) 7 https://paperswithcode.com/method/bilstm 8 https://aprendizajeprofundo.github.io/LibroFundamentos/Redes_Recurrentes/Cuadernos/rnr_GRU_Intro.html 9 https://paperswithcode.com/method/bigru 47 Como se puede observar en la Tabla 1, existen muchos tipos de datos que varían entre sí. Para realizar un primer análisis, necesitábamos filtrar los datos más relevantes de todas las tablas y consolidarlos en un solo archivo CSV. 3.1.2 Estudio de las variables de los CSV de Kaggle Inicialmente, consideramos que predecir las pulsaciones por minuto sería una buena idea, ya que es un factor crucial para los deportistas y una variable clave para mejorar el rendimiento deportivo. Por ello, comenzamos a calcular y analizar esta variable. En la primera fase de nuestra investigación para mejorar los modelos de machine learning, sabemos que cuanta más información tengamos, mejor será la predicción. Por ello, analizamos todos los datos disponibles y seleccionamos los más relevantes. Un aspecto fundamental fue asegurarnos de que las variables abarcasen el mayor intervalo de tiempo posible, para que pudieran sincronizarse con las demás. Consideramos dos factores clave: la importancia del dato y su disponibilidad a lo largo del tiempo. Es importante que todos los datos estén alineados en el mismo intervalo de tiempo para garantizar la coherencia y efectividad de los modelos. Decidimos que trabajar con intervalos de un minuto sería adecuado para analizar y predecir los resultados de manera precisa. Tras varias investigaciones, nos centramos en las pulsaciones, la intensidad y las calorías por minuto. También incluimos el identificador del usuario y el tiempo, unificando todos los datos por minuto. Esto asegura que la información esté en el mismo intervalo de tiempo, garantizando su coherencia y completitud. Todo esto gracias a la conversión que se detallará en el apartado 3.2.1. 48 Figura 3-1: Ejemplo del CSV donde se han unificado los diferentes datos en uno: test_train_data.csv. Se ha analizado la inclusión de diversas variables en el CSV, como por ejemplo el registro del peso de la persona (variable WeightKg de la base de datos de weightLogInfo_merged.csv) o la medición de la calidad de sueño (variable Value de minuteSleep_merged.csv) de la Tabla 1. Sin embargo, nos encontramos con algunos inconvenientes al intentar incluir ciertas variables, ya que los datos disponibles no eran suficientes. Para hacer una predicción precisa, es necesario que la variable esté presente de manera constante a lo largo de un intervalo de tiempo amplio, y no en intervalos de tiempo muy dispares. En comparación con los otros valores continuos, por ejemplo, de las pulsaciones (Valor Value en heartrate_seconds_merged.csv), estos valores están registrados de manera constante, registrándolos todo el día. También consideramos que, en el futuro, no solo se predecirán las pulsaciones por minuto, sino también otras variables. Por lo tanto, al no ser datos registrados de forma constante, no serían tan modulables como quisiéramos. Figura 3-2. Ejemplo de weightLogInfo_merged.csv. Se puede observar que la obtención de datos no es constante. Observar la columna “Date” de color verde amarillento y la columna “Id” color gris claro. 49 3.2 Manipulación de datos y primeros modelos predictivos 3.2.1 Unificación de datos para los modelos de ML En este apartado se detallarán los pasos seguidos para unificar todos los datos necesarios en un único archivo CSV. Todo este proceso se realizó utilizando la librería pandas. El proceso completo se encuentra documentado en el notebook titulado Preparacion Datos.ipynb. • Primero para poder manipular los datos es necesario pasar los CSV a una variable mediante la función read_csv. Figura 3-3: Ejemplo de asignación del heartrate_seconds_merged.csv a un DataFrame llamado data_heartrate_seconds. • Se comprueba de que no haya ningún dato faltante en la base de datos del CSV. En caso de que haya, se rellena los valores faltantes con la moda previamente calculada. Figura 3-4: Ejemplo de código para sustituir valores faltantes con la moda calculada y verificación de la eliminación de valores atípicos. 50 • Se ajustan los tiempos para que todos los registros estén alineados en intervalos de minutos. Para lograr esto, se toma la columna de tiempo y se agrupan los datos en intervalos de 1 minuto. Por ejemplo, para agrupar el archivo heartrate_seconds_merged.csv, que tiene registros cada 5 segundos, se calcula la media agrupándolas en intervalos de 1 minuto. Posteriormente se guarda en el mismo CSV. Figura 3-5: Código para agrupar registros de tiempo en intervalos de 1 minuto y exportarlos a un archivo CSV • Para los CSV: data_intensities_minutes.csv y minuteCaloriesNarrow_merged.csv no ha hecho falta debido a que ya están reagrupados por minutos. • Una vez ajustados, se reagrupan todos los datos en un mismo DataFrame para luego guardarlo en un archivo CSV, donde coincidan el tiempo y el ID. Esto se realiza mediante la función merge de pandas. Es necesario preparar la columna time de los CSV para que pandas pueda interpretarla correctamente y así lograr la coincidencia de los datos. Figura 3-6: Ejemplo de código para combinar el archivo data_intensities_minutes.csv con merged_df (el DataFrame resultante de la unión de todos los CSVs) utilizando la función merge de pandas. 51 Una vez finalizada la unión de los datos más importantes en un único archivo CSV llamado test_train_data.csv para facilitar el entrenamiento de los modelos (véase la Figura 3-1), procedemos al análisis de los mejores modelos de regresión para realizar predicciones futuras con este conjunto de datos. 3.2.2 Análisis de los modelos predictivos de ML En este apartado se presentan los resultados obtenidos con los diferentes modelos que hemos utilizado, está todo documentado en el notebook Modelos de Prediccion.ipynb 12 . En la mayoría de los casos, empleamos la técnica de cross-validation para evaluar la capacidad predictiva de los modelos y garantizar que estos generalicen bien a nuevos datos, evitando así el sobreajuste al conjunto de entrenamiento (Hastie, Tibshirani, & Friedman, 2009). Además, se definió para cada modelo, un conjunto de hiperparámetros para optimizarlos, lo que permitió identificar cada modelo con el mejor rendimiento en términos de predicción utilizando los mejores hiperparámetros. Estos hiperparámetros fueron encontrados previamente mediante GridSearch de la librería sklearn, la cual se encarga de buscar los hiperparámetros que maximicen el rendimiento del modelo. 12 https://github.com/JuanBaroffi/TFG-Analisisfitbit/blob/fd2bf97166870bae6af1f449e7a4cbedb3ccd593/notebooks/Modelos%20de%20Prediccion.ipynb 52 3.2.2.1 Preprocesamiento de los datos Figura 3-7: Preprocesamiento de los datos Para la preparación de los datos para los modelos de machine learning, es fundamental realizar un preprocesamiento adecuado. En este caso, comenzamos transformando la columna de tiempo en el DataFrame result_df para extraer características útiles. Convirtiendo la columna Time a un formato de fecha y hora (pd.to_datetime(result_df['Time'])), podemos extraer atributos como la hora del día, los minutos y el día de la semana. Estos atributos se añaden como nuevas columnas: Hour, Minutes, y Weekday. Luego, seleccionamos las características relevantes (features) para la modelización y la variable objetivo (target). Las características seleccionadas incluyen identificadores, atributos de tiempo, y métricas como la intensidad y las calorías. Dividimos los datos en conjuntos de entrenamiento y prueba utilizando train_test_split, reservando un 17% de los datos para la prueba. 53 El preprocesamiento de datos es importante para asegurar que los modelos de machine learning funcionen de manera efectiva. En nuestro caso, utilizamos un ColumnTransformer para aplicar diferentes transformaciones a las características categóricas y numéricas: • Características numéricas: Para las características numéricas (Hour, Minutes, Intensity, Calories), aplicamos una escalación estándar usando StandardScaler. Esta transformación estandariza los datos para que tengan una media de 0 y una desviación estándar de 1, facilitando el aprendizaje del modelo. • Características categóricas: La columna Id se considera categórica y se transforma usando OneHotEncoder. Esta técnica convierte las categorías en variables binarias (dummies) que el modelo puede procesar. El ColumnTransformer combina estas transformaciones, asegurando que las características numéricas sean escaladas y las categóricas sean codificadas de manera adecuada. El parámetro remainder = 'passthrough' asegura que las columnas no especificadas en las transformaciones sean incluidas sin cambios en el conjunto de datos preprocesado. 54 3.2.2.2 Resultados de los modelos de ML Hablaremos sobre los distintos resultados que nos han dado los diferentes modelos. • Regresión linear: Empezamos con el modelo que utilizamos como baseline, el modelo de regresión lineal. Este modelo sencillo nos da una predicción con un R² score 13 de 0.74151, lo cual significa que tiene un 74.15% de capacidad de explicación de la variabilidad de los datos. Compararemos este resultado con los resultados de los siguientes modelos. Figura 3-8: Código del modelo de regresión linear • XGBoost: En este modelo nos da un resultado de 0.85834 de R² score, es decir, un 85,83% de explicación de la variabilidad de los datos, sin aplicar los mejores hiperparámetros. Al aplicar el mecanismo de GridSearch, cuyos mejores hiperparámetros son tasa de muestreo por árbol (colsample_bytree) =1.0, tasa de aprendizaje (learning_rate) =0.2, profundidad máxima del árbol (max_depth) =7, número de estimadores (n_estimators) =200, y submuestreo (subsample)=1.0, nos da un resultado de 0.86044 (86,04%) de R² score, mejorando un 0,21% 13 R² score es una métrica que indica qué proporción de la variabilidad en la variable dependiente (objetivo) es explicada por el modelo. Su valor va de 0 a 1, donde 1 significa que el modelo explica perfectamente la variabilidad de los datos, y 0 significa que no explica nada. (Hastie, Tibshirani, & Friedman, 2009) 55 respecto a los hiperparámetros por defecto. Figura 3-9: Código del modelo de XGBoost aplicando hiperparámetros • LightGBM: En este modelo con los hiperparámetros por defecto (tasa de aprendizaje (learning_rate) =0.2, número de estimadores (n_estimators) =200 y número de hojas (num_leaves) =40) nos da un resultado R² score de 0.8608 (86.08%) y mejor resultado que con los hiperparámetros testeados y obtenidos de GridSearch, con un resultado R² score de 0.85557 (85,56%), ósea un -0.52% menos. • LSTM: El rendimiento de este modelo ha sido uno de los más bajos, con un R² score de de 0.59253 (59,25%). Se ha descartado este modelo por dos motivos principalmente, por obtener un R² inferior a modelo baseline(Regresor Lineal R² = 0.74151) y, por ser significativamente más lento en comparación con otros modelos evaluados. • MLP: El Multi-Layer Perceptron Regressor obtuvo una puntación de R² score de 0.849799 (84.98%) con los hiperparámetros por defecto. • KNN: Este modelo tuvo una puntuación de R² score de 0.826173 (82,62%) con hiperparámetros inicializado con (número de vecinos (n_neighbors) =5). 56 Figura 3-10: Código del modelo de KNN, donde se aplica Cross Validation • Decision Tree: Este modelo tuvo una puntuación de R² score de 0.7714 (77,14%), muy parecido en cuanto a rendimiento R² score al modelo baseline(Regresor Lineal R² = 0.74151). • SVM: El modelo SVM nos ha dado un R² score de -621.664 14 en el conjunto de prueba, lo que indica que el modelo tiene un rendimiento extremadamente pobre y es incapaz de predecir correctamente los valores objetivos. Además de su bajo rendimiento, este modelo fue descartado al igual que el modelo LSTM porque su procesamiento es significativamente más lento en comparación con otros modelos evaluados. • Random Forest: Este modelo tuvo una puntuación de R² score de 0.83924 (83,92%) con hiperparámetros inicializados (número de estimadores (n_estimators) =100). • Voting Regressor: Además de los modelos individuales, se implementó un modelo combinado utilizando un Voting Regressor, el cual combina las predicciones de tres algoritmos distintos: XGBoost, LightGBM y Random Forest. Para XGBoost y LightGBM, se utilizaron los mejores hiperparámetros obtenidos previamente (tasa de aprendizaje (learning_rate) =0.2, número de estimadores (n_estimators) =200, número de hojas (num_leaves) =31, máxima profundidad (max_depth) =6, fracción de 14 Un R² score negativo sugiere que las predicciones del modelo son incluso peores que simplemente usar la media de los valores observados como predicción. 63 Figura 3-13: Obtención de los datos del Heart Rate en un intervalo de tiempo con una frecuencia de tiempo dada • HRV - Heart Rate Variability (variabilidad de la frecuencia cardíaca) 64 Figura 3-14: Obtención de los datos del HRV en un intervalo de tiempo con una frecuencia de tiempo dada • SPO2 - Saturation Pulse Oxygen (saturación de oxígeno en la sangre) 65 Figura 3-15: Obtención de los datos del SPO2 en un intervalo de tiempo con una frecuencia de tiempo dada • Calories, Distance and Steps (Calorías, Distancia y Pasos) 66 Figura 3-16: Ejemplo de código donde se recopila los datos de calories, distance y steps y se guardan en un csv independiente Los diferentes datos recopilados mediante la API se han guardado en distintos archivos CSV. Una vez obtenida la respuesta a través de peticiones URL y recibidos los datos en formato JSON, estos se almacenan según el tipo de dato solicitado y el mes en que se recogieron. Por ejemplo, los datos de la frecuencia cardíaca del mes de febrero se guardan en un archivo llamado heart_rate_data_2.csv. 67 Figura 3-17: Ejemplo de CSV para heart_rate_data_2.csv, donde se ha recogido los datos mediante la API Resumen en una tabla de los datos más relevante que hemos obtenido: Tipo de dato Intervalo de tiempo de medición Heart Rate Durante todo el día Heart Rate Variability Durante el sueño Saturation Pulse Oxygen Durante el sueño Calories Durante todo el día Distance Durante todo el día Steps Durante todo el día Tabla 3: Resumen de los datos obtenidos mediante la API Si nos fijamos en la tabla, podemos observar que la mayoría de los datos se miden constantemente a lo largo del día. Sin embargo, algunos como la variabilidad de la frecuencia cardíaca (Heart Rate Variability) y la saturación de oxígeno en la sangre (Saturation Pulse Oxygen) solo se miden durante el sueño del usuario, es decir, se recopilan únicamente cuando la pulsera detecta que el usuario entra en una fase de sueño. Por lo tanto, para entrenar los modelos de aprendizaje automático (ML), utilizaremos los datos de Heart Rate, Calories, Distance y Steps, ya que son datos constantes que se registran durante todo el día, lo que los hace más adecuados para predecir en el futuro. 68 En comparación con los datos de Kaggle, véase la Figura 3-1, en este caso se ha escogido más variables para añadir a los modelos (Heart Rate, Calories, Distance y Steps, no se ha podido obtener la intensidad debido a que no se podía obtener esos datos mediante la API debido a un error interno del servidor de Fitbit). Esto puede proporcionar más información para analizar y buscar una correlación más precisa para las predicciones. Sin embargo, es importante tener en cuenta que más parámetros no siempre garantizan un mejor rendimiento; una selección cuidadosa de las variables es esencial para evitar problemas como el sobreajuste y asegurar que el modelo generalice bien en datos nuevos. 3.3.5 Unificación de los datos Una vez establecidas las variables que se van a utilizar para entrenar los modelos, primero realizamos una unificación de todos los datos en un solo archivo CSV, en el que todos los parámetros estén en la misma fila y con el mismo intervalo de tiempo. Esta unificación se ha llevado a cabo en el notebook Merge API Database.ipynb. Dado que los datos están separados en diferentes archivos CSV según el tipo de dato, como se muestra en la Figura 3-17, el objetivo es unificarlos en un único CSV, de manera que todos los datos estén contenidos en una misma fila para un mismo intervalo de tiempo. Figura 3-18: Ejemplo de combinación de los datos tipo distance en distance_merged.csv 69 Al realizar el mismo paso con todas las variables que utilizaremos: Heart Rate, Calories, Distance y Steps, nos quedamos con un único CSV el cual se utilizará para tener una mejor comprensión de los datos que entrenaremos en el CSV llamado test_train_data_api_merged.csv. Los pasos de unificación son muy similares al del apartado 3.2.1. Figura 3-19: Ejemplo de datos generados en test_train_data_api_merged.csv. 3.4 Análisis de los modelos predictivos de ML con datos extraídos con la API Al unificar todos los datos mediante la API en un mismo CSV, para facilitar la compresión de esta, se ha dado paso a estudiar y analizar los modelos de ML que hemos ido utilizando a lo largo del proyecto con este nuevo conjunto de datos. Al haber hecho los análisis de los diferentes modelos de ML, nos hemos quedado con los más destacables: Light GBM Regressor, XGBoost Regressor, KNN Regressor, Random Forest Regressor y MLP Regressor. Para poder predecir los valores, hemos investigado y encontrado una forma más conveniente de facilitar la creación de modelos de predicción de series temporales. Se trata de ForecasterAutoreg, una clase perteneciente a la librería skforecast. Esta clase implementa un modelo de regresión autorregresivo, donde las características (o features) para la predicción son los valores pasados de la serie temporal que se desea predecir. En un modelo de regresión autorregresivo, se entrena un modelo de regresión (por ejemplo, un modelo lineal o un modelo basado en árboles) utilizando los valores pasados de la 70 serie temporal como variables independientes. El objetivo es predecir el valor futuro de la serie temporal. Por ejemplo, si se quiere predecir el valor en el tiempo t, se podrían usar los valores en los tiempos t−1, t−2, …, t−pt-1, t-2 como predictores, donde p es el número de rezagos (lags) que se utilizan. (Amat Rodrigo & Escobar Ortiz, 2024) Figura 3-20: Diagrama del proceso de predicción multi-step recursivo para predecir 3 steps a futuro utilizando los últimos 4 lags de la serie como predictores. 71 Para configurar el ForecasterAutoreg, primero necesitamos configurar el tiempo de los datos: Figura 3-21: Configuración del tiempo, con una frecuencia de 60 segundos Después, establecemos los valores del lag y del step; por ejemplo, steps=5 y lags=10 para el forecaster. Y, por último, debemos comprobar que no haya ninguna fila faltante. Si las hay, debemos rellenarlas con la última medida (esto puede suceder si, por ejemplo, la batería de la pulsera se agota o se interrumpe la carga, lo que causaría la falta de datos). Es necesario que el Forecaster contenga todos los datos sin que falte ninguno. A continuación, pondremos los resultados de los modelos con una medición de error de MSE con steps = 5: • LightGBM Regressor: Con un error de 4.8980 (4,9%) de error de test MSE. Figura 3-22: Ejemplo de entrenamiento de LGBM Regressor 72 Como se puede observar en Figura 3-22, se utiliza como datos exógenos las columnas Calories, Steps y Distance. • XGBoost Regressor: Con un error de 4.838 (4,84%) de error de test MSE. Figura 3-23: Ejemplo de código de cómo se predice los valores con N steps Figura 3-24: Gráfica comparativa donde se muestra los valores predichos con los datos tests en XGBoost Regressor para un valor de steps = 5 • KNN Regressor: Con un error de 47.447 (47,48%) de error de test MSE. • Random Forest Regressor: Con un error de 7.5239 (7,52%) de error de test MSE. • MLP Regressor: Con un error de 5.51538 (5,51%) de error de test MSE. 79 Figura 3-32: Flujo de los ajustes generales En la Figura 3-32 podemos observar el flujo de todas las características de esta ventana, donde se puede cambiar el usuario, la contraseña, cambiar el propósito, podemos cerrar sesión desde ahí y finalmente eliminar la cuenta. 80 • Predicción de datos Figura 3-33: Flujo de la ventana de predicción En esta ventana, podemos seleccionar el campo/variable que deseamos predecir, en este caso la frecuencia cardíaca (HeartRate). Entre las posibles opciones de campos a predecir, podemos seleccionar: frecuencia cardíaca (HeartRate), calorías (Calories), distancia (Distance) o número de pasos (Steps). Los parámetros calorías, distancia y número de pasos se han utilizado con los mismos modelos de ML que la frecuencia cardíaca, por lo que las predicciones pueden ser menos precisas en comparación con el estudio realizado para la frecuencia cardíaca. Para mejorar las predicciones, se ha propuesto estudiar estas variables en futuros trabajos con el fin de obtener un mejor rendimiento. 81 Para realizar una predicción correcta, debemos seleccionar también el tiempo de predicción (steps) y luego presionar el botón de predecir. Con esto, utilizando los últimos datos sincronizados, podremos visualizar una gráfica que mostrará cómo evolucionará nuestro ritmo cardíaco en función de la selección realizada. Además, recibiremos un mensaje que nos indicará, dependiendo de lo que hayamos seleccionado al registrarnos (por ejemplo, el objetivo de mejora del rendimiento deportivo: quema de grasa, mejora de la salud general, etc.), el pronóstico correspondiente. El pronóstico es realmente simple, se trata de una retroalimentación que, depende de dos entradas: el propósito elegido por el usuario y la media de predicciones realizadas por el modelo de ML. Con todos estos datos, y otros cálculos internos que se detallarán en el apartado 3.5.3, la aplicación es capaz de calcular el rango mínimo y máximo de pulsaciones para cada zona de entrenamiento, asociada a cada propósito distinto ofrecidos por HeartPred’it. Finalmente, si las pulsaciones medias predichas por el modelo ML se encuentra en el rango, el pronóstico será un acierto, mostrando un mensaje de ánimo al usuario por acertar la intensidad y pulsaciones del ejercicio. En caso contrario, el pronóstico será un mensaje alertando al usuario de su fracaso en la intensidad y pulsaciones medias del intervalo de tiempo seleccionado, indicando al usuario el rango de pulsaciones mínimas y máximas calculado asociado a su propósito, así como la cercanía a la zona de propósito deseada. Cabe recalcar que, esta funcionalidad solo está implementada para la predicción de la frecuencia cardíaca. • Visualización y sincronización de datos 82 Figura 3-34: Flujo de sincronización y visualización de datos En la Figura 3-34, podemos observar que, cuando se sincronizan los datos de la pulsera con la aplicación HeartPred’it, aparece un pop-up de carga que nos indica cuándo ha finalizado el proceso. También se puede ver la ventana de visualización, donde es posible observar los datos del usuario en un intervalo de tiempo, el cual es ajustable según las necesidades del usuario. 83 Figura 3-35: Flujo completo de la aplicación 3.5.2 Arquitectura de la aplicación Aquí hablaremos sobre la arquitectura de la aplicación, detallando su diagrama UML, así como sus diagramas de flujo, y explicaremos cómo está compuesta. En este proyecto, hemos seguido una arquitectura Modelo-Vista-Controlador (MVC). Este patrón separa la aplicación en tres componentes principales: • Modelo (verde): Es la parte de la aplicación que maneja la lógica de los modelos predictivos de ML y la lógica de la autentificación de Fitbit. El Modelo se encarga de gestionar la información, acceder a la base de datos (En nuestro caso para acceder a los datos de los usuarios o acceder a los datos de los valores recopilados por el usuario 84 mediante la API), y realizar las operaciones necesarias sobre estos. Es independiente de la interfaz de usuario, lo que permite que los datos puedan ser reutilizados o manipulados sin depender de cómo se presenten. • Vista (azul): Es el componente que gestiona la interfaz de usuario y la presentación de los datos. La Vista toma los datos proporcionados por el Modelo y la muestra de una manera que el usuario final pueda interactuar con ellos. La Vista no contiene lógica de negocio; su única función es mostrar información y recibir la interacción del usuario. • Controlador (rosa): Es el intermediario que conecta el Modelo y la Vista. El Controlador recibe la entrada del usuario a través de la Vista, procesa esa entrada (por ejemplo, validando los datos o invocando operaciones en el Modelo), y luego actualiza la Vista con los resultados. De esta manera, el Controlador actúa como un puente que asegura que la lógica de negocio (Modelo) y la presentación (Vista) permanezcan separadas. Esta separación en capas permite una mayor modularidad y facilita el mantenimiento y la escalabilidad de la aplicación. Cada componente puede ser desarrollado, actualizado, y probado de forma independiente, lo que resulta en una aplicación más robusta y flexible. (Doe, Smith, & Johnson, 2023). 85 Figura 3-36: Diagrama UML de la aplicación 86 Como gestor de base de datos se ha utilizado MongoDB. Con este gestor, hemos podido guardar los datos de los usuarios, así como sus tokens de registro, su última sincronización, entre otros. Para mejorar la seguridad de los datos sensibles como la contraseña de usuario, se ha optado por implementar el algoritmo SHA-256, para posteriormente guardar en MongoDB la contraseña de manera segura. Para verificar la autenticidad del usuario, se almacena además en la MongoDB una “salt” generada automáticamente por el algoritmo SHA-256. Esta “salt” se añade a la contraseña del usuario, y se utiliza en el proceso de verificación para comparar los dos hashes de manera segura (MongoDB, 2023). Figura 3-37: Diagrama UML de la clase Mongo coloreada en verde 87 3.5.3 Lógica de los propósitos A continuación, detallaremos la lógica de los propósitos de la aplicación. 3.5.3.1 Propósitos de HeartPred’it. La aplicación ofrece cinco tipos de propósitos: Mejorar la salud general, quemar grasa, mejorar la resistencia cardiovascular, mejorar la velocidad/potencia y mejorar el máximo rendimiento. Cada propósito, se asocia a una zona específica de frecuencia cardíaca; por ejemplo, la zona de "Mejorar salud general" es la primera zona de frecuencia cardíaca. Véase Tabla 5. Cada zona está definida por un rango de pulsaciones mínimas y máximas. Para que la aplicación pueda calcular con éxito el rango de cada zona, es imprescindible conocer la frecuencia cardíaca en reposo y la frecuencia cardíaca máxima del usuario. La frecuencia en reposo se obtiene a partir de la API de Fitbit, mientras que la frecuencia cardíaca máxima se calcula usando la fórmula de Tanaka (Tanaka, Monahan, & Seals, 2001) 𝑇𝑎𝑛𝑎𝑘𝑎(𝐹𝐶𝑀)=(208 − 0.7 ∗ 𝑒𝑑𝑎𝑑) Ecuación 1: Fórmula de Tanaka La fórmula de Tanaka estima la frecuencia cardíaca máxima (FCM) teórica, restando a la constante 208 el resultado de multiplicar (0.7 * edad). Para calcular el rango de pulsaciones mínimas y máximas de cada posible zona, se ha optado por la fórmula de Karvonen: (Moya, s.f.) % 𝑑𝑒 𝐹𝐶 𝑜𝑏𝑗𝑒𝑡𝑖𝑣𝑜 = ((𝐹𝐶𝑀 22 – 𝐹𝐶𝑅 23 ) × % 𝑑𝑒 𝑖𝑛𝑡𝑒𝑛𝑠𝑖𝑑𝑎𝑑) + 𝐹𝐶𝑅 Ecuación 2: Fórmula de Karvonen 22 Donde FCR es frecuencia cardíaca en reposo. 23 Donde FCM es frecuencia cardíaca máxima. 88 ZONAS DE FRECUENCIA CARDÍACA % DE INTENSIDAD RANGO PULSACIONES (FCR:70, FCM:198) ZONA 0 (Ninguna Zona) (0.00, 0.49] (70,133) ZONA 1 (Mejorar salud general) (0.49, 0.59] (133, 146) ZONA 2 (Quema de grasa) (0.59, 0.69] (146,158) ZONA3 (Mejorar resistencia cardiovascular) (0,69, 0.79] (158, 171) ZONA 4 (Mejorar la velocidad y potencia) (0.79, 0.89] (171, 184) ZONA 5 (Mejorar máximo rendimiento) (0.89, 1.00] (184, 198) ZONA 6 (Ninguna zona, sobreesfuerzo) (1.00, 4.00] (198, 582) Tabla 5: Tabla representativa de porcentaje de intensidad y rango de pulsaciones de cada zona de frecuencia cardiaca de Karvonen, con valores FCR de 70 y FCM de 198. Como se puede observar en la Tabla 5, si el propósito elegido por el usuario es (Mejorar salud general), la media de las pulsaciones predichas por el modelo debe caer entre (133,146) para considerarse como pronóstico acertado. 3.5.3.2 Pronóstico/interpretación de resultados: Mejorar salud general (1) Quema de grasa (2) Mejorar resistencia cardiovascular (3) Mejorar la velocidad y potencia (4) Mejorar máximo rendimiento (5) Zona 0 Zona 1 Zona 2 Zona 3 Zona 4 Zona 5 Zona 6 Tabla 6: Tabla representativa sobre la interpretación de resultados para cada zona. Con todos esto datos calculados internamente, la aplicación realiza un pronóstico. Las zonas verdes indican aciertos en las predicciones, es decir, ocurre cuando el usuario ha elegido la zona X y la media de predicciones realizadas por el modelo ha aterrizado en la zona X. 95 Goals Our main objective in this project is to develop an application that allows athletes to improve their sports performance through the analysis of data collected via a wristband. 1. Define and plan the project. • Specify the proposals and objectives of the final degree project. • Create a plan outlining the project phases and the expected results for each phase. 2. Analyse how to process the data for its subsequent use in Machine Learning. • Research the different types of data that can be obtained using an existing database with information such as heart rate, calories burned, exercise intensity, etc. • Study and work with the dataset obtained from Kaggle, developing different predictive algorithms to find the most suitable model for the data from our own data collection device. 3. Analyse the acquisition of a device for collecting athlete data. • Based on the Kaggle dataset, look for devices capable of collecting similar data. • Find devices that can provide data through an open API. 4. Study the use of the Fitbit API to collect data via wearable devices using Python libraries. • Before acquiring the device, explore how to use the Fitbit API through the available documentation, making simple requests such as obtaining user data. • Acquire a Fitbit device and make initial API requests to obtain real data, such as the athlete's heart rate, calories, etc. 5. Analyse different predictive algorithms with the real data obtained. • Clean the data collected. • Test different predictive models and select those that offer the best results. 6. Create an application for processing and visualizing data for users, allowing them to improve their sports performance. 96 • Develop a desktop application in Python capable of visualizing and predicting the various data collected. Work plan As for the work plan, we followed the Scrum model. This model has an agile approach that is mostly used in software development. We chose this agile method due to our familiarity with it, acquired throughout our degree, and also because it allows us to see results at the end of each Sprint. This helps with incremental deliveries and tracking the project's progress. Figure 0-1: SCRUM process diagram. Before each Sprint, we planned the tasks and goals we wanted to achieve before each Sprint Review, where we review all the progress that has been made. These are the steps we followed for each Sprint: 1. Define tasks and goals. • We hold a meeting where we address all the tasks needed to meet several objectives. Once the list of objectives is completed, we hold a meeting with the professor to validate and ensure that the objectives are appropriate. 2. Weekly Scrum. • Every week, we hold a meeting where we review the progress made throughout the Sprint, adjusting tasks as needed. 97 3. Sprint Review. • At the end of the Sprint (approximately every 3 weeks), we review the completed work to evaluate the progress and determine which paths to follow and what needs improvement. In relation to the previous section, each goal has been planned per sprint, following the timeline below: • Sprint 1: - Goal: Define and plan the project. • Sprint 2: - Goal: Gather relevant information and data for the study. • Sprint 3: Goal: Analyze how to process the collected data for its subsequent use in Machine Learning. • Sprint 4: - Goal: Analyze the acquisition of devices for collecting athlete data. • Sprint 5: - Goal: Study the use of the Fitbit API to collect data through wearable devices, using Python libraries. • Sprint 6: - Goal: Analyze different predictive models using the obtained data. Select the best models based on prediction accuracy. • Sprint 7: - Goal: Create a desktop application for processing and visualizing data for users, allowing them to improve their sports performance. 98 Conclusions and future work Conclusions In summary, the application developed in this final degree project, HeartPred’it, represents a useful solution for athletes seeking to optimize their performance. Through the use of advanced technologies such as Machine Learning, we have created a tool capable of predicting key training metrics (such as heart rate, calories, etc.), providing users with valuable and personalized information. One of the fundamental aspects of implementing this application has been the integration of APIs for data collection, especially through wearable devices such as the activity wristband acquired for this project. These APIs have proven to be extremely useful by enabling real-time, continuous data collection on users, which is crucial for feeding the machine learning models with accurate and up-to-date data. Furthermore, this project has demonstrated that not all machine learning models are the same; each has particular characteristics that affect both the results obtained and the processing times. In particular, the XGBoost and LightGBM models have shown an excellent balance between accuracy, processing speed, and efficiency in predicting continuous data, standing out as highly effective options for regression tasks in the context of improving sports performance by making future predictions. A crucial aspect addressed in this project has been data privacy. All collected data is subject to Fitbit's privacy and data handling policies. Under the use of the HeartPred’it application, all collected data is used exclusively for educational and non-professional purposes, without being shared with third parties. This ensures ethical handling of information within the framework provided by Fitbit, aligning with best practices in data protection. Finally, the development of HeartPred’it not only contributes to the advancement of machine learning applications in sports but also opens the door to future research and improvements in this growing field. The combination of efficient machine learning models, along with a robust infrastructure for data collection, offers a promising path toward the personalization of training and continuous improvement of sports performance. 99 Future Work Based on the development and results obtained in this project, several areas for improvement and expansion have been identified that could be explored in future work: 1. Incorporation of New Machine Learning Models: A key aspect for future development would be the exploration and study of new machine learning models that could further improve the predictive analysis performance of the HeartPred’it application. This includes optimizing the current models through hyperparameter tuning, as well as evaluating other models that have not yet been tested in this project. 2. Study of Permissions and Collaboration with Fitbit: It is essential to advance the formalization of permissions and official documents with Fitbit to authorize the use and collection of data from multiple users. This would allow the expansion of the application’s scope and facilitate its implementation in real environments, ensuring compliance with all data privacy and handling regulations. 3. Compatibility with Devices from Multiple Brands: To increase the versatility of HeartPred’it, it would be valuable to extend the application’s compatibility to include more companies that collect user data, allowing for the easy integration of devices from other manufacturers, such as Withings, Xiaomi. This would depend on the availability of open APIs from these companies, enabling the application to interact with a broader range of devices. 4. Optimization for Real-Time Prediction: An important goal for future work is to enhance the application to support fully automatic real-time data retrieval and prediction. This would involve significant improvements in the data processing infrastructure, as well as in the responsiveness of the implemented machine learning models. 5. Improvement in Data Collection and Processing: Further optimizing the process of collecting and processing data from the Fitbit API would be beneficial. This could include incorporating additional metrics that are useful and effective for machine learning model processing, ultimately improving the accuracy and usefulness of the predictions. 6. Cross-Platform Integration: Currently, HeartPred’it has been developed as a desktop application. In future work, it would be relevant to expand its availability to other platforms, such as mobile and web, to increase accessibility and facilitate its use in different environments. 100 7. Study to Predict Other Variables: Conduct a study to find the best model for different variables (calories, steps, distance travelled) to improve the prediction of these. These future efforts would not only improve the functionality and accuracy of HeartPred’it, but also expand its applicability and adaptability in the sports field and beyond. 101 CONTRIBUCIONES PERSONALES Cabe destacar que, ambos integrantes de este proyecto han cooperado por igual en la creación de este proyecto de fin de grado. Juan Israel Baroffi González: Trabajos realizados por el estudiante, Juan Israel Baroffi González: • Estudio y lluvia de ideas de proyectos relacionados con la creación de una herramienta de apoyo para deportista, que implemente varios conocimientos adquiridos durante el grado. • Estudios de bases de datos públicas con datos fitness. o Base de datos pública en Kaggle. • Realización de estudios de investigación sobre el funcionamiento de las distintas tecnologías utilizadas en el proyecto HeartPred’it. Jupyter Notebooks: Merge API Database.ipynb: Unificación de varios CSV proporcionados por la API de Fitbit en un único CSV, facilitando la lectura de los datos. Modelos de Predicción.ipynb: Investigación de modelos de ML para encontrar el más adecuado que se adapte a la variabilidad de la frecuencia cardíaca de los usuarios de la aplicación. Modelos de predicción_Calories.ipynb: Estudio comparativo del rendimiento de XGboost y LightGBM para predecir las calorías de los usuarios de la aplicación. Predicción_a_futuro.ipynb: 102 Estudio y adaptación de técnicas de predicción a futuro utilizando varios modelos de ML como: LightGBM, XGBoost, KNN, RandomForest, SVR. Preparación Datos.ipynb: Preprocesamiento de los datos para su posterior entrenamiento en los modelos de ML. TFG_Fitbit_obtencion_datos.ipynb: Estudio de las llamadas a la API de Fitbit para obtener todos los datos necesarios para la aplicación. Test_Prediccion.ipynb: Evaluación de cómo los diferentes modelos de ML predicen la frecuencia cardíaca, analizando su rendimiento. • Desarrollo de la aplicación HeartPred’it: La aplicación está escrita enteramente en Python, incluye la integración de modelos de Machine Learning, la implementación de clases para la gestión de la API de Fitbit y el flujo de autentificación OAuth2.0. Además, se desarrollaron clases para controlar la lógica del modelo e interfaz de la aplicación usando Tkinter. También se crearon clases relacionadas con la seguridad de los datos proporcionados por el cliente, como el Hashing de contraseñas mediante SHA-256 y, un servidor en Flask para recibir la respuesta del proceso de autenticación OAuth2.0. Finalmente, el desarrollo de una clase para gestionar las lecturas, escrituras de datos en Mongo. • Memoria. 103 Javier María Parra González: Trabajos realizados por el estudiante, Javier María Parra González: • Estudio y lluvia de ideas de proyectos relacionados con la creación de una herramienta de apoyo para deportista, que implemente varios conocimientos adquiridos durante el grado. • Estudios de bases de datos públicas con datos fitness. o Base de datos pública en Kaggle. • Realización de estudios de investigación sobre el funcionamiento de las distintas tecnologías utilizadas en el proyecto HeartPred’it. Jupyter Notebooks: ML-train-time-elapsed-time.ipynb: Estudio para justificar el uso en la aplicación HeartPred’it de modelos de ML como XGboost y LightGBM, frente otros modelos de mejor rendimiento como el VotingRegressor por su demora en tiempo de entrenamiento. Merge API Database.ipynb: Unificación de varios CSV proporcionados por la API de Fitbit en un único CSV, facilitando la lectura de los datos. Modelos de Predicción.ipynb: Investigación de modelos de ML para encontrar el más adecuado que se adapte a la variabilidad de la frecuencia cardíaca de los usuarios de la aplicación. Modelos de predicción_Calories.ipynb: Estudio comparativo del rendimiento de XGboost y LightGBM para predecir las calorías de los usuarios de la aplicación. Predicción_a_futuro.ipynb: 104 Estudio y adaptación de técnicas de predicción a futuro utilizando varios modelos de ML como: LightGBM, XGBoost, KNN, RandomForest, SVR. Preparación Datos.ipynb: Preprocesamiento de los datos para su posterior entrenamiento en los modelos de ML. TFG_Fitbit_obtencion_datos.ipynb: Estudio de las llamadas a la API de Fitbit para obtener todos los datos necesarios para la aplicación. Test_Prediccion.ipynb: Evaluación de cómo los diferentes modelos de ML predicen la frecuencia cardíaca, analizando su rendimiento. • Desarrollo de la aplicación HeartPred’it: La aplicación está escrita enteramente en Python, incluye la integración de modelos de Machine Learning, la implementación de clases para la gestión de la API de Fitbit y el flujo de autentificación OAuth2.0. Además, se desarrollaron clases para controlar la lógica del modelo e interfaz de la aplicación usando Tkinter. También se crearon clases relacionadas con la seguridad de los datos proporcionados por el cliente, como el Hashing de contraseñas mediante SHA-256 y, un servidor en Flask para recibir la respuesta del proceso de autenticación OAuth2.0. Finalmente, el desarrollo de una clase para gestionar las lecturas, escrituras de datos en Mongo. • Memoria.