Programming on Matias Di Bernardo

Generador de ruitnas de entrenamiento automáticas

Wed, 17 Apr 2024 00:00:00 +0000

Generador Automático de Rutinas de Ejercicio

Este proyecto fue el trabajo final para la asignatura Algoritmos y Programación II en la UNTREF. La idea de la aplicación es funcionar como una planificación inteligente de rutinas de ejercicio, donde el usuario ingresa ciertos criterios y el programa establece la mejor rutina para maximizar las preferencias del usuario. El programa fue escrito en el lenguaje de programación Go.

Gestión de Datos

Este curso no se centra en bases de datos, por lo que optamos por usar un archivo CSV para simular una base de datos. Este archivo contiene toda la información sobre las diferentes rutinas y sus atributos. Esto sirve como un archivo de persistencia mientras que toda la lógica es manejada por el programa.

Los diferentes ejercicios están categorizados por temáticas. Hay dos entidades en el programa que están representadas como structs en Go: los Ejercicios y las Rutinas.

Ejercicio

Todos los ejercicios tienen los siguientes atributos:

Nombre: Nombre del ejercicio.
Descripción: Descripción detallada del ejercicio.
Duración: Duración estimada del ejercicio.
Calorías: Número de calorías quemadas durante el ejercicio.
Tipo: Tipo de ejercicio (por ejemplo, cardio, fuerza, flexibilidad).
Grupo Muscular: Grupo muscular objetivo del ejercicio.
Puntos: Puntos asignados al ejercicio según sus tipos.
Dificultad: Nivel de dificultad del ejercicio.

Rutinas

Todas las rutinas son una colección de ejercicios. Estas se procesan como una lista enlazada de ejercicios. Además, las rutinas tienen los siguientes atributos:

Nombre: Nombre de la rutina.
Ejercicios: Cadena que almacena los IDs de los ejercicios en la rutina, separados por comas.
EjerciciosDisponibles: Lista enlazada de los ejercicios disponibles para crear la rutina.

Algoritmo

La idea es maximizar diferentes parámetros, por ejemplo, la cantidad máxima de calorías quemadas en el menor tiempo posible, o la duración mínima para un grupo muscular o tipo de ejercicio específico. Para encontrar las mejores soluciones basadas en los datos existentes, proponemos un algoritmo de programación dinámica que busca todas las posibilidades a partir de los datos y encuentra el máximo o mínimo según las especificaciones del usuario. El enfoque de programación dinámica utiliza memoria para evitar recalcular combinaciones que ya fueron computadas, lo que optimiza el algoritmo lo suficiente como para generar las rutinas en milisegundos (con el conjunto de datos de prueba evaluado).

Interfaz de Usuario

Actualmente, el programa está diseñado para ser utilizado desde la terminal como una aplicación CLI. El usuario puede crear un ejercicio y una rutina, listar las opciones disponibles y generar una rutina personalizada basada en las especificaciones que elija.

Esta es la primera iteración del proyecto y es completamente funcional, pero planeamos crear una interfaz gráfica para que sea más amigable para el usuario. Para este propósito, sería mejor usar un framework diferente y utilizar esta aplicación en Go como backend para un servicio web o una aplicación.

Conclusiones

Con este proyecto, solidifiqué mis conocimientos sobre temas de programación como estructuras de datos y algoritmos, ya que aplicamos la teoría vista en clase a un caso real. También me ayudó a familiarizarme con el lenguaje Go, que se convirtió en un lenguaje que disfruto mucho programar. El código de este proyecto está disponible en este repositorio.

Z-Plane Visualizer

Sat, 12 Aug 2023 00:00:00 +0000

En el curso de Procesamiento Digital de Señales (DSP) en la UNTREF, exploramos el plano Z para el diseño de filtros con variables discretas. Durante la clase, el profesor presentó una herramienta construida en MatLab que visualiza los gráficos de transferencia y fase en relación con las posiciones de los ceros y polos en el plano Z.

Inspirado en esto, decidí recrear esta herramienta en Python. Aprovechando mi experiencia con la biblioteca PyGame, logré construir una aplicación en tiempo real que permite mover los polos y ceros, permitiendo a los usuarios ver cómo cambia la función de transferencia en tiempo real.

