UNIVERSIDAD CENTRAL DEL ECUADOR FACULTAD DE INGENIERÍA

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

[email protected]

mailto:[email protected]

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).

https://link.springer.com/chapter/10.1007/978-3-319-11179-7_28

https://link.springer.com/chapter/10.1007/978-3-319-11179-7_28

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


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


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

https://github.com/hexahedria/biaxial-rnn-music-composition/blob/master/midi_to_statematrix.py

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

https://www.youtube.com/watch?v=WV6ECGsHnmc&feature=youtu.be

https://www.youtube.com/watch?v=WV6ECGsHnmc&feature=youtu.be

63

Figura 93. Matriz binaria DT - 2.mid

Bosque Aleatorio

Conjunto de entrenamiento Metal_rhythm_patterns





Resultado https://www.youtube.com/watch?v=se6Fpz_1eGI

Tabla 20. Datos de entrenamiento para RF

Figura 94. Matriz binaria RF - 5.mid

https://www.youtube.com/watch?v=se6Fpz_1eGI

64

Perceptrón multicapa






É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

https://www.youtube.com/watch?v=biFjkKHQsrQ

https://www.youtube.com/watch?v=FhJQfB6w83M

65

LSTM






É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

https://www.youtube.com/watch?v=YEL8I-gbz8E

https://www.youtube.com/watch?v=8QWqiHSyag8

66

LSTM






É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

https://www.youtube.com/watch?v=h_3GVcBoYUc

https://www.youtube.com/watch?v=F4sDS4fbMZU

67

CNN






É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

https://www.youtube.com/watch?v=HXaMVKEnQwU

https://www.youtube.com/watch?v=GPK8YkJR3vE

68

CNN






É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)



https://www.youtube.com/watch?v=O8X2L6NQWVY

https://www.youtube.com/watch?v=lUI5xrhkMuE

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

Documents

UNIVERSIDAD CENTRAL DEL ECUADOR FACULTAD DE INGENIERÍA