universidad central del ecuador facultad de ingenierÍa
TRANSCRIPT
UNIVERSIDAD CENTRAL DEL ECUADOR
FACULTAD DE INGENIERÍA, CIENCIAS FÍSICAS Y
MATEMÁTICA
CARRERA DE INGENIERÍA EN COMPUTACIÓN GRÁFICA
Desarrollo de una aplicación para generar ritmos de batería a través de
técnicas relacionadas con aprendizaje automático
Trabajo de titulación modalidad Proyecto Integrador, previo a la
obtención del título de Ingeniero en Computación Gráfica
AUTOR: Oña Játiva Martín Patricio
TUTOR: Ing. Zoila De Lourdes Ruiz Chávez
Quito, 2020
ii
DERECHOS DE AUTOR
Yo, Oña Játiva Martín Patricio en calidad de autor y titular de los derechos morales y
patrimoniales del trabajo de titulación, Desarrollo de una aplicación para generar
ritmos de batería a través de técnicas relacionadas con aprendizaje automático,
modalidad proyecto integrador, de conformidad con el Art. 114 del CÓDIGO
ORGÁNICO DE LA ECONOMÍA SOCIAL DE LOS CONOCIMIENTOS,
CREATIVIDAD E INNOVACIÓN, concedo a favor de la Universidad Central del
Ecuador una licencia gratuita, intransferible y no exclusiva para el uso no comercial de la
obra, con fines estrictamente académicos. Conservo a mi favor todos los derechos de autor
sobre la obra, establecidos en la normativa citada.
Así mismo, autorizo a la Universidad Central del Ecuador para que realice la
digitalización y publicación de este trabajo de titulación en el repositorio virtual, de
conformidad a lo dispuesto en el Art. 144 de la Ley Orgánica de Educación Superior.
El autor declara que la obra objeto de la presente autorización es original en su forma de
expresión y no infringe el derecho de autor de terceros, asumiendo la responsabilidad por
cualquier reclamación que pudiera presentarse por esta causa y liberando a la Universidad
Central del Ecuador de toda responsabilidad.
__________________________
Oña Játiva Martín Patricio
CC. 1723546014
iii
APROBACIÓN DEL TUTOR
En mi calidad de Tutora del Trabajo de Titulación, presentado por Oña Játiva Martín
Patricio, para optar por el Grado de Ingeniero en Computación Gráfica; cuyo título es:
“DESARROLLO DE UNA APLICACIÓN PARA GENERAR RITMOS DE
BATERÍA A TRAVÉS DE TÉCNICAS RELACIONADAS CON APRENDIZAJE
AUTOMÁTICO”, considero que dicho trabajo reúne los requisitos y méritos suficientes
para ser sometido a la presentación y evaluación por parte del tribunal examinador que se
designe.
En la ciudad de Quito, a los 06 días del mes de abril de 2020.
________________________________________
Ing. Zoila de Lourdes Ruiz Chávez
DOCENTE-TUTOR
CI. 171192655-8
iv
DEDICATORIA
A mi familia, por el apoyo incondicional.
v
AGRADECIMIENTO
Al GMSC (Grupo de modelado de sistemas complejos) por todas las oportunidades
brindadas, en especial al Ing. Pedro Almagro por la dedicación como docente y por
todo el tiempo y conocimiento brindado.
A la Ing. Zoila Ruiz por las enseñanzas brindadas a lo largo de la carrera, tanto
académica como personal.
A Cristina, por hacerme ver mis fallas, además del tiempo compartido hasta el
momento.
vi
CONTENIDO
DERECHOS DE AUTOR ................................................................................................ ii
APROBACIÓN DEL TUTOR ........................................................................................ iii
DEDICATORIA .............................................................................................................. iv
AGRADECIMIENTO ...................................................................................................... v
CONTENIDO .................................................................................................................. vi
LISTA DE TABLAS ....................................................................................................... ix
LISTA DE FIGURAS ...................................................................................................... x
RESUMEN .................................................................................................................... xiii
CAPÍTULO I .................................................................................................................... 1
1. PLANTEAMIENTO DEL PROBLEMA ............................................................. 1
1.1 ANTECEDENTES ............................................................................................. 1
1.2 FORMULACIÓN DEL PROBLEMA ............................................................. 2
1.3 DESCRIPCIÓN DEL PROBLEMA ................................................................ 2
1.4 JUSTIFICACIÓN .............................................................................................. 3
1.5 OBJETIVOS ....................................................................................................... 4
1.5.1 OBJETIVO GENERAL ............................................................................. 4
1.5.2 OBJETIVOS ESPECÍFICOS .................................................................... 4
1.6 ALCANCE .......................................................................................................... 4
1.7 LIMITACIONES ............................................................................................... 5
CAPÍTULO II ................................................................................................................... 6
2. MARCO TEÓRICO ............................................................................................... 6
2.1 ASPECTOS TEÓRICOS ................................................................................... 6
2.2 ALGUNOS CONCEPTOS DE INTELIGENCIA ARTIFICIAL .................. 6
2.2.1 PRUEBA DE TURING .............................................................................. 6
2.3 APRENDIZAJE AUTOMÁTICO .................................................................... 8
2.3.1 PARADIGMA DE PROGRAMACIÓN TRADICIONAL Y DE
APRENDIZAJE AUTOMÁTICO ..................................................................... 8
2.3.2 ELEMENTOS DEL APRENDIZAJE AUTOMÁTICO ......................... 9
2.3.2.1 DATOS .................................................................................................. 9
2.3.2.2 MODELOS ........................................................................................... 9
2.3.2.3 ENTRENAMIENTO ........................................................................... 9
2.3.3 TIPOS DE APRENDIZAJE AUTOMÁTICO ....................................... 10
2.3.3.1 APRENDIZAJE SUPERVISADO ................................................... 10
2.3.2.2 APRENDIZAJE NO SUPERVISADO ............................................ 11
vii
2.3.3.3 APRENDIZAJE POR REFUERZO ................................................ 11
2.4 ALGORITMOS DE APRENDIZAJE AUTOMÁTICO .............................. 11
2.4.1 ÁRBOLES DE DECISIÓN (DECISION TREE - DT) ......................... 11
2.4.1.1 COMPONENTES DEL ÁRBOL DE DECISIÓN .......................... 11
2.4.1.2 ID3 ....................................................................................................... 12
2.4.2 BOSQUES ALEATORIOS (RANDOM FOREST - RF) ...................... 14
2.4.3 REDES NEURONALES ARTIFICIALES (ARTIFICIAL NEURAL
NETWORK - ANN) .......................................................................................... 15
2.4.3.2 REDES NEURONALES CONVOLUCIONALES
(CONVOLUTIONAL NEURAL NETWORK - CNN) .............................. 19
2.4.3.3 REDES NEURONALES RECURRENTES (RECURRENT
NEURAL NETWORK - RNN) ..................................................................... 22
2.5 FUNCIONES DE ACTIVACIÓN Y PÉRDIDA ........................................... 23
2.6 DEFINICIÓN DE WEB................................................................................... 25
2.6.1 ARQUITECTURA CLIENTE SERVIDOR .......................................... 25
2.6.2 EL PATRÓN MVC .................................................................................. 26
2.6.3 PROTOCOLO HTTP .............................................................................. 26
2.7 MÚSICA ............................................................................................................ 26
2.7.1 ELEMENTOS DE LA MÚSICA ............................................................ 26
2.7.2 FIGURAS MUSICALES ......................................................................... 27
2.7.3 SIGNOS DE NOTACIÓN MUSICAL .................................................... 27
2.8 ANÁLISIS DE LAS HERRAMIENTAS ....................................................... 28
2.8.1 ANACONDA NAVIGATOR ................................................................... 28
2.8.2 SPYDER .................................................................................................... 29
2.8.3 PYTHON ................................................................................................... 29
2.8.4 SCIKIT-LEARN ....................................................................................... 30
2.8.5 KERAS ...................................................................................................... 30
2.8.6 MAGENTA ............................................................................................... 30
2.8.7 VISUAL STUDIO CODE ........................................................................ 31
2.8.8 DJANGO ................................................................................................... 31
2.8.9 HTML ........................................................................................................ 32
2.8.10 CSS ........................................................................................................... 32
2.8.11 JAVASCRIPT ......................................................................................... 33
CAPÍTULO III ............................................................................................................... 34
3. MARCO METODOLÓGICO ............................................................................. 34
3.1 PROGRAMACIÓN EXTREMA (EXTREME PROGRAMMING - XP) .. 34
viii
3.2 CRYSTAL ......................................................................................................... 35
3.3 KANBAN........................................................................................................... 36
3.4 SCRUM ............................................................................................................. 37
3.5 SCRUM, XP Y CRYSTAL .............................................................................. 39
3.6 REQUISITOS PARA EL DESARROLLO DE LA APLICACIÓN ............ 39
CAPÍTULO IV ............................................................................................................... 41
4. DESARROLLO DE LA APLICACIÓN ............................................................. 41
4.1 FORMATO DE DATOS PARA EL CONJUNTO DE
ENTRENAMIENTO .............................................................................................. 41
4.2 MANUPULACIÓN DE LOS DATOS ............................................................ 44
4.3 CONVERSIÓN A MATRIZ BINARIA ......................................................... 47
4.3 DIVIDIR EN X_TRAIN Y Y_TRAIN ............................................................ 49
4.4 ALGORITMOS DE APRENDIZAJE AUTOMÁTICO .............................. 54
4.5 GENERACIÓN DE NUEVOS RITMOS DE BATERÍA ............................. 56
4.6 IMPLEMENTACIÓN DEL CÓDIGO EN EL LADO DEL SERVIDOR .. 58
4.7 IMPLEMENTACIÓN DE LA VISTA ........................................................... 59
4.8 DESPLIEGUE .................................................................................................. 62
4.9 PRUEBAS Y RESULTADOS ......................................................................... 62
CAPÍTULO V ................................................................................................................ 69
5. CONCLUSIONES Y RECOMENDACIONES .................................................. 69
5.1 CONCLUSIONES ............................................................................................ 69
5.2 RECOMENDACIONES .................................................................................. 70
BIBLIOGRAFÍA ............................................................................................................ 71
ANEXOS ........................................................................................................................ 75
ix
LISTA DE TABLAS
Tabla 1. Algunas definiciones de inteligencia artificial. Obtenido de (Norving &
Russell, 2004) ................................................................................................................... 6
Tabla 2. Árbol de decisión .............................................................................................. 12
Tabla 3. Funciones de activación. Obtenido de (Raschka & Mirjalili, 2019) ................ 24
Tabla 4. Funciones de pérdida (coste) ............................................................................ 24
Tabla 5. Figuras musicales. Obtenido de (Díaz, 2002) .................................................. 27
Tabla 6. Ventajas y desventajas (Python, Matlab y RStudio) ....................................... 30
Tabla 7. Características de Django y Flask .................................................................... 32
Tabla 8. Uso de las herramientas de software en la aplicación ...................................... 33
Tabla 9. Diferencias entre metodologías ágiles y no ágiles. Obtenido de (Canós,
Letelier, & Penadés, 2012) ............................................................................................. 34
Tabla 10. Elementos del marco de trabajo Scrum. Obtenido de (Schwaber & Sutherland,
2013) ............................................................................................................................... 38
Tabla 11. Ranking de "agilidad". Obtenido de (Letelier & Penadés, 2012) ................... 39
Tabla 12. Requisitos de la aplicación DrumML ............................................................. 40
Tabla 13. Mensajes MIDI. Obtenido de (Midi Association, 2009) ................................ 42
Tabla 14. Mapa MIDI de percusión. Obtenido de (Song Writer, 2012) ........................ 43
Tabla 15. Manipulación de archivo (.mid) con Mido y Magenta ................................... 46
Tabla 16. Elementos del diseño ...................................................................................... 60
Tabla 17. Elementos de la aplicación ............................................................................. 60
Tabla 18. Parámetros de la aplicación ............................................................................ 61
Tabla 19. Datos de entrenamiento para DT .................................................................... 62
Tabla 20. Datos de entrenamiento para RF .................................................................... 63
Tabla 21. Datos de entrenamiento para MLP ................................................................. 64
Tabla 22. Datos de entrenamiento para LSTM............................................................... 65
Tabla 23. Datos de entrenamiento para LSTM – Dropout(0.5)...................................... 66
Tabla 24. Datos de entrenamiento para CNN ................................................................. 67
Tabla 25. Datos de entrenamiento para CNN – Dropout(0.5) ........................................ 68
Tabla 26. Pantallas de la aplicación desde IPhone ......................................................... 75
Tabla 27. Pantallas de la aplicación desde Samsung ...................................................... 76
Tabla 28. Pantallas de la aplicación desde Windows 10 ................................................ 78
x
LISTA DE FIGURAS
Figura 1. Prueba de Turing. Obtenido de (Taulli, 2019) .................................................. 7
Figura 2. Ramas de la Inteligencia Artificial .................................................................... 7
Figura 3. Paradigma de programación tradicional. Obtenido de (Kashyap, 2018) .......... 8
Figura 4. Paradigma de aprendizaje automático. Obtenido de (Kashyap, 2018) ............. 9
Figura 5. Proceso de Aprendizaje (vertical) e inferencia (horizontal). Obtenido de (Kim,
2017) ................................................................................................................................. 9
Figura 6. Tipos de Aprendizaje Automático .................................................................. 10
Figura 7. Componentes del árbol de decisión. Obtenido de (Ayyadevara, 2018) .......... 12
Figura 8. Datos para predecir un árbol de decisión, resultado final del árbol de decisión.
Obtenido de (Sayad, 2010) ............................................................................................. 12
Figura 9. Cálculo de la entropía del sistema. Obtenido de (Sayad, 2010)...................... 13
Figura 10. Cálculo de la entropía con respecto al atributo Outlook. Obtenido de (Sayad,
2010) ............................................................................................................................... 13
Figura 11. Cálculo de la ganancia de información. Obtenido de (Sayad, 2010) ............ 13
Figura 12. Bagging. Obtenido de (Swamynathan, 2017) ............................................... 14
Figura 13. Neurona Artificial. Obtenido de (Pacheco, 2017) ......................................... 15
Figura 14. Perceptrón. Obtenido de (Raschka & Mirjalili, 2019) .................................. 16
Figura 15. Adaline. Obtenido de (Raschka & Mirjalili, 2019) ....................................... 17
Figura 16. Descenso del gradiente. Obtenido de (Raschka & Mirjalili, 2019) .............. 17
Figura 17. Perceptrón multicapa (fully connected). Obtenido de (Raschka & Mirjalili,
2019) ............................................................................................................................... 18
Figura 18. Propagación hacia atrás. Obtenido de (Raschka & Mirjalili, 2019) ............. 19
Figura 19. Ejemplo de convolución (p=0). Obtenido de (Raschka & Mirjalili, 2019) .. 20
Figura 20. Formas de relleno en la convolución. Obtenido de Obtenido de (Raschka &
Mirjalili, 2019) ............................................................................................................... 20
Figura 21. Resultado de la convolución 2D. Obtenido de Obtenido de (Raschka &
Mirjalili, 2019) ............................................................................................................... 21
Figura 22. Ejemplo de max-pooling con dos matrices de entrada diferentes. Obtenido de
(Raschka & Mirjalili, 2019)............................................................................................ 21
Figura 23. Red neuronal convolucional. Obtenido de (Santamaría, Zuñiga, Pineda,
Somodevilla, & Rossainz) .............................................................................................. 22
Figura 24. Red neuronal recurrente. Obtenido de (Swamynathan, 2017) ...................... 22
Figura 25. LSTM. Obtenido de (Swamynathan, 2017) .................................................. 23
Figura 26. Cliente – Servidor. Obtenido de (Marini, 2012) ........................................... 25
Figura 27. Esquema de una aplicación MVC. Obtenido de (Sierra, 2007) .................... 26
Figura 28. Pentagrama. Obtenido de (Díaz, 2002) ......................................................... 27
Figura 29. Clave de fa. Obtenido de (Díaz, 2002) .......................................................... 27
Figura 30. Llave rítmica. Obtenido de (Díaz, 2002) ...................................................... 28
Figura 31. Compás 4/4 ................................................................................................... 28
Figura 32. Líneas divisorias. Obtenido de (Díaz, 2002) ................................................. 28
Figura 33. Tempo ........................................................................................................... 28
Figura 34. Logo de Anaconda. Obtenido de (Anaconda, 2020) ..................................... 28
Figura 35. Logo de Spyder. Obtenido de (Spyder, 2018)............................................... 29
Figura 36. Logo de Python. Obtenido de (Python, 2001)............................................... 29
xi
Figura 37. Logo de Matlab. Obtenido de (Matlab, 1994)............................................... 29
Figura 38. Logo de RStudio. Obtenido de (RStudio, 2020) ........................................... 30
Figura 39. Logo de Scikit-Learn. Obtenido de (scikit-learn, 2020) ............................... 30
Figura 40. Logo de Keras. Obtenido de (Keras, 2020)................................................... 30
Figura 41. Logo de Magenta. Obtenido de (Magenta, 2020) ......................................... 31
Figura 42. Logo de VScode. Obtenido de (Visual Studio Code, 2020) ......................... 31
Figura 43. Logo de Django. Obtenido de (Django, 2005) .............................................. 31
Figura 44. Logo de Flask. Obtenido de (Flask, 2010) .................................................... 32
Figura 45. Logo de HTML. Obtenido de (Freepng, 2019) ............................................. 32
Figura 46. Logo de CSS. Obtenido de (Freepng, 2019) ................................................. 32
Figura 47. Logo de JavaScript. Obtenido de (Freepng, 2019) ....................................... 33
Figura 48. Ciclo de XP. Obtenido de (Visual Paradigm, 2020) ..................................... 35
Figura 49. Grupo de metodologías en Crystal. Obtenido de (Edureka, 2020) ............... 36
Figura 50. Control visual en Kanban. Obtenido de (Hammarberg & Sunden, 2014) .... 36
Figura 51. Ciclo de Scrum. Obtenido de (Freepng, 2019) ............................................. 37
Figura 52. Note-on y note-off. Obtenido de (Midi Association, 2009) .......................... 41
Figura 53. Velocity. Obtenido de (Midi Association, 2009) .......................................... 41
Figura 54. Pitch bend. Obtenido de (Midi Association, 2009) ....................................... 42
Figura 55. Estructura de un archivo (.mid). Obtenido de (Carleton, 2013) .................... 44
Figura 56. Matriz binaria (uno) ...................................................................................... 45
Figura 57. Archivo (.mid) manipulado con Mido .......................................................... 46
Figura 58. Archivo (.mid) manipulado con Magenta ..................................................... 46
Figura 59. Código del método midiToMatrix ................................................................ 47
Figura 60. Código del método matrixToMidi ................................................................ 48
Figura 61. Matriz binaria (dos) cuatro filas por tiempo ................................................. 49
Figura 62. Matriz binaria (tres) ocho filas por tiempo ................................................... 49
Figura 63. Partitura de un ritmo de batería ..................................................................... 50
Figura 64. División del conjunto de entrenamiento por tiempo ..................................... 50
Figura 65. División del conjunto de entrenamiento por compás .................................... 51
Figura 66. Código para dividir al conjunto de entrenamiento por tiempo o compás ..... 52
Figura 67. Figura 67. División del conjunto de entrenamiento en n tiempos (iteración 1)
........................................................................................................................................ 53
Figura 68. División del conjunto de entrenamiento en n tiempos (iteración 2) ............. 53
Figura 69. División del conjunto de entrenamiento en n tiempos (ultima iteración) ..... 53
Figura 70. Código para dividir al conjunto de entrenamiento por n tiempos ................. 54
Figura 71. Aplanamiento de los datos de entrada ........................................................... 54
Figura 72. Código de los algoritmos (DT, RF Y MLP) ................................................. 55
Figura 73. Código de la red neuronal recurrente (LSTM) .............................................. 55
Figura 74. Código de la red neuronal convolucional (CNN) ......................................... 56
Figura 75. Código para generar nuevos ritmos de batería con los modelos (DT, RF y
MLP) ............................................................................................................................... 57
Figura 76. Ritmo generado con MLP ............................................................................. 57
Figura 77. Estructura de la aplicación en el lado del servidor ........................................ 58
Figura 78. Código para capturar los datos enviados desde el lado del cliente ............... 59
Figura 79. Estructura del diseño de la aplicación ........................................................... 59
Figura 80. Tríada de colores ........................................................................................... 60
Figura 81. Título de la aplicación ................................................................................... 60
xii
Figura 82. Barra de navegación de la aplicación ............................................................ 60
Figura 83. Botón para subir archivos ............................................................................. 60
Figura 84. Selección del modelo .................................................................................... 60
Figura 85. División de cada tiempo ................................................................................ 61
Figura 86. Dividir por tiempo o compás......................................................................... 61
Figura 87. Cuadro de ventana libre ................................................................................ 61
Figura 88. Cuadro de duración de los nuevos ritmos ..................................................... 61
Figura 89. Cuadro de épocas de entrenamiento .............................................................. 61
Figura 90. Botón comenzar ............................................................................................ 61
Figura 91. Sección de resultados .................................................................................... 61
Figura 92. Características del servidor ........................................................................... 62
Figura 93. Matriz binaria DT - 2.mid ............................................................................. 63
Figura 94. Matriz binaria RF - 5.mid.............................................................................. 63
Figura 95. Matriz binaria MLP - 5.mid - 1.000 Épocas de entrenamiento .................... 64
Figura 96. Matriz binaria MLP - 5.mid - 10.000 Épocas de entrenamiento .................. 64
Figura 97. Matriz binaria LSTM - 3.mid - 1.000 Épocas de entrenamiento .................. 65
Figura 98. Matriz binaria LSTM - 3.mid - 10.000 Épocas de entrenamiento ................ 65
Figura 99. Matriz binaria LSTM - 2.mid - 100 Épocas de entrenamiento ..................... 66
Figura 100. Matriz binaria LSTM - 2.mid - 1000 Épocas de entrenamiento ................. 66
Figura 101. Matriz binaria CNN - 5.mid - 1000 Épocas de entrenamiento ................... 67
Figura 102. Matriz binaria CNN - 5.mid - 10.000 Épocas de entrenamiento ................ 67
Figura 103. Matriz binaria CNN - 2.mid - 100 Épocas de entrenamiento ..................... 68
Figura 104. Matriz binaria CNN - 2.mid - 1000 Épocas de entrenamiento ................... 68
Figura 105. Partitura del resultado con árbol de decisión .............................................. 79
Figura 106. Partitura del resultado con bosque aleatorio ............................................... 80
Figura 107. Partitura del resultado con MLP ................................................................. 80
Figura 108. Partitura del resultado con LSTM ............................................................... 81
Figura 109. Partitura del resultado con CNN ................................................................. 82
xiii
TÍTULO: Desarrollo de una aplicación para generar ritmos de batería a través de técnicas
relacionadas con aprendizaje automático
Autor: Oña Játiva Martín Patricio
Tutor: Ing. Zoila de Lourdes Ruiz Chávez
RESUMEN
El presente proyecto consiste en generar ritmos de batería en formato MIDI a través de
técnicas relacionadas con aprendizaje automático, tales como: árboles de decisión,
bosques aleatorios, perceptrón multicapa, redes neuronales convolucionales y redes
neuronales recurrentes, implementados con el lenguaje de programación Python. La
aplicación web “DrumML” desarrollada con Django en el lado del servidor permite al
usuario entrenar los modelos mencionados anteriormente con diferentes conjunto de datos
de entrenamiento, variar los parámetros de la aplicación como: modelo a utilizar, dividir
al conjunto de entrenamiento por tiempo, compas o ventana libre (n tiempos), definir la
duración, de igual manera la cantidad de los nuevos ritmos a generar los cuales parten de
una semilla aleatoria inicial y establecer el número de épocas de entrenamiento para los
modelos adecuados.
PALABRAS CLAVE: APRENDIZAJE AUTOMÁTICO/ PYTHON/ RITMOS DE
BATERÍA/ DESARROLLO WEB/ DJANGO
xiv
TITLE: Development of an application to generate drum rhythms through techniques
related to machine learning.
Author: Oña Játiva Martín Patricio
Tutor: Ing. Zoila de Lourdes Ruiz Chávez
ABSTRACT
The present project consists of generating drum rhythms in MIDI format through
techniques related to machine learning, such as: decision trees, random forests, multilayer
perceptron, convolutional neural networks and recurrent neural networks, implemented
with the Python programming language. The server-side "DrumML" web application
developed with Django allows the user to train the above mentioned models with different
training data sets, to vary the application parameters such as: model to be used, divide the
training set by time, compas or free window (n times), to define the duration, as well as
the amount of new rhythms to be generated which start from an initial random seed and
to establish the number of training times for the appropriate models.
KEYWORDS: MACHINE LEARNING/ PYTHON/ DRUM RHYTHMS/ WEB
DEVELOPMENT/ DJANGO
1
CAPÍTULO I
1. PLANTEAMIENTO DEL PROBLEMA
1.1 ANTECEDENTES
El aprendizaje automático es una de las ramas de la inteligencia artificial que más se ha
abordado en los últimos años. Ha tenido participación en diversas actividades como la
extracción de conocimiento, análisis de datos, motores de búsqueda, robótica, generación
de contenido, etc.
Es ampliamente utilizado en diversos campos de estudio, como medicina, marketing,
estudios ambientales, entre otros. También se ha incursionado en el uso de herramientas
de aprendizaje automático en el ámbito artístico, más específicamente en la rama musical.
Combinar dos ramas como son las ciencias y el arte, permite crear nuevas aplicaciones
utilizando los avances tecnológicos en ámbitos que no son usualmente analizados. A
partir de este hecho se realizó un análisis de trabajos dentro de esta temática, describiendo
a continuación los enfocados a la generación de música mediante técnicas relacionadas
con aprendizaje automático:
En el artículo POLYPHONIC MUSIC GENERATION BY MODELING TEMPORAL
DEPENDENCIES USING A RNN-DBN, se propone una técnica genérica para modelar
dependencias temporales y secuencias utilizando combinaciones diferentes de redes
neuronales, entre ellas una red neuronal recurrente (RNN) y una red neuronal de creencias
profundas (DBN). La RNN le permite proporcionar información temporal mientras que
la DBN multicapa ayuda en la representación de alto nivel en los datos. Se aplica esta
técnica para la generación de música polifónica (Goel, Vohra, & Sahoo, 2014).
Mediante la investigación SONG FROM PI: A MUSICALLY PLAUSIBLE NETWORK
FOR POP MUSIC GENERATION. Se plantea un marco novedoso para la generación de
música pop, el modelo es una arquitectura de red neuronal recurrente jerárquica, donde
las capas y la estructura codifican el conocimiento previo sobre cómo se compone la
música pop. Las capas inferiores generan la melodía mientras que las capas superiores
son las encargadas de producir los acordes y tambores (Chu, Urtasun, & Fidler, 2016).
2
En el trabajo MIDINET: A CONVOLUTIONAL GENERATIVE ADVERSARIAL
NETWORK FOR SYMBOLIC-DOMAIN MUSIC GENERATION, se explora el uso de
redes neuronales convolucionales (CNN) para generar melodías (series de notas MIDI).
Además del generador, utilizan un discriminador que aprende las distribuciones de las
melodías, obteniendo una red generativa adversaria (GAN), de modo que el modelo puede
generar melodías desde cero, siguiendo una secuencia de acordes o mediante la melodía
de compases anteriores. El modelo resultante se puede ampliar para la generación de
música con múltiples canales MIDI (varias pistas) (Yang, Chou, & Yang, 2017).
El trabajo de investigación LEARNING TO GROOVE WITH INVERSE SEQUENCE
TRANSFORMATIONS, exploran modelos para producir ideas musicales abstractas
(partituras y ritmos), utilizando modelos como Seq2Seq y Variational Information
Bottleneck (VIB). Se muestra que es posible adaptar un enfoque de la red neuronal
generativa adversaria (GAN) a las secuencias, creando volúmenes de datos emparejados
realizando transformaciones simples y entrenando modelos generativos para invertir estas
trasformaciones de manera plausible. La batería proporciona un caso de prueba sólido
para este enfoque porque muchas trasformaciones comunes (cuantización, eliminación de
voces) tienen una semántica clara (Gillick, Roberts, Engel, Eck, & Bamman, 2019).
1.2 FORMULACIÓN DEL PROBLEMA
El uso de técnicas relacionadas con aprendizaje automático para la generación de ritmos
de batería, no ha sido ampliamente explorado dentro del ámbito musical en temas
referentes a investigación, por lo tanto, el propósito de este trabajo es explorar y combinar
las dos áreas y mediante los resultados obtenidos contribuir con bases para incursionar en
este tipo de enfoques que permiten investigaciones multidisciplinarias.
Por lo tanto, se pretende corroborar que los algoritmos de aprendizaje automático son
capaces, no solo de procesar información alfanumérica, imágenes o videos, sino también,
producir nuevos ritmos de batería, de diferente duración y con patrones rítmicos distintos,
proporcionando nuevas ideas creativas.
1.3 DESCRIPCIÓN DEL PROBLEMA
Para plantear una posible solución a un problema utilizando aprendizaje automático, es
indispensable tener los conocimientos sobre el funcionamiento de los diferentes
3
algoritmos, sus elementos, requerimientos y el formato que deben tener los conjuntos de
entrenamiento. Adicional, se debe contar con conocimientos sólidos en áreas como las
matemáticas, programación y música, siendo esta última la que provee los conceptos base
referente al ritmo para así implementar la lógica de los modelos elaborados en este
proyecto integrador. Emplear aprendizaje automático permite generar contenido nuevo
creado por ordenador a partir de contenido existente.
Por otro lado, en la actualidad las aplicaciones que se ejecutan en un navegador tienen
gran popularidad, debido a la facilidad de acceso del usuario a un computador con
internet. Por ello se ha implementado la visualización del proyecto en la Web. En el
presente proyecto luego de un análisis de herramientas se ha escogido el lenguaje de
programación Python, siendo este uno de los lenguajes más populares en el área del
aprendizaje automático gracias a la gran cantidad de librerías con las que cuenta, además
de la variedad de ejemplos existentes, su extensa documentación y una gran comunidad
activa.
Para poder implementar Python en el lado servidor se ha empleado el framework Django,
que ofrece un desarrollo rápido.
1.4 JUSTIFICACIÓN
Ante los grandes avances de la Inteligencia Artificial especialmente en el área del
Aprendizaje Automático se busca combinar las artes musicales con las ciencias de la
computación, en efecto, es de gran interés conocer el comportamiento de los modelos de
aprendizaje automático en un ámbito distinto a los habituales, en este caso particular en
la generación de ritmos de batería.
El presente proyecto integrador nace de la experiencia de trabajar con algoritmos de IA
en la rama profesional y la pasión personal por la música. De ahí nace la interrogante: ¿Es
posible combinar exitosamente modelos de Aprendizaje Automático con la generación
de ritmos de batería? Toda investigación nace de una idea o una interrogante, es así que
se planteó el presente proyecto integrador.
Los resultados se presentan de forma visual mediante una aplicación web de nombre
“DrumML”, que es accesible desde el navegador para aquellas personas que deseen
involucrase en el aprendizaje automático con un enfoque musical. Como estudiante de la
4
carrera de Ingeniería en Computación Gráfica y estudiante de batería, por hobby, se
abarca este tema para mostrar que es posible incursionar en nuevas aplicaciones de
aprendizaje automático, y que es factible realizarlo con el conocimiento adquirido.
1.5 OBJETIVOS
1.5.1 OBJETIVO GENERAL
Desarrollar una aplicación que permita generar ritmos de batería a través de
técnicas relacionadas con aprendizaje automático.
1.5.2 OBJETIVOS ESPECÍFICOS
Implementar distintos modelos de aprendizaje automático tales como árboles de
decisión, bosques aleatorios, perceptrón multicapa, red neuronal convolucional y
red neuronal recurrente.
Emplear el Framework Django en el lado del servidor e implementar una interfaz
gráfica en el lado del cliente para el funcionamiento de la aplicación.
Comparar los resultados obtenidos con los distintos modelos de aprendizaje
automático y conjuntos de entrenamiento.
1.6 ALCANCE
Al contar con una gran variedad de instrumentos musicales, la aplicación “DrumML” está
enfocada a la generación de ritmos de batería, la misma que consta de varias vistas, una
por cada modelo. Donde el usuario puede experimentar con sus propios conjuntos de
entrenamiento con archivos MIDI, definir cuantos ritmos nuevos se va a generar así como
su duración, el tamaño de la matriz, la misma que indica la división en cada tiempo
(cuatro, ocho o dieciséis filas), escoger entre dividir al conjunto de entrenamiento por
tiempo, compas o ventana libre (n tiempos) y las épocas de entrenamiento para los
modelos como el perceptrón multicapa, red neuronal convolucional y red neuronal
recurrente.
5
1.7 LIMITACIONES
Hablar de aprendizaje automático es sinónimo de una gran cantidad de coste
computacional, por esa razón se ha optado por utilizar archivos MIDI como formato
idóneo para el conjunto de entrenamiento.
Consecuentemente el servidor en donde se encuentra alojada la aplicación “DrumML” es
de características mínimas (1 GB Memoria / 25 GB Disco), debido a los costes de
alojamiento en la nube, por lo que con conjuntos de entrenamiento demasiados grandes
le tomará a la aplicación demasiado tiempo entrenar, procesar y mostrar los resultados.
La aplicación no permite entrenar a los modelos de aprendizaje automático con ritmos
que cambien de compás o de tempo en el transcurso del tiempo.
Los archivos MIDI que se utilizan como conjunto de entrenamiento deben contener una
sola pista en donde se encuentre todas las partes de la batería.
6
CAPÍTULO II
2. MARCO TEÓRICO
2.1 ASPECTOS TEÓRICOS
La elaboración de la aplicación “DrumML” se basó en tres áreas de conocimiento:
aprendizaje automático, desarrollo web y música (ritmo).
2.2 ALGUNOS CONCEPTOS DE INTELIGENCIA ARTIFICIAL
A lo largo del siglo XX se han definido varios conceptos de inteligencia artificial, esto
debido a que se estudia desde cuatro enfoques diferentes, los dos primeros: sistemas que
piensan como humanos y sistemas que piensan racionalmente, aluden al razonamiento y
a procesos mentales, mientras que los sistemas que actúan como humanos y aquellos
sistemas que actúan racionalmente apuntan a la conducta (Norving & Russell, 2004).
Tabla 1. Algunas definiciones de inteligencia artificial. Obtenido de (Norving & Russell, 2004)
Se toma en cuenta el enfoque: sistemas que actúan como humanos, porque a través de la
prueba de Turing se puede determinar el punto de partida del Aprendizaje Automático.
2.2.1 PRUEBA DE TURING
La prueba o test de Turing creada por Alan Turing, consiste en un juego con tres
participantes, de los cuales dos son seres humanos y el último es un computador. La
7
dinámica consiste en que el primer participante (ser humano) realiza preguntas a los otros
dos participantes (ser humano y computador respectivamente), con la finalidad de decidir
cuál de estos dos participantes es el ser humano, si el ser humano a cargo de realizar las
peguntas no es capaz de determinar cuál de los participantes es humano, entonces se
determina que una computadora es inteligente (Taulli, 2019).
Figura 1. Prueba de Turing. Obtenido de (Taulli, 2019)
En la actualidad, una máquina que pueda superar la prueba de Turing debe contar con
varias capacidades tales como: procesamiento de lenguaje natural, representación del
conocimiento, razonamiento automático y aprendizaje automático. La prueba de Turing
evadió la interacción física entre el participante encargado de hacer las preguntas y el
computador. Posteriormente, la prueba global de Turing integra señal de video que
permite al participante encargado de hacer las preguntas, evaluar la capacidad de
percepción; para superar la prueba, la máquina debe contar con las dos características
siguientes: visión computacional y robótica, debido a que estas disciplinas forman la
mayor parte de las ramas de Inteligencia Artificial (Norving & Russell, 2004).
Figura 2. Ramas de la Inteligencia Artificial
Entre las ramas de la inteligencia artificial, se destaca el Aprendizaje Automático debido
a que representa la parte principal del presente trabajo integrador.
8
2.3 APRENDIZAJE AUTOMÁTICO
Aprendizaje automático es un término que en la actualidad ha tenido gran renombre y al
cual se le atribuyen varias definiciones.
Una de las definiciones de Aprendizaje Automático establece que es un conjunto de
técnicas y herramientas para crear sistemas computacionales que aprendan de los datos
para poder hacer predicciones (Swamynathan, 2017).
Otra definición establecida en el año 1959 por Arthur Samuel pionero en el área de juegos
de computadoras e inteligencia artificial, la define como un campo de estudio en donde
los computadores son capaces de aprender sin ser explícitamente programadas
(Swamynathan, 2017).
Pero no fue hasta 1997 que Tom Mitchell estableció la definición formal de aprendizaje
automático y la define de la siguiente manera: “Aprendizaje Automático es un programa
de computador que aprende de la experiencia E, respecto a alguna tarea T y con medida
de rendimiento P, si el desempeño sobre la tarea T, medido por P, mejora la experiencia
en E”.
2.3.1 PARADIGMA DE PROGRAMACIÓN TRADICIONAL Y DE
APRENDIZAJE AUTOMÁTICO
Los paradigmas de programación tradicionales, implican básicamente un programador
para escribir un conjunto de instrucciones u operaciones utilizando un determinado
lenguaje de programación que hace que la computadora funcione (Sarkar, Bali, &
Sharma, 2018).
Figura 3. Paradigma de programación tradicional. Obtenido de (Kashyap, 2018)
El paradigma de aprendizaje automático trata de tener en cuenta un conjunto de datos con
los resultados esperados, si los hay, usar la computadora para realizar el programa
conocido como modelo, el mismo que a futuro proporcionara resultados de las nuevas
entradas (Sarkar, Bali, & Sharma, 2018).
9
Figura 4. Paradigma de aprendizaje automático. Obtenido de (Kashyap, 2018)
2.3.2 ELEMENTOS DEL APRENDIZAJE AUTOMÁTICO
2.3.2.1 DATOS
Todos los modelos de aprendizaje automático se basan en datos o también llamados
conjunto de entrenamiento, el mismo que se utiliza para entrenar a los modelos. Estos
pueden ser recolectados y manipulados por humanos o ser recopilados de forma
automática por herramientas de software (Paluszek & Thomas, 2019).
2.3.2.2 MODELOS
Los modelos se utilizan en los sistemas de aprendizaje proporcionando un marco
matemático. Estos pueden ser de origen humano, basándose en experiencias y
observaciones humanas, sin embargo, algunas técnicas de aprendizaje automático
desarrollan sus propios modelos sin una estructura de origen humano (Paluszek &
Thomas, 2019).
2.3.2.3 ENTRENAMIENTO
Con similitud a los seres humanos que a través del entrenamiento aprenden a realizar
tareas, los modelos de aprendizaje automático necesitan ser entrenados. El entrenamiento
se realiza ingresando al sistema un conjunto de datos de entrada para que posteriormente
la máquina pueda hacer alguna predicción (Paluszek & Thomas, 2019).
Figura 5. Proceso de Aprendizaje (vertical) e inferencia (horizontal). Obtenido de (Kim, 2017)
10
2.3.3 TIPOS DE APRENDIZAJE AUTOMÁTICO
Se dividen principalmente en tres grupos, que a su vez se subdividen de la siguiente
manera:
Figura 6. Tipos de Aprendizaje Automático
Dentro del presente proyecto integrador se utilizará Aprendizaje Supervisado para
conocer la predicción de notas que se activan y desactivan en las distintas partes de la
batería.
2.3.3.1 APRENDIZAJE SUPERVISADO
Es un proceso de aprendizaje, en donde los datos de entrada cuentan con su respectiva
etiqueta (variable de salida), es decir, se sabe lo que se intenta predecir (Kashyap, 2018).
2.3.3.1.1 CLASIFICACIÓN
El resultado a predecir es una clase en particular y puede haber dos o más clases como
datos de salida. Un ejemplo de este caso es el filtrado de correo electrónico, en el que el
resultado a clasificar es un correo electrónico como “correo deseado” o “correo no
deseado” (Swamynathan, 2017).
2.3.3.1.2 REGRESIÓN
El resultado a predecir es un valor continuo en relevancia con un determinado conjunto
de datos de entrada. Un ejemplo de este caso es la predicción del precio de alguna
vivienda según su dimensión de lote (Swamynathan, 2017).
11
2.3.2.2 APRENDIZAJE NO SUPERVISADO
Al contrario del aprendizaje supervisado en este caso no se conoce el resultado o etiqueta
de los datos de entrada. El objetivo es encontrar patrones similares en los datos de entrada
para posteriormente agruparlos en clases específicas (Swamynathan, 2017).
2.3.3.3 APRENDIZAJE POR REFUERZO
El objetivo es desarrollar un sistema (agente) que mejore su rendimiento basado en las
interacciones con el medio ambiente (Raschka & Mirjalili, 2019). Este tipo de aprendizaje
es utilizado especialmente en el área de los videojuegos.
2.4 ALGORITMOS DE APRENDIZAJE AUTOMÁTICO
Para la realización del presente proyecto integrador se ha tomado en cuenta algunas
técnicas relacionadas con aprendizaje automático que se describen a continuación:
2.4.1 ÁRBOLES DE DECISIÓN (DECISION TREE - DT)
Este algoritmo toma como entrada un objeto o una situación descrita a través de un
conjunto de atributos y devuelve una decisión (valor previsto de la salida dada la entrada).
Los atributos de entrada y salida pueden ser discretos o continuos (Norving & Russell,
2004).
El objetivo de este algoritmo es obtener un modelo que pueda predecir resultados basados
en reglas de decisión, las mismas que se basan en los atributos (Sarkar, Bali, & Sharma,
2018).
2.4.1.1 COMPONENTES DEL ÁRBOL DE DECISIÓN
Componentes del árbol de decisión
Nodo raíz Es el nodo que representa a todo el árbol,
y se divide en dos o más sub-nodos.
Dividir Proceso de división de un nodo basado en
cierta regla.
Nodo de decisión Cuando un sub-nodo se divide en más
sub-nodos.
Hoja Nodo final.
Poda Proceso de eliminación de sub-nodos en
un nodo de decisión.
12
Rama Es una sub-sección de un árbol entero.
Tabla 2. Árbol de decisión
Figura 7. Componentes del árbol de decisión. Obtenido de (Ayyadevara, 2018)
2.4.1.2 ID3
El algoritmo ID3 construye un árbol de decisión de tamaño pequeño, con el menor
número de nodos posibles para poder encontrar la salida correcta. Para ello usa el
concepto de ganancia de información para la selección del atributo con más relevancia en
cada paso. Para entender cómo se mide la ganancia de información hay que definir el
criterio de entropía que mide el grado de incertidumbre de una muestra (Caparrini, 2019).
A continuación, se describe un ejemplo:
Figura 8. Datos para predecir un árbol de decisión, resultado final del árbol de decisión. Obtenido de (Sayad, 2010)
Para obtener el árbol de decisión descrita en la Figura 8, se procede a calcular la entropía
del sistema, tomando en cuenta si se juega o no al golf:
𝑬(𝑺) = ∑ −𝒑𝒊𝒍𝒐𝒈𝟐(𝒑𝒊)𝑪
𝒊=𝟏
13
Figura 9. Cálculo de la entropía del sistema. Obtenido de (Sayad, 2010)
Se calcula la entropía asociada a los atributos de los datos de entrada, para este caso se
calcula la entropía para el atributo Outlook:
𝑬(𝑻, 𝑿) = ∑ 𝑷(𝒄)𝑬(𝒄)
𝒄∈𝑿
Figura 10. Cálculo de la entropía con respecto al atributo Outlook. Obtenido de (Sayad, 2010)
Se obtiene la ganancia de información:
𝑮𝒂𝒊𝒏(𝑻, 𝑿) = 𝑬𝒏𝒕𝒓𝒐𝒑𝒚(𝑻) − 𝑬𝒏𝒕𝒓𝒐𝒑𝒚(𝑻, 𝑿)
Figura 11. Cálculo de la ganancia de información. Obtenido de (Sayad, 2010)
Se escoge al atributo con mayor ganancia de información como nodo decisión. Al nodo
que tenga como entropía nula se convierte en nodo respuesta (hoja), mientras que un nodo
con entropía superior a cero necesita más divisiones. El algoritmo ID3 se ejecuta
14
recursivamente en nodos que no sean hojas hasta que todos los datos se clasifiquen
(Sayad, 2010).
2.4.2 BOSQUES ALEATORIOS (RANDOM FOREST - RF)
Los bosques aleatorios, conocido por sus siglas en inglés como Random Forest, son
combinaciones de varios árboles de decisión, de manera que cada árbol de decisión puede
considerarse único respecto de los demás en cuanto a las características que evalúa en una
rama determinada. Aunque la longitud de estos árboles es homogénea, la decisión de cada
árbol es independiente de los demás. El valor que elegimos para una observación
determinada suele ser el valor medio con respecto a todos los árboles en el caso de la
regresión, o es la observación media (o más frecuente) con respecto a todos los árboles
de la clasificación (Beysolow II, 2017). El término aleatorio se refiere al muestreo
aleatorio de datos del conjunto de enteramiento y bosque se refiere a la construcción de
varios árboles de decisión, uno por cada muestra aleatoria de datos (Ayyadevara, 2018).
BAGGING (BOOTSTRAP AGGREGATION)
El término “bootstrap” se refiere a la selección aleatoria de filas (del conjunto de
entrenamiento), y “agregación” al promedio de las predicciones de todos los árboles de
decisión que se construyen sobre la muestra del conjunto de entrenamiento seleccionadas
aleatoriamente (Ayyadevara, 2018).
Figura 12. Bagging. Obtenido de (Swamynathan, 2017)
15
2.4.3 REDES NEURONALES ARTIFICIALES (ARTIFICIAL NEURAL
NETWORK - ANN)
Una red neuronal artificial es un sistema de procesamiento de información inspirada en
las redes neuronales biológicas tanto en estructura como en funcionamiento (Hilera
González & Martínez Hernando, 2000).
Figura 13. Neurona Artificial. Obtenido de (Pacheco, 2017)
Para conocer la definición formal de neurona artificial (perceptrón) se ha tomado en
cuenta una tarea de clasificación binaria en la que se trabaja con dos clases como: 1 (clase
positiva) y -1 (clase negativa). Se define una función de decisión (∅(𝒛)) , donde z es la
combinación lineal con los valores de entrada x y el vector de pesos w.
𝐰 = [
𝒘𝟏...
𝒘𝒎
] ; 𝐱 = [
𝒙𝟏...
𝒙𝒎
] ; 𝒛 = 𝒘𝟏𝒙𝟏 + ⋯ + 𝒘𝒎𝒙𝒎
Ahora, si para algún valor en particular 𝒙(𝒊) es mayor que el valor definido en el umbral
𝜽, se predice la clase 1 y la clase -1 caso contrario.
∅(𝒛) = {𝟏 𝒔𝒊 𝒛 ≥ 𝜽
−𝟏 𝒄𝒂𝒔𝒐 𝒄𝒐𝒏𝒕𝒓𝒂𝒓𝒊𝒐
Ahora por simplicidad, 𝒘𝟎 = −𝜽 (unit bias) y 𝒙𝟎 = 𝟏, por lo que se tiene:
𝒛 = 𝒘𝟎𝒙𝟎 + 𝒘𝟏𝒙𝟏 + ⋯ + 𝒘𝒎𝒙𝒎 = ∑ 𝒙𝒋𝒘𝒋
𝒎
𝒋=𝟎= 𝒘𝑻𝒙
Por lo tanto:
16
∅(𝒛) = {𝟏 𝒔𝒊 𝒛 ≥ 𝟎
−𝟏 𝒄𝒂𝒔𝒐 𝒄𝒐𝒏𝒕𝒓𝒂𝒓𝒊𝒐
La regla de aprendizaje del perceptrón se basa en los siguientes pasos:
1. Inicializar los valores de los pesos w a cero o a valores aleatorios muy pequeños.
2. Para cada muestra de entrenamiento 𝒙(𝒊):
- Calcular el valor de salida yˆ.
- Actualizar los pesos.
𝒘𝒋 ≔ 𝒘𝒋 + ∆𝒘𝒋
∆𝒘𝒋 = 𝛈(𝒚(𝒊) − 𝒚ˆ(𝐢))𝒙𝒋(𝒊)
Donde 𝛈 es la tasa de aprendizaje (comúnmente una constante entre 0.0 y 1.0), 𝒚(𝒊) es la
clase de la i-ésima muestra de entrenamiento y 𝒚ˆ(𝐢) es la clase calculada por el
perceptrón.
Figura 14. Perceptrón. Obtenido de (Raschka & Mirjalili, 2019)
Años más adelante se publica por Bernard Widrow y Tedd Hoff otro tipo de neurona
artificial (Adaline – ADAptive LInear NEuron), considerada como una mejora del
algoritmo del perceptrón de Frank Rosenblatt. La principal diferencia entre el algoritmo
adaline y el perceptrón es que los pesos se actualizan en base a una función de activación
lineal (en este caso función identidad).
∅(𝒛) = 𝒛
17
Figura 15. Adaline. Obtenido de (Raschka & Mirjalili, 2019)
Uno de los puntos clave de los algoritmos de aprendizaje automático supervisado, es la
optimización de la función de pérdida mediante el proceso de aprendizaje. Para el caso
del algoritmo adaline se utiliza la función de pérdida siguiente:
𝑱(𝑾) =𝟏
𝟐∑ (𝒚(𝒊) − ∅(𝒛(𝒊)))𝟐
𝒊
La regla de aprendizaje de este algoritmo mediante el algoritmo del descenso del
gradiente está establecida de la siguiente manera:
𝒘 ≔ 𝒘 + ∆𝒘
∆𝒘 = −𝛈𝛁𝑱(𝒘)
∆𝒘𝒋 = −𝛈∂J
∂𝑤𝑗= 𝛈 ∑(𝒚(𝒊) − ∅(𝒛(𝒊)))𝒙𝒋
(𝒊)
𝒊
Donde ∆𝒘 se define como el gradiente negativo multiplicado por la tasa de aprendizaje
𝛈 (Raschka & Mirjalili, 2019).
Figura 16. Descenso del gradiente. Obtenido de (Raschka & Mirjalili, 2019)
18
2.4.3.1 PERCEPTRÓN MULTICAPA (MULTILAYER PERCEPTRON – MLP)
El perceptrón multicapa (MLP) es un típico ejemplo de redes neuronales artificiales
feedfoward, que contiene al menos una capa oculta distinta de la capa de entrada y salida
(Manaswi, Manaswi, & John, 2018).
El termino feedfoward se refiere al hecho de que cada capa sirve como entrada a la
siguiente capa sin bucles. Hay que tener en cuenta que las neuronas artificiales que
componen al perceptrón multicapa son unidades sigmoides (regresión logística) y no
perceptrones (Raschka & Mirjalili, 2019).
∅(𝐳) =𝟏
𝟏 + 𝐞−𝐳
MLP utiliza diferentes funciones de pérdida 𝑱(𝑾) según el tipo de problema.
Figura 17. Perceptrón multicapa (fully connected). Obtenido de (Raschka & Mirjalili, 2019)
Cálculo de los valores de la capa oculta y capa de salida respectivamente:
𝒁(𝒉) = 𝑨(𝒊𝒏)𝑾(𝒉) , 𝑨(𝒉) = ∅(𝒁(𝒉)) ; 𝒁(𝒐𝒖𝒕) = 𝑨(𝒉)𝑾(𝒐𝒖𝒕) , 𝑨(𝒐𝒖𝒕) = ∅(𝒁(𝒐𝒖𝒕))
Para la actualización de los valores de los pesos comúnmente se utiliza el algoritmo de
propagación hacia atrás, descrito a continuación:
1. Inicializar los pesos mediante el muestreo de la distribución normal.
2. Cálculo de los valores de la capa oculta y capa de salida.
3. Cálculo del gradiente y actualización de los pesos desde la capa oculta a la capa
de entrada.
4. Repetir los dos pasos anteriores hasta que el algoritmo haya alcanzado las
iteraciones máximas (Beysolow II, 2017).
19
Figura 18. Propagación hacia atrás. Obtenido de (Raschka & Mirjalili, 2019)
2.4.3.2 REDES NEURONALES CONVOLUCIONALES (CONVOLUTIONAL
NEURAL NETWORK - CNN)
Las redes neuronales convolucionales están inspiradas en cómo funciona la corteza visual
del cerebro humano al reconocer objetos: debido a su destacado rendimiento en tareas
que incluyan la clasificación de imágenes, ha conducido a múltiples mejoras en el área
del aprendizaje automático y en las respectivas aplicaciones de visión por computador
(Raschka & Mirjalili, 2019).
Este tipo de redes neuronales se caracteriza por tener en su arquitectura tres tipos de capas.
Capa de convolución: es el componente principal de las redes neuronales
convolucionales, consiste en un conjunto de filtros que ayudan a capturar
características de la imagen y por lo general son de un tamaño bastante pequeño
(Sarkar, Bali, & Sharma, 2018).
La definición matemática de la convolución en una dimensión está dada de la
siguiente manera:
𝒚 = 𝒙 ∗ 𝒘 → 𝒚[𝒊] = ∑ 𝒙[𝒊 − 𝒌]𝒘[𝒌]
+∞
𝒌=−∞
Donde 𝒙 es la entrada o también denominado señal y 𝒘 es el núcleo o filtro.
Supongamos que la entrada 𝒙 y el filtro 𝒘 tienen dimensiones de 𝒎 y 𝒏
20
respectivamente, donde 𝒎 <= 𝒏. Por lo tanto, el vector 𝒙𝒑 (padded) tiene
dimensión 𝒏 + 𝟐𝒑 (Raschka & Mirjalili, 2019).
𝒚 = 𝒙 ∗ 𝒘 → 𝒚[𝒊] = ∑ 𝒙𝒑[𝒊 + 𝒎 − 𝒌]𝒘[𝒌]
𝒌=𝒎−𝟏
𝒌=𝟎
Figura 19. Ejemplo de convolución (p=0). Obtenido de (Raschka & Mirjalili, 2019)
Hay tres formas diferentes de relleno (padding) en la convolución. A
continuación, se muestra una imagen de las tres formas (Full padding, Same
padding y Valid padding).
Figura 20. Formas de relleno en la convolución. Obtenido de Obtenido de (Raschka & Mirjalili, 2019)
La definición matemática de la convolución en dos dimensiones está dada de la
siguiente manera:
21
𝒀 = 𝑿 ∗ 𝑾 → 𝒀[𝒊, 𝒋] = ∑ ∑ 𝑿[𝒊 − 𝒌𝟏, 𝒋 − 𝒌𝟐]𝑾[𝒌𝟏, 𝒌𝟐]
+∞
𝒌𝟐=−∞
+∞
𝒌𝟏=−∞
Figura 21. Resultado de la convolución 2D. Obtenido de Obtenido de (Raschka & Mirjalili, 2019)
Capa de agrupación (pooling): esta capa es responsable de reducir la
dimensionalidad y por lo tanto, reducir el conteo de parámetros para controlar el
tiempo de entrenamiento, la técnica utilizada con mayor frecuencia es la
agrupación máxima (max pooling), que toma el valor máximo de la matriz
(Gollapudi, 2019).
Figura 22. Ejemplo de max-pooling con dos matrices de entrada diferentes. Obtenido de (Raschka & Mirjalili, 2019)
Capa totalmente conectada: esta capa generalmente maneja redes neuronales
artificiales totalmente conectadas (conexiones completas con las neuronas de la
capa anterior), esta capa se encarga de realizar tareas de clasificación (Sarkar,
Bali, & Sharma, 2018).
22
Figura 23. Red neuronal convolucional. Obtenido de (Santamaría, Zuñiga, Pineda, Somodevilla, & Rossainz)
2.4.3.3 REDES NEURONALES RECURRENTES (RECURRENT NEURAL
NETWORK - RNN)
La red neuronal recurrente es similar al perceptrón multicapa, la diferencia consiste en
que las primeras cuentan con un ciclo de retroalimentación, lo que significa que el paso
actual se alimenta de la información del paso anterior. Por lo tanto, la capa oculta del paso
anterior y la salida de la retroalimentación se utiliza como entrada para la capa de los
siguientes pasos, permitiendo que la red prediga lo que sucederá a continuación
(Swamynathan, 2017).
Figura 24. Red neuronal recurrente. Obtenido de (Swamynathan, 2017)
2.4.3.3.1 LSTM (LONG SHORT-TERM MEMORY)
Es una arquitectura mejorada de las redes neuronales recurrentes, diseñada para mejorar
la memoria a través de celdas que se utilizan para controlar el flujo de información.
23
Figura 25. LSTM. Obtenido de (Swamynathan, 2017)
Puerta de entrada: decide que valores almacenar en la celda.
Puerta de olvido: decide qué información retirar de la celda.
Puerta de salida: crea un vector de valores que puede ser añadido a la celda
(Swamynathan, 2017).
2.5 FUNCIONES DE ACTIVACIÓN Y PÉRDIDA
A continuación se muestran algunas de las diferentes funciones de activación que se
utlizan en redes neuronales artificiales:
Función de activación Ecuación Ejemplo Gráfico
Linear
Adaline,linear
regression
Unit Step (Heaviside
Function)
Perceptron
variant
Sign (signum)
Perceptron
variant
Piece-wise Linear
Support vector
machine
24
Logistic (sigmoid)
Logistic
regression,
Multilayer NN
Hyperbolic Tangent
(tanh)
Multilayer NN,
RNNs
ReLU
Multilayer NN,
CNNs
Tabla 3. Funciones de activación. Obtenido de (Raschka & Mirjalili, 2019)
El uso de las funciones de pérdida no es único, por lo tanto, se menciona en la siguiente
tabla algunas de las más utilizadas:
Función de pérdida Ecuación
Raíz cuadrada media (RMSE)
Error absoluto medio (MAE)
Error absoluto medio escalado
(MASE)
Entropía cruzada categórica
Entropía cruzada binaria
Tabla 4. Funciones de pérdida (coste)
25
Debido a que la aplicación “DrumML” es considerada una aplicación web de ámbito
musical se mencionarán algunos conceptos básicos de desarrollo web y música.
2.6 DEFINICIÓN DE WEB
También conocida como World Wide Web, www o web, es un conjunto de documentos
que se encuentran conectados por enlaces de hipertexto (textos, gráficos, archivos de todo
tipo en el mismo documento), los cuales se encuentran disponibles en el internet y que
pueden comunicarse de manera digital (Latorre, 2018).
Las aplicaciones web han tomado mayor importancia desde la creciente popularidad de
la Internet en las últimas décadas, permitiendo acceso a las aplicaciones mediante
computadoras, tabletas o dispositivos móviles desde cualquier sitio con acceso a Internet
(Ferrer Martínez, 2012).
2.6.1 ARQUITECTURA CLIENTE SERVIDOR
La arquitectura cliente servidor es un modelo en donde las tareas se reparten entre los
proveedores de recursos o servicios conocidos como servidores, y los demandantes,
conocidos como clientes.
Desde este punto de vista se distinguen dos lados: la primera, referente al cliente
(considerado el usuario) que es quien puede utilizar la aplicación por medio de un
navegador que interactúa con la aplicación localizada al otro lado, en el servidor, donde
se encuentran los datos, reglas y lógica de la misma (Ferrer Martínez, 2012).
Figura 26. Cliente – Servidor. Obtenido de (Marini, 2012)
26
2.6.2 EL PATRÓN MVC
La arquitectura Modelo Vista Controlador es un patrón de diseño que especifica cómo
debe estar estructurada una aplicación, la capa intermedia de una aplicación web puede
estar dividida en tres partes: el controlador, la vista y el modelo (Sierra, 2007).
Figura 27. Esquema de una aplicación MVC. Obtenido de (Sierra, 2007)
El controlador: las peticiones que se realicen desde el cliente a la capa intermedia
son dirigidas al controlador, con el objetivo de determinar las acciones a realizar
e invocar al resto de los componentes.
La vista: encargada de generar las respuestas que se envía al cliente
El modelo: se encuentra lógica de negocio de la aplicación, permitiendo el acceso
y manipulación de los datos (Sierra, 2007).
2.6.3 PROTOCOLO HTTP
El Protocolo de transferencia de hipertexto es el más utilizado en la Internet, con el
propósito de permitir la transferencia de archivos entre un navegador (cliente) y un
servidor web localizado mediante una cadena de caracteres denominada dirección URL
(localizador uniforme de recursos) (Ferrer Martínez, 2012).
2.7 MÚSICA
Es el arte de organizar los sonidos con la finalidad de crear una determinada emoción en
el oyente (Herrera, 1998).
2.7.1 ELEMENTOS DE LA MÚSICA
Melodía: idea musical expresada por una sucesión de sonidos determinados.
27
Armonía: disciplina o ciencia musical, que indica reglas para elaborar y combinar los
acordes entre sí.
Ritmo: movimiento que surge de la sucesión de los sonidos, no existe obra musical sin
ritmo, por el contrario, puede existir ritmo sin sonido musical (Ingram, 2002).
2.7.2 FIGURAS MUSICALES
A continuación, se presenta una tabla con información sobre las figuras musicales.
Tabla 5. Figuras musicales. Obtenido de (Díaz, 2002)
2.7.3 SIGNOS DE NOTACIÓN MUSICAL
Pentagrama: es el conjunto de cinco líneas horizontales equidistantes, de manera que se
cuentan de abajo hacia arriba, y sirve para escribir música.
Figura 28. Pentagrama. Obtenido de (Díaz, 2002)
Clave de FA en cuarta línea: antiguamente la batería era identificada con esta clave, en
la actualidad se identifica con la llave rítmica.
Figura 29. Clave de fa. Obtenido de (Díaz, 2002)
28
Figura 30. Llave rítmica. Obtenido de (Díaz, 2002)
Compás: es la división regular del tiempo en partes de igual duración (2, 3 o 4 partes
generalmente). Se representa en forma de quebrado indicando el número de tiempos en
que se divide el compás (numerador) y las figuras que entran en él (denominador).
𝟒
𝟒
Figura 31. Compás 4/4
Líneas divisorias: líneas que separa a cada compás, se dibujan de manera vertical.
Figura 32. Líneas divisorias. Obtenido de (Díaz, 2002)
Tempo: indica la velocidad a la que debe ejecutarse una pieza o trozo musical (Díaz,
2002).
Figura 33. Tempo
2.8 ANÁLISIS DE LAS HERRAMIENTAS
2.8.1 ANACONDA NAVIGATOR
Es una interfaz gráfica de escritorio incluida en la distribución Anaconda (distribución de
Python y R), permitiendo administrar de manera sencilla entornos virtuales e iniciar
aplicaciones tales como: Jupyter Notebook, Spyder, VScode, RStudio entre otras
(Anaconda, 2020).
Figura 34. Logo de Anaconda. Obtenido de (Anaconda, 2020)
29
2.8.2 SPYDER
Spyder es un entorno de desarrollo integrado (IDE) escrito en Python para Python,
diseñado por y para científicos, ingenieros y analistas de datos (Spyder, 2018).
Figura 35. Logo de Spyder. Obtenido de (Spyder, 2018)
2.8.3 PYTHON
Python es un lenguaje de programación multiparadigma que incorpora los principios de
la filosofía que dicta: las tareas complejas se pueden realizar de maneras simples; creado
para tener una curva de aprendizaje y desarrollo rápido y sencillo, además de ser
considerado un lenguaje de programación de uso general permitiendo a los usuarios
trabajar en casi cualquier rama de estudio (Nagar, 2017).
Lenguaje de
programación
Ventajas Desventajas
Figura 36. Logo de
Python. Obtenido de
(Python, 2001)
Código abierto
Librerías disponibles para
aprendizaje automático (TensorFlow,
Pythorch, Keras, scikit-learn, etc.)
Fácil de aprender
Multiparadigma (orientada a objetos,
imperativa y funcional)
Multiplataforma
Es considerado un
lenguaje de
programación lento
Figura 37. Logo de
Matlab. Obtenido de
(Matlab, 1994)
Amplio soporte matemático y
funciones ya desarrolladas.
Es un lenguaje de programación
rápido (debido a su gran optimización
de algoritmos)
Es de uso comercial
30
Figura 38. Logo de
RStudio. Obtenido de
(RStudio, 2020)
Software libre
Multiplataforma
Código abierto
Ofrece gran cantidad de técnicas de
análisis de datos
Los gráficos disponibles en R son de
calidad.
R utiliza una consola de
comandos en lugar de
una interfaz gráfica
Curva de aprendizaje
alta
Tabla 6. Ventajas y desventajas (Python, Matlab y RStudio)
2.8.4 SCIKIT-LEARN
Es un módulo de Python que incorpora una variedad de algoritmos de aprendizaje
automático para resolver problemas de aprendizaje supervisado y no supervisado. Se
caracteriza por la facilidad de uso, rendimiento y por su amplia documentación
(Pedregosa, y otros, 2011).
Figura 39. Logo de Scikit-Learn. Obtenido de (scikit-learn, 2020)
2.8.5 KERAS
Es una API (Interfaz de programación de aplicaciones) de redes neuronales de alto nivel
escrito en Python permitiendo el desarrollo de modelos funcionales con menos de quince
líneas de código (Moolayil, Moolayil, & John, 2019).
Figura 40. Logo de Keras. Obtenido de (Keras, 2020)
2.8.6 MAGENTA
Es un proyecto de investigación de código abierto que explora el aprendizaje automático
como herramienta en el proceso creativo. Se distribuye como una biblioteca de código
31
abierto para Python permitiendo la manipulación de datos como imágenes y música
(Magenta, 2020).
Figura 41. Logo de Magenta. Obtenido de (Magenta, 2020)
2.8.7 VISUAL STUDIO CODE
Es un editor de código, ligero y potente que se ejecuta en el escritorio y se encuentra
disponible para distintas plataformas (Windows, macOS y Linux). Con soporte para
JavaScript, TypeScript y Node.js, e incluye extensiones para lenguajes como Python,
C++, PHP, entre otros (Visual Studio Code, 2020).
Figura 42. Logo de VScode. Obtenido de (Visual Studio Code, 2020)
2.8.8 DJANGO
Django es un framework web de código abierto para Python de alto nivel que incorpora
el desarrollo rápido y limpio (Django, 2005).
Framework web Características
Figura 43. Logo de Django.
Obtenido de (Django, 2005)
Funciona bajo el patrón MVC (Modelo Vista
Controlador), lo que lo caracteriza por ser
reutilizable y de desarrollo ágil.
Estructura de proyecto autogenerado permitiendo
la optimización de tiempo y código.
Cuenta con el panel de administración que
permite gestionar bases de datos.
32
Figura 44. Logo de Flask. Obtenido de (Flask, 2010)
Permite el desarrollo de aplicaciones básicas de
manera ágil y rápida.
Incluye un servidor web de desarrollo.
Compatible con wsgi (protocolo que utilizan los
servidores web para servir las páginas web
escritas en Python).
Es de código abierto.
Tabla 7. Características de Django y Flask
2.8.9 HTML
HTML (HyperText Markup Language) es un lenguaje de marcado utilizado
principalmente en el desarrollo de páginas web, utilizado en forma de texto para describir
y crear la estructura de las páginas (Garro, 2014).
El lenguaje HTML es un estándar reconocido en todo el mundo y cuyas normas las define
un organismo conocido como World Wide Web Consortium (W3C) el mismo que define
el lenguaje HTML como “un lenguaje reconocido universalmente y que permite publicar
información de forma global” (Eguíluz Pérez, Introducción a XHTML, 2012).
Figura 45. Logo de HTML. Obtenido de (Freepng, 2019)
2.8.10 CSS
Es un lenguaje de hojas de estilo creado para controlar el aspecto o presentación de los
documentos definidos con HTML, separando el contenido (párrafos, textos, tablas, lista
de elementos, etc.) con la presentación (color, tamaño, tipo de letra, separaciones entre
elementos, etc.), imprescindible para la creación de páginas web complejas (Eguíluz
Pérez, Introducción a CSS, 2009).
Figura 46. Logo de CSS. Obtenido de (Freepng, 2019)
33
2.8.11 JAVASCRIPT
Es un lenguaje de programación interpretado (los programas escritos con JavaScript se
pueden probar directamente en cualquier navegador), que se emplea principalmente para
desarrollar páginas web dinámicas (aquellas que incorporan efectos de texto,
animaciones, acciones al pulsar un botón y ventanas emergentes de aviso) (Eguíluz Pérez,
Introducción a JAVASCRIPT, 2012).
Figura 47. Logo de JavaScript. Obtenido de (Freepng, 2019)
Se presenta una tabla con las herramientas utilizadas describiendo su participación en el
proyecto después del análisis realizado:
Herramienta Uso
Anaconda Navigator Instalación de Python y creación del entorno virtual de
la aplicación.
Spyder IDE utilizado para el desarrollo del código.
Python Lenguaje de programación en que se basa la aplicación.
Scikit-learn, Keras Módulos utilizados para la implementación de las redes
neuronales.
Magenta Biblioteca utilizada para la manipulación de los
archivos MIDI.
Visual Studio Code Editor de código para el desarrollo de la aplicación web.
Django Framework web para la implementación del código
Python en el lado del servidor.
HTML, CSS y JavaScript Tecnologías utilizadas para la implementación de la
vista y validación de los datos de entrada.
Tabla 8. Uso de las herramientas de software en la aplicación
34
CAPÍTULO III
3. MARCO METODOLÓGICO
Las metodologías ágiles nacen como alternativa a las metodologías tradicionales, que se
consideran rígidas en las actuales características del mercado (Trigás Gallego, 2012).
El uso de metodologías ágiles para el desarrollo de software, permite la creación de
aplicaciones de manera ágil y fiable, optimizando el tiempo de desarrollo. Por este motivo
es importante la selección de una metodología para el desarrollo de la aplicación
“DrumML” del presente trabajo integrador.
Se describe una tabla comparativa sobre el uso de metodologías ágiles y metodologías
tradicionales:
Tabla 9. Diferencias entre metodologías ágiles y no ágiles. Obtenido de (Canós, Letelier, & Penadés, 2012)
A continuación, se describe algunas de las metodologías ágiles más representativas en el
desarrollo de software:
3.1 PROGRAMACIÓN EXTREMA (EXTREME PROGRAMMING - XP)
Es una metodología ágil que trata de fomentar las relaciones entre un grupo de personas,
para alcanzar el éxito en el desarrollo de software, además, promueve el trabajo en equipo
en un ambiente idóneo que permita impulsar el aprendizaje de los desarrolladores. XP
35
está pensado para implementar la retroalimentación continua del equipo de desarrollo con
el cliente, enfocándose en alcanzar una solución simple. Debido a que XP es
particularmente útil cuando los requisitos del proyecto son volubles e imprecisos (Canós,
Letelier, & Penadés, 2012).
Figura 48. Ciclo de XP. Obtenido de (Visual Paradigm, 2020)
3.2 CRYSTAL
Es un grupo de metodologías basadas en los conceptos de Rational Unified Process (RUP)
donde los recursos más valiosos son quienes conforman el equipo de desarrollo. Cada una
de las metodologías puede ser aplicada según el tamaño del proyecto y el nivel de control
que requiera. Entre las metodologías contenidas en Crystal se encuentran: Crystal Clear,
Crystal Yellow, Crystal Orange y Crystal Red, donde los colores indican el número de
personas que integran el equipo de trabajo, siendo la primera la que menor número de
participantes tiene.
El fundamento de Crystal está basado en la cooperación y comunicación de las personas
para lograr que se entregue software funcional y útil en no más de cuatro meses; además,
establece que al finalizar cada entrega es necesario tener un taller de reflexión para afinar
detalles. Uno de sus principios indica que al producir código con mayor frecuencia se
puede avanzar en la realización del trabajo intermedio, y también, permite que el equipo
evolucione y se adecue a las necesidades y cambios del sistema (Cadavid, Martinez, &
Vélez, 2013).
36
Figura 49. Grupo de metodologías en Crystal. Obtenido de (Edureka, 2020)
3.3 KANBAN
Es una metodología que mantiene el seguimiento de un proyecto, a través del control
visual para brindar transparencia en todo el flujo de desarrollo. Está basado en un
principio que establece empezar un nuevo bloque de trabajo solamente si el anterior ha
sido entregado. Generalmente se presenta una pizarra o panel con secciones que
identifican el momento en el que se encuentra una actividad; en cada una de las secciones
se puede incluir una nota adhesiva que detalla cada actividad, este proceso permite un
cambio progresivo de acuerdo al resultado del consenso de los participantes de un
proyecto.
La implementación de Kanban es relativamente fácil y su esquema visual permite
identificar los cambios de manera efectiva, teniendo en cuenta que cada actividad debe
hacer únicamente lo justo y necesario sin perder de vista los conceptos de mejora continua
(Maida, 2015).
Figura 50. Control visual en Kanban. Obtenido de (Hammarberg & Sunden, 2014)
37
3.4 SCRUM
Es un marco de trabajo que se utiliza en gestión de proyectos para detallar el desarrollo
de productos simples o complejos (Schwaber & Sutherland, 2013). Scrum ha sido
ampliamente utilizada en los últimos años debido a que se adapta rápidamente a cambios
de requisitos que pueden generar incertidumbre dentro de un proyecto (Canós, Letelier,
& Penadés, 2012). Una ventaja que ofrece Scrum es la auto-organización del equipo de
trabajo, pues cada uno de ellos puede organizarse por sí mismo, sin tomar en cuenta su
rol en la gestión del proyecto siempre y cuando exista autonomía, auto-superación y auto-
enriquecimiento dentro del equipo.
El flujo de Scrum permite controlar moderada y eficientemente el desarrollo del proyecto
sin socavar la creatividad y espontaneidad de los miembros del equipo; pero lo más
destacable de la metodología es que cada uno de los miembros aprende del resto y al
finalizar cada proyecto para empezar otro nuevo puede compartir conocimiento con los
distintos integrantes del nuevo equipo a lo largo de su permanencia en el desarrollo de
proyectos.
Una de las bases de Scrum es la eficiencia y eficacia del desarrollo, debido a lo cual cada
uno de las iteraciones consiste en ciclos breves denominados Sprints, en los cuales se
cumplen cinco fases de desarrollo ágil denominadas: concepto, especulación,
exploración, revisión y cierre (Trigás Gallego, 2012).
Figura 51. Ciclo de Scrum. Obtenido de (Freepng, 2019)
38
A continuación, se describe algunos conceptos necesarios que intervienen en el marco de
trabajo Scrum:
Elementos Descripción
Dueño del producto
(Product Owner)
Es el responsable de gestionar la lista del producto (Product
Backlog).
Lista del producto
(Product Backlog)
Es una lista ordenada que contiene los requisitos necesarios
para un producto, enumera todas las características,
funcionalidades, requisitos, mejoras y correcciones que
constituyen cambios sobre el producto para entregas futuras.
Reunión de
planificación de Sprint
(Sprint Planning
Meeting)
Es la etapa en la cual se planifica el trabajo a realizar durante el
sprint (un bloque de tiempo en el cual se crea un incremento
del producto), se crea mediante el trabajo colaborativo del
equipo de desarrollo (Scrum team).
Equipo de desarrollo
(Scrum Team)
Conformado por los profesionales que desempeñan la tarea de
entregar incrementos (requisitos que se han completado y son
perfectamente operativos) del producto.
Lista de pendientes del
Sprint (Sprint Backlog)
Es el conjunto de elementos de la lista de producto que se han
escogido para la elaboración en el sprint.
Scrum Master
Es el líder responsable del proyecto, el encargado de que el
marco de trabajo Scrum sea entendido y adoptado,
asegurándose de que el equipo de desarrollo trabaje ajustándose
a la teoría, prácticas y reglas correspondientes.
Reunión diaria (Daily
Scrum)
Es una reunión de 15 minutos entre el equipo de desarrollo,
para sincronizar actividades y crear tareas para las siguientes
24 horas, se inspecciona el trabajo realizado en el último sprint
y se realiza una proyección para el siguiente trabajo.
Revisión del Sprint
(Sprint Review)
Se inspecciona el incremento y se adapta la lista del producto
si fuese necesario.
Retrospectiva de Sprint
(Sprint Retrospective)
Es la etapa en la que el equipo de desarrollo planifica formas
para mejorar la calidad del producto.
Tabla 10. Elementos del marco de trabajo Scrum. Obtenido de (Schwaber & Sutherland, 2013)
39
3.5 SCRUM, XP Y CRYSTAL
La tabla siguiente, compara a Scrum, XP y Crystal teniendo en cuenta los siguientes
parámetros: sistema como algo cambiante, colaboración, resultados, simplicidad,
adaptabilidad, excelencia técnica y prácticas de colaboración.
Scrum XP Crystal
Sistema como algo cambiante 5 5 4
Colaboración 5 5 5
Resultados 5 5 5
Simplicidad 5 5 4
Adaptabilidad 4 3 5
Excelencia técnica 3 4 3
Prácticas de colaboración 4 5 5
Tabla 11. Ranking de "agilidad". Obtenido de (Letelier & Penadés, 2012)
Mediante el análisis realizado de las diferentes metodologías ágiles de desarrollo de
software se decidió utilizar Scrum que es la que se acopla al desarrollo del presente
proyecto integrador.
3.6 REQUISITOS PARA EL DESARROLLO DE LA APLICACIÓN
A continuación, se observa los requisitos necesarios para el desarrollo de la aplicación
“DrumML”, organizado en el marco de trabajo Scrum:
Aplicación DrumML
Id Prioridad Descripción
1 Muy alta Escoger el formato de los datos para el conjunto de
entrenamiento.
2 Alta Seleccionar la librería necesaria para la manipulación de los
datos.
2 Muy alta Convertir los datos (pistas de batería) a matrices binarias y
viceversa.
4 Media Dividir los datos de entrenamiento (x_train, y_train).
40
5 Alta Escoger algoritmos de aprendizaje automático para la creación
de nuevos ritmos de batería.
6 Muy Alta Implementar y entrenar a los modelos seleccionados
anteriormente.
7 Alta Generar nuevos ritmos a partir de una semilla aleatoria inicial.
8 Media Escoger la herramienta necesaria para el desarrollo de la
aplicación web (servidor).
9 Muy alta Implementar el código realizado en el lado del servidor
10 Media Diseño de la interfaz gráfica en el lado del cliente.
11 Media Escoger la herramienta necesaria para realizar el despliegue de
la aplicación web.
12 Alta Realizar pruebas y verificar el funcionamiento de la aplicación.
Tabla 12. Requisitos de la aplicación DrumML
En cada etapa se realizó reuniones para la verificación del avance de la planificación, así
como validación del producto y corrección de errores.
41
CAPÍTULO IV
4. DESARROLLO DE LA APLICACIÓN
4.1 FORMATO DE DATOS PARA EL CONJUNTO DE ENTRENAMIENTO
Debido a la mínima cantidad de espacio que ocupan los archivos MIDI (.mid) en el disco
duro, se ha optado por utilizarlos como formato estándar para los datos del conjunto de
entrenamiento.
MIDI (Interfaz Digital de Instrumentos Musicales) es un protocolo de comunicación que
permite a los instrumentos musicales electrónicos (sintetizadores, secuenciadores, etc.) y
computadoras comunicarse y compartir información. Para que estos dispositivos puedan
comunicarse entre sí, MIDI utiliza su propio lenguaje, que consiste en un conjunto de
mensajes (Midi Association, 2009).
En la siguiente tabla se describe los mensajes más significativos que intervienen a la hora
de interactuar con un dispositivo electrónico musical.
Mensaje Descripción Imagen
Note-on y note-off Cuando se toca una nota, se
envía un mensaje de note-on, y
cuando se deja de tocar la nota,
se trasmite un mensaje de note-
off.
Figura 52. Note-on y note-off. Obtenido de (Midi Association, 2009)
Velocity Es la intensidad con la que se
ejecuta una nota.
Figura 53. Velocity. Obtenido de (Midi Association, 2009)
42
Pitch bend Estos mensajes indican a un
dispositivo MIDI que suba o
baje el tono de la noca tocada.
Figura 54. Pitch bend. Obtenido de (Midi Association, 2009)
Tabla 13. Mensajes MIDI. Obtenido de (Midi Association, 2009)
La nota (pitch) indica una parte de la batería o instrumento de percusión que se está
ejecutando, el mismo que está representado por un número. A continuación, se muestra
una tabla de la nota y su equivalente al instrumento:
Número de
la nota
(pitch)
Tipo de
instrumento
Número de
la nota
(pitch)
Tipo de
instrumento
Número de
la nota
(pitch)
Tipo de
instrumento
27
Laser
28
Whip
29
Scratch Push
30 Scratch Pull 31 Stick Click 32
Metronome
Click
34 Metronome
Bell
35 Metronome
Bell
36 Kick Drum
37 Snare Cross
Stick
38 Snare Drum 39 Hand Clap
40
Electric
Snare Drum
41 Floor Tom 2 42 Hi-Hat
Closed
43 Floor Tom 1 44 Hi-Hat Foot 45 Low Tom
46 Hi-Hat Open 47 Low-Mid
Tom
48 High-Mid
Tom
49 Crash
Cymbal
50 High Tom 51 Ride
Cymbal
52 China
Cymbal
53 Ride Bell 54 Tambourine
55 Splash
cymbal
56 Cowbell 57 Crash
Cymbal 2
43
58 Vibraslap 59 Ride
Cymbal 2
60 High Bongo
61 Low Bongo 62 Conga Dead
Stroke
63 Conga
64 Tumba 65 High
Timbale
66 Low
Timbale
67 High Agogo 68
Low Agogo
69 Cabasa
70 Maracas 71 Whistle
Short
72 Whistle
Long
73 Guiro Short 74 Guiro Long 75 Claves
76 High
Woodblock
77 Low
Woodblock
78 Cuica High
79 Cuica Low 80 Triangle
Mute
81 Triangle
Open
82 Shaker 83 Sleigh Bell 84 Bell Tree
85 Castanets 86 Surdu Dead
Stroke
87 Surdu
91 Snare Drum
Rod
92 Ocean Drum 93 Snare Drum
Brush
Tabla 14. Mapa MIDI de percusión. Obtenido de (Song Writer, 2012)
Los archivos MIDI (Standar MIDI Files) tienen la extensión “.mid” al final de su nombre
y son de dos tipos, los SMF de tipo cero (0) contienen una única pista de los dieciséis (16)
canales disponibles para ser ocupados (1-9 y 11-16 reproducen sonidos estándar, cada
nota del canal 10 toca un sonido de batería diferente), mientras que los archivos de tipo
uno (1) pueden contener múltiples pistas (Midi Association, 2009).
Las especificaciones de los archivos SMF fueron publicadas por primera vez en 1990. Lo
que proporcionó a los usuarios la oportunidad de crear, guardar, reproducir y compartir
archivos MIDI. Un SMF está compuesto de dos fragmentos, el primero correspondiente
al encabezado que indica el tipo de SMF, el número de pistas en el archivo y el valor PPQ
44
(pulsos por cuarto de nota); y el segundo es el correspondiente a las pistas (Carleton,
2013).
Figura 55. Estructura de un archivo (.mid). Obtenido de (Carleton, 2013)
4.2 MANUPULACIÓN DE LOS DATOS
Para la manipulación de los archivos MIDI, se investigó el uso de algún método que
convierta la información de los archivos (mensajes) en una matriz binaria y viceversa. El
archivo midi_to_statematrix.py fue obtenido del repositorio GitHub, este script ha sido
45
implementado en el presente trabajo; y es el resultado de la investigación de Daniel
Johnson (Github, 2015).
A continuación, se muestra una gráfica de un archivo manipulado con el script
mencionado anteriormente:
Figura 56. Matriz binaria (uno)
De acuerdo a los requerimientos específicos del proyecto, el método analizado y probado
no obtuvo los resultados esperados, pues registraba pérdida de información al convertir
un archivo .mid en matriz binaria y viceversa; en consecuencia, este método no fue
implementado. Para solventar los errores encontrados y obtener las matrices con los
formatos y precisión necesarios para un correcto funcionamiento de los algoritmos
utilizados, que se basan en la matriz de entrada, se generaron métodos propios.
Se utilizó la biblioteca Mido como punto de partida, la misma que proporciona
información de los archivos como una lista de mensajes. De igual manera, se comparó
con la librería Magenta, y se determinó que al contrario de la librería Mido, la información
resultante de los archivos es entregada como una lista de valores. En base a estos
resultados, se decidió utilizar la librería Magenta para la trasformación de los archivos a
matrices binarias y viceversa, prestando facilidad de desarrollo de los métodos necesarios
a partir de la información de los archivos.
46
Biblioteca Representación de un archivo MIDI (.mid)
Mido
Figura 57. Archivo (.mid) manipulado con Mido
Magenta
Figura 58. Archivo (.mid) manipulado con Magenta
Tabla 15. Manipulación de archivo (.mid) con Mido y Magenta
47
4.3 CONVERSIÓN A MATRIZ BINARIA
Se convierte la información de los archivos del conjunto de entrenamiento en matrices
binarias para que los modelos implementados sean capaces de predecir las notas que se
activan (con valor de 1) y notas que se desactivan (con valor a 0). Para ello se
desarrollaron los métodos: midiToMatrix y matrixToMidi en el lenguaje de programación
Python:
Figura 59. Código del método midiToMatrix
El método midiToMatrix toma como parámetros de entrada la ruta del archivo (midi_file)
y el número de filas en que se divide cada tiempo, el mismo que puede ser entre cuatro,
48
ocho o dieciséis filas (steps_per_quarter) y retorna la matriz binaria del archivo (aa), la
duración de cada fila (jump), el número de filas por compas (steps_per_bar) y el número
de filas por cada tiempo (steps_per_quarter).
El método matrixToMidi tiene como parámetros de entrada una matriz binaria
(into_active), la duración de cada fila (jump) y la ruta donde se van a gaurdar los nuevos
archivos (exit_mid). A continuación, se presente el método correspondiente:
Figura 60. Código del método matrixToMidi
49
Para verificar el funcionamiento de los métodos desarrollados, se presentan dos gráficas
distintas de su funcionamiento, una con división de cada tiempo en cuatro filas y otra con
división de ocho filas; se puede observar que la pérdida de información al convertir un
archivo a matriz binaria y viceversa es menor con respecto a la Figura 56. Matriz binaria
(uno).
Figura 61. Matriz binaria (dos) cuatro filas por tiempo
Figura 62. Matriz binaria (tres) ocho filas por tiempo
4.3 DIVIDIR EN X_TRAIN Y Y_TRAIN
Para el propósito del presente trabajo integrador se ha realizado la división del conjunto
de entrenamiento como x_train y su respectiva etiqueta y_train de tres formas diferentes.
50
Se presenta la siguiente imagen con el propósito de explicar los términos de tiempo y
compás, los cuales en adelante servirán para ofrecer las respectivas explicaciones
pertinentes.
Figura 63. Partitura de un ritmo de batería
En la primera forma, se toman todas las filas de los tiempos impares de cada compás (I y
III) las cuales conforman los datos del conjunto x_train, y las filas de los tiempos pares
de cada compás (II y IV) conforman los datos del conjunto y_train.
Todas las matrices binarias de cada pista de batería individual se concatenan en una sola
matriz.
Figura 64. División del conjunto de entrenamiento por tiempo
51
La segunda forma, el conjunto x_train está conformado por todas las filas que conforman
los compases impares, mientras que el conjunto y_train está conformado por las filas de
los compases pares.
Figura 65. División del conjunto de entrenamiento por compás
Para dividir el conjunto de entrenamiento se desarrolló el método X_Y_train, que tiene
como parámetros de entrada la matriz binaria (active) y el tipo de división por tiempo o
compás (quarter_or_bar), dicho método devuelve dos arreglos, el primero con los datos
del conjunto de entrenamiento x_train (X) y el segundo con los datos de su respectiva
etiqueta y_train (Y).
Al entrenar a los modelos de aprendizaje automático se debe verificar que exista el mismo
número de muestras en el conjunto x_train y y_train; de no ser el caso, se completa el
número de muestras aumentando una matriz nula.
52
Figura 66. Código para dividir al conjunto de entrenamiento por tiempo o compás
En la tercera forma se implementó una opción que permite al usuario ingresar el número
de tiempos (n tiempos), los cuales son los que conforman el conjunto x_train, y el tiempo
siguiente (n+1) serán los datos del conjunto y_train.
53
Figura 67. Figura 67. División del conjunto de entrenamiento en n tiempos (iteración 1)
Figura 68. División del conjunto de entrenamiento en n tiempos (iteración 2)
Figura 69. División del conjunto de entrenamiento en n tiempos (ultima iteración)
54
El algoritmo se ejecuta avanzando por cada tiempo hasta que el conjunto y_train agregue
el último tiempo del conjunto de datos, y para eso se desarrolló el método freeWin que
tiene como parámetro de entrada la matriz binaria (activate) y el número de tiempos
deseados.
Figura 70. Código para dividir al conjunto de entrenamiento por n tiempos
Debido a que las matrices binarias son de dimensión 𝒏𝒙𝒎, el número de filas que
corresponde a la división de cada tiempo y el número de columnas que corresponde a las
notas (pitch). Se ha optado por hacer un aplanamiento para la entrada a los modelos tales
como: árboles de decisión, bosques aleatorios y perceptrón multicapa.
Figura 71. Aplanamiento de los datos de entrada
4.4 ALGORITMOS DE APRENDIZAJE AUTOMÁTICO
Se han utilizado cinco algoritmos: árboles de decisión (DT), bosques aleatorios (RF),
perceptrón multicapa (MLP), redes neuronales recurrentes (LSTM) y redes neuronales
convolucionales (CNN).
Se estableció el criterio de entropía en el algoritmo árbol de decisión y bosque aleatorio
debido a toda la investigación teórica mencionada en el Capítulo II de este escrito.
55
En el caso del MLP tiene una capa oculta con trescientas neuronas menos que la
dimensión de entrada a la red, está implementado con la función de activación sigmoidea,
además de incluir el optimizador Adam para minimizar la función de coste, y el valor
numero_epocas que es ingresado por el usuario para definir el número de iteraciones
máximas de entrenamiento.
Figura 72. Código de los algoritmos (DT, RF Y MLP)
La red neuronal recurrente, en la primera capa cuenta con funciones de activación relu,
en la segunda capa con celdas LSTM y una capa de salida con función de activación
sigmoidea, utiliza el optimizador descenso del gradiente estocástico para minimizar la
función de coste de la entropía cruzada categórica.
Figura 73. Código de la red neuronal recurrente (LSTM)
La red neuronal convolucional tiene una capa de convolución seguida de una capa de max
pooling, implementada con la función relu en la capa oculta y la función sigmoidea en la
56
capa de salida, utiliza el optimizador descenso del gradiente estocástico para minimizar
la función de coste de la entropía cruzada categórica.
Figura 74. Código de la red neuronal convolucional (CNN)
4.5 GENERACIÓN DE NUEVOS RITMOS DE BATERÍA
Los nuevos ritmos de batería son generados a partir de una semilla aleatoria inicial, la
misma que se utiliza para predecir el tiempo o compás siguiente, a continuación, el nuevo
tiempo o compás generado por el algoritmo se convierte en la nueva entrada al algoritmo,
el algoritmo se ejecuta hasta alcanzar el valor máximo introducido por el usuario lo que
indica la duración del nuevo ritmo de batería.
57
Figura 75. Código para generar nuevos ritmos de batería con los modelos (DT, RF y MLP)
A continuación, se muestra un ejemplo de ritmo generado con el algoritmo MLP con
1.000 épocas de enteramiento, entrenado con el conjunto de entrenamiento de metal,
dividiendo al conjunto de entrenamiento con una ventana de cinco tiempos y una división
de cada tiempo en cuatro filas.
Figura 76. Ritmo generado con MLP
58
4.6 IMPLEMENTACIÓN DEL CÓDIGO EN EL LADO DEL SERVIDOR
Se utiliza Django como framework web para ejecutar el código en el lado del servidor,
todos los procesos descritos anteriormente constituyen la lógica de la aplicación
DrumML, y por lo tanto, se realizan en el lado del servidor.
Figura 77. Estructura de la aplicación en el lado del servidor
En consecuencia, todos los datos necesarios para que la aplicación emplee el
procedimiento son enviados desde el cliente y capturados en el servidor, los archivos con
los que se entrenan a los algoritmos de aprendizaje automático son guardados
temporalmente en el servidor (en la carpeta media), hasta que la ejecución termine y se
muestren los resultados en el lado del cliente.
59
Figura 78. Código para capturar los datos enviados desde el lado del cliente
4.7 IMPLEMENTACIÓN DE LA VISTA
La maquetación correspondiente al diseño de la aplicación, cuenta con tres partes
fundamentales: el título, la barra de navegación y el contenido, la barra de navegación
cuenta con varias vistas, permitiendo al usuario navegar a través de las diferentes
opciones que dispone la aplicación, en el contenido se puede introducir los parámetros
necesarios para entrenar a los modelos de aprendizaje automático y obtener los resultados.
Se ha utilizado una composición de color en tríada la misma que está compuesta de los
colores como: anaranjado, morado y verde.
En las siguientes tablas, se muestra información de los elementos del diseño con una
descripción de su funcionamiento.
Característica Componentes del diseño
Maquetación
Figura 79. Estructura del diseño de la aplicación
60
Colores:
- #fc910
- #2b007080
- #069e0d80
Figura 80. Tríada de colores
Tabla 16. Elementos del diseño
En la siguiente tabla se muestran los elementos de la aplicación:
Título
Figura 81. Título de la aplicación
Barra de
navegación
Figura 82. Barra de navegación de la aplicación
Tabla 17. Elementos de la aplicación
La aplicación cuenta con nueve diferentes parámetros, los cuales se detallan a
continuación:
Parámetro Descripción
Figura 83. Botón para subir archivos
Permite subir el conjunto de
entrenamiento con un mínimo de
tres archivos MIDI.
Figura 84. Selección del modelo
Se selecciona el tipo de algoritmo de
aprendizaje automático.
61
Figura 85. División de cada tiempo
La opción de dividir cada tiempo en
cuatro, ocho o dieciséis filas.
Figura 86. Dividir por tiempo o compás
Dividir al conjunto de
entrenamiento por tiempo o
compases.
Figura 87. Cuadro de ventana libre
Determinar el número de tiempos
para dividir el conjunto de
entrenamiento (n tiempos).
Figura 88. Cuadro de duración de los nuevos ritmos
Determina la duración de los nuevos
ritmos a generar.
Figura 89. Cuadro de épocas de entrenamiento
Épocas máximas de entrenamiento
para los modelos adecuados.
Figura 90. Botón comenzar
El botón comenzar, indica que los
parámetros serán enviados para
realizar los procedimientos.
Figura 91. Sección de resultados
Es la sección en donde se mostraran
los nuevos archivos generados, los
mismos que se pueden descargar
para poder escucharlos.
Tabla 18. Parámetros de la aplicación
62
4.8 DESPLIEGUE
Se ha utilizado los servicios de DigitalOcean para construir el servidor y hacer el
despliegue de la aplicación, a la cual se podrá acceder desde cualquier dispositivo
electrónico con internet que disponga de un navegador web.
Figura 92. Características del servidor
4.9 PRUEBAS Y RESULTADOS
Se ha generado cinco ritmos diferentes con los modelos implementados en el presente
proyecto integrador, de los cuales se muestra el mejor resultado de cada uno de ellos en
la siguiente tabla.
Árbol de decisión
Conjunto de entrenamiento Metal_rhythm_patterns (Musicez, 2014)
Número de ritmos a generar 5
División de cada tiempo (filas) 4
Ventana libre (n tiempos) 5
Duración del nuevo ritmo 60 (30 segundos)
Resultado https://www.youtube.com/watch?v=WV6ECGsHnmc&f
eature=youtu.be
Tabla 19. Datos de entrenamiento para DT
63
Figura 93. Matriz binaria DT - 2.mid
Bosque Aleatorio
Conjunto de entrenamiento Metal_rhythm_patterns
Número de ritmos a generar 5
División de cada tiempo (filas) 4
Ventana libre (n tiempos) 5
Duración del nuevo ritmo 60 (30 segundos)
Resultado https://www.youtube.com/watch?v=se6Fpz_1eGI
Tabla 20. Datos de entrenamiento para RF
Figura 94. Matriz binaria RF - 5.mid
64
Perceptrón multicapa
Conjunto de entrenamiento Metal_rhythm_patterns
Número de ritmos a generar 5
División de cada tiempo (filas) 4
Ventana libre (n tiempos) 5
Duración del nuevo ritmo 60 (30 segundos)
Épocas de entrenamiento 1000 – 10 000
Resultados https://www.youtube.com/watch?v=biFjkKHQsrQ
https://www.youtube.com/watch?v=FhJQfB6w83M
Tabla 21. Datos de entrenamiento para MLP
Figura 95. Matriz binaria MLP - 5.mid - 1.000 Épocas de entrenamiento
Figura 96. Matriz binaria MLP - 5.mid - 10.000 Épocas de entrenamiento
65
LSTM
Conjunto de entrenamiento Metal_rhythm_patterns
Número de ritmos a generar 5
División de cada tiempo (filas) 4
Ventana libre (n tiempos) 5
Duración del nuevo ritmo 60 (30 segundos)
Épocas de entrenamiento 1000 - 10 000
Loss 9.0353 - 6.6585
Resultado https://www.youtube.com/watch?v=YEL8I-gbz8E
https://www.youtube.com/watch?v=8QWqiHSyag8
Tabla 22. Datos de entrenamiento para LSTM
Figura 97. Matriz binaria LSTM - 3.mid - 1.000 Épocas de entrenamiento
Figura 98. Matriz binaria LSTM - 3.mid - 10.000 Épocas de entrenamiento
66
LSTM
Conjunto de entrenamiento Metal_rhythm_patterns
Número de ritmos a generar 5
División de cada tiempo (filas) 4
Ventana libre (n tiempos) 5
Duración del nuevo ritmo 60 (30 segundos)
Épocas de entrenamiento 100 - 1000
Loss 17.5190 – 9.8011
Dropout 0.5
Resultado https://www.youtube.com/watch?v=h_3GVcBoYUc
https://www.youtube.com/watch?v=F4sDS4fbMZU
Tabla 23. Datos de entrenamiento para LSTM – Dropout(0.5)
Figura 99. Matriz binaria LSTM - 2.mid - 100 Épocas de entrenamiento
Figura 100. Matriz binaria LSTM - 2.mid - 1000 Épocas de entrenamiento
67
CNN
Conjunto de entrenamiento Metal_rhythm_patterns
Número de ritmos a generar 5
División de cada tiempo (filas) 4
Ventana libre (n tiempos) 5
Duración del nuevo ritmo 60 (30 segundos)
Épocas de entrenamiento 1000 - 10 000
Loss 12.5338 - 12.4233
Resultados https://www.youtube.com/watch?v=HXaMVKEnQwU
https://www.youtube.com/watch?v=GPK8YkJR3vE
Tabla 24. Datos de entrenamiento para CNN
Figura 101. Matriz binaria CNN - 5.mid - 1000 Épocas de entrenamiento
Figura 102. Matriz binaria CNN - 5.mid - 10.000 Épocas de entrenamiento
68
CNN
Conjunto de entrenamiento Metal_rhythm_patterns
Número de ritmos a generar 5
División de cada tiempo (filas) 4
Ventana libre (n tiempos) 5
Duración del nuevo ritmo 60 (30 segundos)
Épocas de entrenamiento 100 - 1000
Loss 12.4111 - 9.8011
Dropout 0.5
Resultados https://www.youtube.com/watch?v=O8X2L6NQWVY
https://www.youtube.com/watch?v=lUI5xrhkMuE
Tabla 25. Datos de entrenamiento para CNN – Dropout(0.5)
Figura 103. Matriz binaria CNN - 2.mid - 100 Épocas de entrenamiento
Figura 104. Matriz binaria CNN - 2.mid - 1000 Épocas de entrenamiento
69
CAPÍTULO V
5. CONCLUSIONES Y RECOMENDACIONES
5.1 CONCLUSIONES
La aplicación DrumML genera de forma más que aceptables ritmos de batería mediante
distintos algoritmos de Aprendizaje automático. Al ser una aplicación web, se puede
utilizar desde cualquier dispositivo electrónico que disponga de un navegador web con
acceso a internet, permitiendo a los usuarios ejecutar la aplicación DrumML desde sus
computadores o dispositivos móviles.
El uso de diferentes algoritmos de aprendizaje automático, permitió obtener variedad de
resultados en los modelos generados, así mismo, tener una aplicación con cinco tipos de
modelos de aprendizaje automático permitiéndole al usuario interactuar con más de una
arquitectura.
El desarrollo de la aplicación con el framework Django en el lado del servidor, permitió
la integración del código: manipulación de los datos, la implementación de los modelos
de aprendizaje automático y desarrollo de la lógica para generar nuevos ritmos de batería
a través de una semilla aleatoria inicial; realizado con el lenguaje de programación Python
de manera fácil, organizada y optimizando el recurso tiempo. La implementación de una
interfaz gráfica para la aplicación de manera en que: cada vista representa un modelo
diferente, ha permitido el uso de la aplicación de una manera clara y fácil para el usuario.
Debido a que la música es algo relativo y depende más de gustos personales, he utilizado
el conjunto de entrenamiento con ritmos del género musical de metal, probando todos los
modelos implementados obteniendo resultados variados para cada uno de ellos. Desde mi
perspectiva concluyo que los mejores resultados se han obtenido con los algoritmos
árboles de decisión y el perceptrón multicapa debido que los nuevos ritmos generados
incluyen dinamismo a lo largo del tiempo y sus patrones rítmicos son agradables. Y
obteniendo resultados no aceptables con la red neuronal convolucional debido a la pérdida
de información que se da en sus capas de convolución y agrupación, obteniendo un error
elevado al momento de finalizar el entrenamiento de la red.
70
En general, los mejores resultados se obtuvieron dividiendo al conjunto de entrenamiento
con n tiempos previos, debido a que el algoritmo tiene más información en la matriz de
entrada y predice menos información en la matriz de salida; por lo tanto los resultados
también varían dependiendo en como se divide al mismo. El parámetro de dividir el
tiempo en cuatro, ocho o dieciséis filas ha permitido definir la calidad en trasformar los
archivos MIDI en matrices binarias evitando la pérdida de información en algunos
conjuntos de entrenamiento.
5.2 RECOMENDACIONES
Se recomienda utilizar la aplicación con un número moderado de datos debido al gran
coste computacional que requieren los algoritmos de aprendizaje automático, a los
procesos realizados con los datos y por las características mínimas con las que cuenta el
servidor en que se encuentra alojada la aplicación.
Al utilizar la aplicación, es necesario cambiar los parámetros para obtener resultados
distintos, permitiendo al usuario sacar sus propias conclusiones.
Con la finalidad de comprobar los resultados de la aplicación, se recomienda la utilización
de bases rítmicas diferentes a las utilizadas en el presente trabajo integrador, debido a la
utilización de los ritmos de metal como base rítmica fundamental que son los que
conforman la parte de resultados.
El sistema implementado, predice las notas que se activa y se desactivan a lo largo del
tiempo, por lo tanto queda como trabajo futuro, desarrollar un sistema que pueda predecir
la velocidad de cada nota, el tempo y el compás de los nuevos archivos generados.
71
BIBLIOGRAFÍA
Anaconda. (2020). Anaconda Documentation. Obtenido de
https://docs.anaconda.com/anaconda/navigator/
Ayyadevara, V. (2018). Pro Machine Learning Algorithms. New York: Apress.
Beysolow II, T. (2017). Introduction to Deep Learning Using R: A Step-by-Step Guide
to Learning and Implementing Deep Learning Models Using R. Apress.
Cadavid, A., Martinez, J., & Vélez, J. (2013). Revisión de metodologías ágiles para el
desarrollo de software. Prospectiva, 11(2), 35-36.
Canós, J. H., Letelier, P., & Penadés, M. C. (2012). Metodologías ágiles en el desarrollo
de software.
Caparrini, F. S. (2019). Sobre la Inteligencia Artificial... Obtenido de
http://www.cs.us.es/~fsancho/?e=54
Carleton. (2013). Introduction to Music Technology . Obtenido de Standard MIDI Files
(SMF) Introduction: https://acad.carleton.edu/courses/musc108-00-
f14/pages/03/03StandardMIDIFilesIntroduction.html
Chu, H., Urtasun, R., & Fidler, S. (2016). Song from PI: A musically plausible network
for pop music generation.
Díaz, B. (2002). Método básico para batería.
Django. (2005). Meet Django. Obtenido de https://www.djangoproject.com/
Edureka. (2020). What Is Agile Methodology – Know the What and How? Obtenido de
https://www.edureka.co/blog/what-is-agile-methodology/
Eguíluz Pérez, J. (2009). Introducción a CSS.
Eguíluz Pérez, J. (2012). Introducción a JAVASCRIPT.
Eguíluz Pérez, J. (2012). Introducción a XHTML.
Ferrer Martínez, J. (2012). Implantación de aplicaciones web.
Flask. (2010). User’s Guide. Obtenido de https://flask.palletsprojects.com/en/1.1.x/
Freepng. (2019). Obtenido de https://www.freepng.es/png-egtwpk/
Garro, A. (2014). Xhtml.
Gillick, J., Roberts, A., Engel, J., Eck, D., & Bamman, D. (2019). Learning to groove
with inverse sequence transformations.
Github. (1 de 8 de 2015). biaxial-rnn-music-composition. Obtenido de
https://github.com/hexahedria/biaxial-rnn-music-
composition/blob/master/midi_to_statematrix.py
Goel, K., Vohra, R., & Sahoo, J. K. (2014). Polyphonic music generation by modeling
temporal dependencies using a rnn-dbn.
72
Gollapudi, S. (2019). Learn Computer Vision Using OpenCV. Apress.
Hammarberg, M., & Sunden, J. (2014). Kanban in action. Manning Publications Co.
Herrera, E. (1998). Teoría Musical y Armonía Moderna: vol. 1. Antoni Bosch.
Hilera González, J. R., & Martínez Hernando, V. J. (2000). Redes neuronales
artificiales: fundamentos, modelos y aplicaciones.
Ingram, J. (2002). Orientación musical. Universal Books.
Kashyap, P. (2018). Machine Learning for Decision Makers: Cognitive Computing
Fundamentals for Better Decision Making. Apress.
Keras. (2020). Keras: The Python Deep Learning library. Obtenido de https://keras.io/
Kim, P. (2017). Matlab deep learning. With Machine Learning, Neural Networks and
Artificial Intelligence.
Latorre, M. (2018). Historia de las web, 1.0, 2.0, 3.0 y 4.0. Obtenido de
http://umch.edu.pe/arch/hnomarino/74_Historia%20de%20la%20Web.pdf
Letelier, P., & Penadés, M. C. (2012). Métodologías ágiles para el desarrollo de
software: eXtreme Programming (XP).
Magenta. (2020). Make Music and Art Using Machine Learning. Obtenido de
https://magenta.tensorflow.org/
Maida, E. G. (2015). Metodologías de desarrollo de software.
Manaswi, N. K., Manaswi, N. K., & John, S. (2018). Deep Learning with Applications
Using Python. Apress.
Marini, E. (2012). El modelo cliente/servidor. Obtenido de http://index-
of.co.uk/REDES/linuxito%20-%20El%20Modelo%20Cliente-Servidor.pdf
Matlab. (1994). Math. Graphics. Programming. Obtenido de
https://www.mathworks.com/products/matlab.html
Midi Association. (2009). An Intro to MIDI. Obtenido de
https://www.midi.org/images/easyblog_articles/43/intromidi.pdf
Moolayil, J., Moolayil, & John, S. (2019). Learn Keras for Deep Neural Networks.
Apress.
Musicez. (2014). Metal Midi Rhythm Patterns. Obtenido de
http://www.musicez.com/metalrp.html
Nagar, S. (2017). Introduction to Python for Engineers and Scientists: Open Source
Solutions for Numerical Computation. Apress.
Norving, P., & Russell, S. (2004). Inteligencia artificial. Un enfoque moderno. 2. a
Edición.
Pacheco, M. A. (2017). Identificacion de sistemas no lineales con redes neuronales
convolucionales. México.
73
Paluszek, M., & Thomas, S. (2019). MATLAB Machine Learning Recipes: A Problem-
solution Approach. Apress.
Pedregosa, F., Varoquaux, G., Gramfort, A., Michel, V., Thirion, B., Grisel, O., &
Vanderplas, J. (2011). Scikit-learn: Machine learning in Python. Journal of
machine learning research.
Python. (2001). Obtenido de https://www.python.org/
Raschka, S., & Mirjalili, V. (2019). Python Machine Learning: Machine Learning and
Deep Learning with Python, scikit-learn, and TensorFlow 2. Packt Publishing
Ltd.
RStudio. (2020). Obtenido de https://rstudio.com/
Santamaría, L. A., Zuñiga, S., Pineda, I. H., Somodevilla, M. J., & Rossainz, M. (s.f.).
Reconocimiento de genes en secuencias de ADN por medio de imágenes.
Sarkar, D., Bali, R., & Sharma, T. (2018). Practical Machine Learning with Python. A
Problem-Solvers Guide To Building Real-World Intelligent Systems. Berkely:
Apress.
Sayad, S. (2010). An Introduction to Data Science. Obtenido de
https://www.saedsayad.com/decision_tree.htm
Schwaber, K., & Sutherland, J. (2013). La guía de scrum: La guía definitiva de scrum,
las reglas del juego.
scikit-learn. (2020). scikit-learn Machine Learning in Python. Obtenido de
https://scikit-learn.org/stable/
Sierra, A. J. (2007). Struts 2ª edición.
Song Writer. (2012). Percussion MIDI Maps. Obtenido de
https://usermanuals.finalemusic.com/SongWriter2012Win/Content/PercussionM
aps.htm
Spyder. (2018). The Scientific Python Development Environment. Obtenido de
https://www.spyder-ide.org/
Swamynathan, M. (2017). Mastering machine learning with python in six steps: A
practical implementation guide to predictive data analytics using python.
Apress.
Taulli, T. (2019). Artificial Intelligence Basics. Apress.
Trigás Gallego, M. (2012). Metodologia scrum.
Visual Paradigm. (2020). Extreme Programming (XP) vs Scrum. Obtenido de
https://www.visual-paradigm.com/scrum/extreme-programming-vs-scrum/
Visual Studio Code. (2020). Getting Started. Obtenido de
https://code.visualstudio.com/docs
74
Yang, L. C., Chou, S. Y., & Yang, Y. H. (2017). MidiNet: A convolutional generative
adversarial network for symbolic-domain music generation.
75
ANEXOS
Pantallas de la aplicación desde IPhone 5S con el navegador Safari
Tabla 26. Pantallas de la aplicación desde IPhone
76
Pantallas de la aplicación desde Samsung con el navegador Google Chrome
Tabla 27. Pantallas de la aplicación desde Samsung
77
Pantallas de la aplicación desde Windows 10 con el navegador Google Chrome
78
Tabla 28. Pantallas de la aplicación desde Windows 10
79
A continuación, se presenta la visualización en partituras de los resultados generados.
Figura 105. Partitura del resultado con árbol de decisión
80
Figura 106. Partitura del resultado con bosque aleatorio
Figura 107. Partitura del resultado con MLP
81
Figura 108. Partitura del resultado con LSTM
82
Figura 109. Partitura del resultado con CNN