Cómo Funciona

Primero, mapeo las posiciones de los píxeles en el plano Z a coordenadas de acuerdo con la representación del círculo unitario. Luego, construyo la función de transferencia, donde cada cero $z_{n}$ es un término en el numerador y cada polo $z_{i}$ es un término en el denominador. Con la función de transferencia $H(z)$, puedo graficar tanto el magnitud como el gráfico de fase, que también son representaciones mapeadas de la respuesta normalizada dentro de la aplicación.

$$ H(z) = \frac{\sum_{n=0}^{N} (z - z_{n})}{\sum_{i=0}^{N} (z - z_{i})} $$

Cada fotograma recalcula la función de transferencia. El programa funciona de manera eficiente porque almaceno los ceros y polos en arreglos, lo que permite cálculos más rápidos gracias a numpy, que ya está altamente optimizado. Esto permite visualizar los cambios en tiempo real y proporciona una comprensión más intuitiva del comportamiento del plano Z. El siguiente fragmento de código muestra como se calcula la magnitud y fase utilizando exponenciales complejas.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


def e(w, root):
 return (np.exp(1j*w) - root)

def transfer_function(zeros, poles):
 w = np.linspace(-np.pi, np.pi, RES)

 for zero in zeros:
 num = e(w, zero)

 for pole in poles:
 den = e(w, pole)

 H_z = num/den

 mag = np.abs(H_z)
 ang = np.angle(H_z)

 return mag, ang

Este proyecto está diseñado como material educativo, proporcionando a los estudiantes una herramienta práctica para comprender mejor las interacciones entre los polos y ceros en el plano Z. No está destinado como una herramienta profesional para el diseño de filtros.

Funcionalidad

La aplicación ofrece las siguientes características:

Mostrar y mover polos/ceros: Los usuarios pueden seleccionar y mover los polos y ceros en el plano Z. Cuando la opción de simetría está activa, todos los polos y ceros seleccionados o movidos se colocan de manera simétrica respecto al eje imaginario.
Orden: Los usuarios pueden ajustar el orden de los polos y ceros desplazando la rueda del mouse. El orden puede incrementarse o disminuirse, con soporte hasta un orden de 4. El color de cada polo o cero cambia según su orden.
Información: Al pasar el cursor sobre un polo o cero, se muestra información sobre su posición, simetría y orden.
Zoom: El usuario puede acercar o alejar el plano Z usando los botones de más y menos.
Eliminar: El ícono de la papelera elimina todos los polos y ceros del plano. Los usuarios también pueden eliminar polos o ceros individuales haciendo clic derecho sobre ellos.
Gráfico de Magnitud: El espectro de magnitud mostrado en la aplicación está normalizado. Esta decisión asegura que el enfoque permanezca en la forma de la magnitud, haciendo que el gráfico sea visualmente significativo para los usuarios. Sin embargo, no captura la diferencia en los valores máximos.
Gráfico de Fase: La fase se muestra sin envolver entre $-\pi$ y $\pi$.

Demo

Aquí tienes una demostración rápida de la aplicación en acción:

El código fuente de este proyecto se encuentra en este repositorio.

Algorítmos de modificación de escala temporal

Thu, 09 Mar 2023 00:00:00 +0000

Los algoritmos de modificación de escala temporal se utilizan para acelerar o desacelerar la velocidad de reproducción de un audio. Cuando se cambia la tasa de muestreo de un audio, la velocidad cambia, pero también lo hace el tono (al acelerar el audio, suena con un tono más alto). Existen diferentes algoritmos que permiten modificar la velocidad del audio manteniendo constante el tono.

La principal referencia para este estudio es el siguiente artículo, donde se describen en detalle los distintos algoritmos.

A Review of Time-Scale Modification of Music Signals.
— Jonathan Driedger y Meinard Müller¹

Comparación de algoritmos

Existen dos algoritmos principales, el Overlap-and-add (OLA) y el Phase Vocoder (PV). Ambos logran buenos resultados bajo diferentes señales y condiciones. Para aprovechar las ventajas de ambos métodos, se utiliza una implementación final basada en la Separación Armónico-Percusiva (HPS), que combina ambos algoritmos y logra los mejores resultados.

OLA

Este método trabaja en el dominio del tiempo, superponiendo secciones del audio (ventanas) y reorganizándolas para lograr un cambio deseado en la velocidad. Este método funciona bien para señales percusivas, pero introduce artefactos cuando se utiliza con señales armónicas o tonales.

PV

Este método opera en el dominio de la frecuencia, combinando fragmentos de audio en este dominio para lograr el cambio deseado en el tiempo. Utiliza el principio del vocoder de fase para propagar la fase entre ventanas, garantizando la continuidad al aplicarse a señales armónicas. Sin embargo, no es efectivo para señales percusivas, ya que el proceso de propagación de fase elimina los transitorios en las señales.

Creé visualizaciones usando Manim para mejorar mi presentación en clase. El primer video muestra cómo el algoritmo PV alinea las ventanas para garantizar transiciones suaves en la señal generada a lo largo del tiempo. Para lograrlo, se aplica una ventana gaussiana que mantiene la continuidad y suavidad, incluso al inicio y al final de la secuencia.

El segundo video muestra los efectos de aplicar el algoritmo PV a una señal que contiene transitorios.

Como predice la teoría, los transitorios desaparecen porque el algoritmo PV interrumpe la alineación vertical de la fase. Aunque estos ejemplos utilizan señales idealizadas, demuestran de manera efectiva las principales fortalezas y limitaciones del algoritmo.

HPS

Para utilizar ambos métodos con las señales ideales, se emplea el algoritmo HPS. Este algoritmo separa la señal en sus componentes armónicas y percusivas. Funciona comparando la continuidad de la señal en la representación STFT, utilizando un filtro que compara la presencia vertical contra la horizontal en el espectrograma. Con un umbral, se puede definir una máscara binaria sobre el espectrograma para separar las partes percusivas de las secciones armónicas.

Resultados

Implementamos con éxito todos los algoritmos y los comparamos, verificando los contenidos teóricos presentados en el artículo de referencia. Durante el proceso, desarrollamos un conjunto de herramientas para utilizar estos algoritmos con el lenguaje de programación Python. Todo el código está disponible en este repositorio.

Presentación académica

El estudio fue presentado junto a mis compañeros en las JAAS (Jornadas de Acústica, Audio y Sonido). Las principales ideas y conclusiones se expusieron en la conferencia. En el siguiente informe se encuentran todos los detalles y análisis realizados para este proyecto (en español).

ALGORITMOS DE MODIFICACIÓN DE ESCALA TEMPORAL.
— Matías Di Bernardo; Matías Vereertbruhggen; Sebastían Carro²

A Review of Time-Scale Modification of Music Signal paper. ↩︎
JAAS 2023 - Algoritmos de Modificación de Escala Temporal paper. ↩︎

IA aprende a jugar 2048

Fri, 17 Feb 2023 00:00:00 +0000

Usé este proyecto como introducción al Aprendizaje por Refuerzo (Reinforcement Learning). Habiendo trabajado principalmente con aprendizaje supervisado y no supervisado, quería comenzar con un proyecto pequeño y sencillo para comprender rápidamente las ideas principales y crear algo divertido. Seguí este video de YouTube como referencia, el cual explica cómo usar Aprendizaje por Refuerzo (RL) para entrenar un modelo capaz de jugar al juego de la serpiente. Para hacerlo más desafiante, apliqué la misma red al juego 2048.

Código

El código tiene tres componentes principales:

El Juego: Implementa la lógica del juego y la interfaz gráfica (GUI).
Agente: Controla la jugabilidad.
Modelo de IA: Una red neuronal que aprende a jugar y guía al agente.

Estado del Juego

Modelé el estado del juego como una matriz de 4x4 que representa el tablero. Las acciones del juego están representadas por un vector con las siguientes posibilidades:

Izquierda: [1, 0, 0, 0]
Derecha: [0, 1, 0, 0]
Arriba: [0, 0, 1, 0]
Abajo: [0, 0, 0, 1]

Recompensa

El modelo de RL funciona con recompensas para cuantificar cuándo el agente actúa bien o mal. Inicialmente, definí las siguientes recompensas:

+10 puntos: Cuando el agente duplica los puntos. Esto es crucial porque, en 2048, los puntos aumentan exponencialmente.
-10 puntos: Cuando se pierde el juego. Esto sirve como una penalización sencilla.

Al principio, el modelo mostraba una mejora lenta. Para solucionarlo, añadí una recompensa adicional:

+2 puntos: Cuando se incrementan los puntos. Esta recompensa incentiva acciones que maximicen la limpieza del tablero y el progreso.

Cómo Funciona el Modelo

El modelo es una red neuronal lineal simple. Toma el estado del juego como entrada y predice la mejor acción siguiente para maximizar la recompensa.

Las recompensas se gestionan utilizando una técnica llamada Q-Learning. Un valor Q representa la calidad de una decisión basada en la función de pérdida. La función de pérdida se deriva de la Ecuación de Bellman:

$$ NewQ(s, a) = Q(s, a) + \alpha [R(s, a) + \lambda \, \text{max}Q'(s', a') - Q(s, a)] $$

Donde:

$Q(s, a)$: El valor Q para un estado y acción específicos.
$\alpha$: Tasa de aprendizaje.
$R(s, a)$: Recompensa para un estado y acción específicos.
$\lambda$: Tasa de descuento.
$\text{max}Q’(s’, a’)$: Recompensa futura máxima esperada.

Experimentos y Resultados

Prueba Aleatoria como Línea Base

Para establecer una línea base, probé el puntaje promedio que se puede lograr tomando acciones aleatorias. Después de 1,000 iteraciones, el puntaje promedio fue de 170, muy por debajo de los 2048 puntos necesarios para ganar el juego.

Resultados Iniciales

Mis primeros intentos fueron desalentadores. El modelo tenía un desempeño peor que los movimientos aleatorios. Aquí algunos resultados iniciales:

Juego 1,000 | Puntaje: 208 | Récord: 416 | Puntaje Promedio: 200 | Recompensa: 640
Juego 1,000 | Puntaje: 116 | Récord: 346 | Puntaje Promedio: 161 | Recompensa: 310
Juego 1,000 | Puntaje: 112 | Récord: 348 | Puntaje Promedio: 146 | Recompensa: 320

En estos intentos, el agente desarrolló una estrategia subóptima de llenar el tablero antes de incrementar los puntos.

Mejoras

Tras experimentar con los parámetros de recompensa, me centré en la fase de exploración. Inicialmente, el parámetro de juegos de exploración, que elige movimientos aleatorios, estaba configurado en 25 juegos. Al aumentar este parámetro, el agente pudo explorar más estrategias, logrando mejores resultados:

Juego 1,000 | Puntaje: 478 | Récord: 478 | Puntaje Promedio: 230
Juego 1,000 | Puntaje: 514 | Récord: 964 | Puntaje Promedio: 382

A medida que el modelo mejoraba, extendí el entrenamiento a más juegos:

Juego 3,796 | Puntaje: 770 | Récord: 1,366 | Puntaje Promedio: 469
Juego 4,852 | Puntaje: 631 | Récord: 1,462 | Puntaje Promedio: 483

Finalmente, con 200 juegos de exploración y 5,000 juegos de entrenamiento, los resultados fueron los siguientes:

Juego 5,000 | Puntaje: 840 | Récord: 1,678 | Puntaje Promedio: 512

Aunque el modelo no logró ganar el juego, quedé satisfecho con el progreso. Creo que con más tiempo de entrenamiento (el último intento duró 4 horas) y capas adicionales en la red, sería posible ganar el juego con esta arquitectura.

Demo

Aquí tienes una demostración de la aplicación, mostrando el proceso de aprendizaje del agente:

Implementé atajos de teclado para controlar la velocidad del juego, ofreciendo tres opciones:

Rápida: Para un entrenamiento acelerado.
Lenta: Para observar y analizar el progreso del agente y sus errores.
Media: Casi no la utilicé.

El código completo para este proyecto está disponible en este repositorio.