TFG_SANTIAGO_JUAN_QUEIPO_DE_LLANO_MAZZUCHELLI

•

Engenharias

edw ga

28/4/2024

¡Este material tiene más páginas!

Entonces, ¿te gustó este material?

Ayude a animar a otros estudiantes a mejorar el contenido

¿Te gustó este material? ¡Compartir! 🧡

Microcontroladores y aplicaciones

220 Materiales compartidos

Descarga la aplicación para disfrutar aún más

Lea materiales sin conexión, sin usar Internet. Además de muchas otras características!

Vista previa del material en texto

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA Y
SISTEMAS DE TELECOMUNICACIÓN

PROYECTO FIN DE GRADO

TÍTULO: Implementación de aplicaciones de Deep
Learning en microcontroladores ARM Cortex M.

AUTOR: Santiago Juan Queipo de llano Mazzuchelli

TITULACIÓN: Ingeniería Electrónica de Comunicaciones

TUTOR: Mariano Ruiz González

DEPARTAMENTO: DTE

VºBº

Miembros del Tribunal Calificador:

PRESIDENTE: Cesar Asensio Rivera

TUTOR: Mariano Ruiz González

SECRETARIO: Julián Nieto Valhondo

Fecha de lectura:

Calificación:

El Secretario,

AGRADECIMIENTOS:

A mis padres quienes han sido un apoyo incondicional durante toda mi vida y en
especial en esta etapa universitaria. Gracias a ellos pude recibir la mejor formación
posible.

A mis seis hermanos pequeños por ser mi motivación diaria para ser ejemplo de trabajo
constante.

A mis amigos que me han acompañado en tantas tardes de estudio en la biblioteca, tanto
de día como de noche.

A mis amigos del Erasmus, que me han hecho disfrutar de mi experiencia a pesar de
todas las horas de estudio. Cada rato con ellos ha sido maravilloso.

A mi novia por escucharme hablar horas y horas de temas académicos, que en muchas
ocasiones, resultan poco emocionantes.

A mis compañeros de la universidad por ser un apoyo continuo, agradezco
especialmente a los más veteranos, sus consejos hicieron que el paso por las aulas fuera
más sencillo.

A mis profesores por sus conocimientos, pero sobre todo su calidad como personas, han
sido para mí, un ejemplo de dedicación y disciplina.

A mi tutor por su paciencia y por acompañamiento en este proyecto, que en muchas
ocasiones se vio lejos el final. Gracias de verdad.

RESUMEN:
Los dispositivos conectados o Internet of Things (IoT) han aumentado exponencialmente
en los últimos tiempos y se prevé que esta tendencia siga durante los próximos años. Este
hecho provocará una carga considerable en el ancho de banda de la red, por lo que la
latencia se convertirá en un gran desafío en el futuro [1]. Esta dependencia a internet
dificulta su implementación en áreas con baja conectividad de red. La solución a este
problema es desarrollar tecnologías que se procesen y ejecuten los datos directamente en
la fuente. Esto reduciría la latencia y el consumo de energía en comunicación en la red.
Sin embargo, la limitada capacidad de cálculo de los microcontroladores es un desafío
para los diseñadores. Para ayudar en este proceso, existen bibliotecas y herramientas que
ayudan a aumentar el rendimiento y reducir el cálculo para la memoria del
microcontrolador. El problema es que es difícil encontrar información que siga el proceso
completo desde la idea a la resolución.

En el proyecto que desarrolla esta memoria, se ha querido elaborar una guía que recoja
cómo es el proceso completo a seguir desde la idea de una red neuronal a su
implementación. Pasando por todas las fases. Crear una red neuronal en Keras, adquirir
los datos para su entrenamiento y entrenarla. Crear el proyecto en STM32CubeIDE,
introducir la red entrenada en el proyecto y poder ejecutarla en una aplicación funcional.
En este proyecto se ha puesto el foco en las aplicaciones para microcontroladores ARM
Cortex-M. Con la dificultad que presenta la limitada memoria de estos aparatos La
aplicación a implementar será una red que utiliza datos del acelerómetro para identificar
diferentes gestos.

ABSTRACT:
Connected devices or the Internet of Things (IoT) have increased exponentially in recent
times and this trend is expected to continue in the coming years. This will put a
considerable load on the network bandwidth, so latency will become a big challenge in
the future. This dependence on the internet makes it difficult to implement in areas with
low network connectivity [1]. The solution to this problem is to develop technologies that
process and execute data directly at the source. This would reduce latency and power
consumption in communication on the network. However, the limited computing power
of microcontrollers is a challenge for designers. Some libraries and tools help increase
performance and reduce computation for microcontroller memory to aid in this process.
The problem is that it is difficult to find information that follows the entire process from
idea to resolution.

In the project that develops this report, we have wanted to develop a guide that collects
the complete process to follow from the idea of a neural network to its implementation.
Going through all the phases. Create a neural network in Keras and train it. Create the
project in STM32CubeIDE, introduce the network trained in the project, and run it in a
functional application. In this project the focus has been on the applications for ARM
Cortex-M microcontrollers. With the difficulty presented by the limited memory of these
devices, the application to be implemented will be a network that uses accelerometer data
to identify different gestures.

Índice de contenidos

Índice de ilustraciones ...................................................................................................... 7
Índice de tablas ................................................................................................................. 9
Acrónimos ........................................................................................................................ 9
Capítulo 1. Introducción y objetivos del proyecto. ........................................................ 11
1.1 Introducción del proyecto ................................................................................ 13
1.2 Contexto ........................................................................................................... 13
1.3 Justificación y objetivos del trabajo fin de grado ............................................ 14
1.4 Metodología de trabajo .................................................................................... 15
1.5 Organización de la memoria ................................................................................. 16
Capítulo 2. Estado del arte. ............................................................................................. 17
2.1 Conceptos teóricos ................................................................................................ 19
2.1.1 Introducción a Redes Neuronales Artificiales ............................................... 19
2.1.2 Conceptos a tener en cuenta en redes neuronales. ......................................... 20
2.1.4 Introducción a Machine Learning Embebido (TinyML)................................ 24
2.2 Desarrollos existentes ........................................................................................... 25
2.2.1 Bibliotecas principales ................................................................................... 25
2.2.2 Herramientas y plataformas de desarrollo ..................................................... 28
2.3 Red neuronal ST ................................................................................................... 41
2.4 Hardware Empleado ............................................................................................. 42
2.4.1 Introducción ................................................................................................... 42
2.4.2 Características generales................................................................................ 44
2.4.3 B-L475E-IOT01A en detalle ......................................................................... 44
Capítulo 3. Planteamiento del problema y Diseño de la solución. ................................. 51
3.1 Introducción ..................................................................................................... 53
3.2 Diseño del sistema ...........................................................................................53
3.3 Configuración del entorno ............................................................................... 53
3.3.1 Configuración inicial en STM32CubeIDE ............................................... 53
3.3.2 Configuración del sensor LSM6DSL y de la Interfaz I2C para utilizarlo 55
3.3.3 Configuración del UART ......................................................................... 59
3.3.4 Configuración X-CUBE-IA Core (Red neuronal) .................................... 60
3.3.5 Configuración del timer ............................................................................ 65
3.3.6 Generación del código .............................................................................. 66
3.3.6 Configuración del Tera Term ........................................................................ 67
3.3.7 Exportar proyectos a otros entornos desde STM32CubeIDE. ....................... 69
Capítulo 4. Implementación y pruebas ........................................................................... 71

4.1 Introducción ..................................................................................................... 73
4.2 Red neuronal .................................................................................................... 73
4.2.1 Adquisición de datos para la red. Programa de adquisición de datos....... 73
4.2..2 Codificación de la red ............................................................................... 78
4.3 Framework de la red neuronal ......................................................................... 88
4.4 Timer para medir la inferencia.............................................................................. 91
4.5 Sistema completo ............................................................................................. 92
4.6 Posibles problemas ........................................................................................ 105
4.6.1 Problemas con valores float ......................................................................... 105
4.6.2 Problemas con malloc .................................................................................. 105
4.7 Resultados de la red. ...................................................................................... 106
4.8 Planificación temporal del trabajo ...................................................................... 107
4.9 Presupuesto del proyecto ............................................................................... 108
Capítulo 5. Conclusiones y trabajos futuros. ................................................................ 109
5.1 Conclusiones del trabajo fin de grado ............................................................ 111
5.2 Trabajos futuros ............................................................................................. 111
Bibliografía ................................................................................................................... 112
Anexo 1. Esquemáticos del dispositivo B-L475E-IOT01A. ........................................ 117

Índice de ilustraciones

Ilustración 1. Artificial Intelligence, Machine Learning y Deep Learning. [9] .............. 13
Ilustración 2. Fases de la metodología de trabajo del proyecto. ..................................... 15
Ilustración 3. Esquema neurona y neurona artificial. ..................................................... 19
Ilustración 4. Esquema red neuronal artificial. ............................................................... 19
Ilustración 5. Esquema pesos neurona. ........................................................................... 20
Ilustración 6. Representación del descenso del gradiente. ............................................. 21
Ilustración 7, Función Sigmoide ..................................................................................... 22
Ilustración 8. Función tangente hiperbólica ................................................................... 23
Ilustración 9. Función rectificada de unidad lineal (ReLU) .......................................... 23
Ilustración 10. Función Softmax .................................................................................... 24
Ilustración 11. Logotipo Theano .................................................................................... 25
Ilustración 12. Logotipo TensorFlow ............................................................................. 26
Ilustración 13. Logotipo Pytorch .................................................................................... 26
Ilustración 14. Logotipo Keras ....................................................................................... 27
Ilustración 15. Logotipo Edge Impulse .......................................................................... 28
Ilustración 16. Ciclo de trabajo Edge Impulse ............................................................... 28
Ilustración 17. Captura de bienvenida a nuevo proyecto................................................ 29
Ilustración 18. Captura con opciones iniciales sobre el diseño de redes con entrada de
audio ............................................................................................................................... 29
Ilustración 19. Menú desplegable con las diferentes etapas del proyecto. ..................... 29
Ilustración 20. Captura Dashboard del proyecto ............................................................ 30
Ilustración 21. Captura dispositivos conectados. Pestaña Devices ................................ 31
Ilustración 22. Captura de pestaña adquisición de datos. ............................................... 31
Ilustración 23. Captura creación del impulso. ................................................................ 32
Ilustración 24. Captura pestaña Generate features del MFCC. ...................................... 32
Ilustración 25. Captura pestaña Parameters del MFCC .................................................. 33
Ilustración 26. Captura pestaña diseño red neuronal, para edición codificada. .............. 34
Ilustración 27. Captura pestaña diseño red neuronal, para edición con versión
descriptiva ....................................................................................................................... 34
Ilustración 28. Captura opciones de exportación del proyecto. ...................................... 35
Ilustración 29. Comparación del uso de la memoria y el tiempo de inferencia [28] ...... 37
Ilustración 30. Ecosistema de desarrollo STM32Cube .................................................. 37
Ilustración 31. Ciclo de configuración STM32CubeMX ............................................... 39
Ilustración 32. Versiones CMSIS en X-CUBE-AI ......................................................... 39
Ilustración 33. Esquema X-CUBE-AI ............................................................................ 40
Ilustración 34. Graficas de HAR del dataset de la red neuronal de ST. ......................... 41
Ilustración 35, Vista Top B-L475E-IOT01A ................................................................. 43
Ilustración 36. Vista Bottom B-L475E-IOT01A ............................................................ 43
Ilustración 37. Configuración Jumper J4 del dispositivo B-L475E-IOT01A. ............... 45
Ilustración 38. Captura de la tabla con las direcciones I2C del B-L475E-IOT01A. ...... 47
Ilustración 39. Esquemático sensor acelerómetro LSM6DSL. ...................................... 47
Ilustración 40. Esquematico boton reset del dispositivo B-L475E-IOT01A. ................ 47
Ilustración 41. Esquematico botón de usuario del dispositivo B-L475E-IOT01A......... 48
Ilustración 42. Esquemático LEDs de usuario del dipositivo B-L475E-IOT01A .......... 48
Ilustración 43. Captura de la tabla de los puertos de los botones y los LEDs deldispositivo B-L475E-IOT01A. ....................................................................................... 49
Ilustración 44. Captura selección espacio de trabajo en STM32CubeIDE..................... 54

Ilustración 45. Captura creación de un nuevo proyecto en STM32CubeIDE ................ 54
Ilustración 46. Captura del Target Selection en STM32CubeIDE ................................. 54
Ilustración 47. Captura Setup Proyect en STM32CubeIDE ........................................... 55
Ilustración 48. Captura ventana de inicialización de todos los periféricos en
STM32CubeIDE ............................................................................................................. 55
Ilustración 49. Esquemático sensor acelerómetro LSM6DSL. ...................................... 56
Ilustración 50. Esquemático del B-L475E-IOT01A1 pines PA, PB,PC ........................ 56
Ilustración 51. Esquemático del B-L475E-IOT01A1 pines PD y PE............................. 56
Ilustración 52. Captura detalle selección Select Components ........................................ 57
Ilustración 53. Captura Software pack component selector detalle sensor LSM6DSL.. 57
Ilustración 54. Captura detalle configuración I2C2........................................................ 58
Ilustración 55. Captura detalle configuración GPIO ...................................................... 58
Ilustración 56 . Captura detalle configuración NVIC ..................................................... 59
Ilustración 57. Captura detalle configuración MEMS .................................................... 59
Ilustración 58. Extraxto manual de usuario del dispositivo B-L475E-IOT01A ............. 59
Ilustración 59. Esquemático del dispositivo B-L475E-IOT01A. Detalle configuración
puertos USART. ............................................................................................................. 60
Ilustración 60. Captura configuración USART1 ............................................................ 60
Ilustración 61. Captura detalle selección Select Components ........................................ 61
Ilustración 62. Captura Software pack component selector detalle Core de X-CUBE-AI
........................................................................................................................................ 61
Ilustración 63. Captura detalle configuración X-CUBE-AI ........................................... 62
Ilustración 64. Captura consola al analizar el modelo. ................................................... 62
Ilustración 65. Captura detalle tick analyze.................................................................... 63
Ilustración 66. Captura consola al validar el modelo ..................................................... 63
Ilustración 67. Captura detalle parametros de validación............................................... 64
Ilustración 68. Grafico del uso de la memoria por capa. ................................................ 64
Ilustración 69. captura información de cada capa .......................................................... 65
Ilustración 70. Captura detalle configuración timer ....................................................... 66
Ilustración 71Captura detalle Generar código ................................................................ 66
Ilustración 72Donde se introduce el código ................................................................... 67
Ilustración 73. Captura archivo network_data con los pesos de la red........................... 67
Ilustración 74. Captura New Connection Tera Term. .................................................... 68
Ilustración 75. Captura menú Setup en Tera Term ......................................................... 68
Ilustración 76. Captura ventana Serial port en Tera Term ............................................. 68
Ilustración 77. Captura salida Programa entrenamiento en Tera Term .......................... 69
Ilustración 78. Captura Proyect Manager detalle Toolchain /IDE ................................. 69
Ilustración 79. Captura Tera Term Programa de entrenamiento de la red. .................... 78
Ilustración 80. Graficas diferentes tipos de movimientos 1 ........................................... 81
Ilustración 81. Graficas diferentes tipos de movimientos 2 ........................................... 82
Ilustración 82. Captura configuración Properties. Detalle -u_print_float .................... 105
Ilustración 83. Captura consola. Detalle error Malloc.................................................. 106
Ilustración 84. Captura configuración Properties. Detalle Malloc ............................... 106
Ilustración 85. Captura salida programa principal en Tera Term ................................. 107
Ilustración 86. Diagrama de Gantt ................................................................................ 108
Ilustración 87. Tabla pines Discovery Kit .................................................................... 119
Ilustración 88. Diferentes esquemáticos del Discovery Kit 1 ...................................... 120
Ilustración 89. Diferentes esquemáticos del Discovery Kit 2 ...................................... 121

https://d.docs.live.net/4580135ffe976ee5/Documentos/TFG_deepLearning%20(2).docx#_Toc75278508
https://d.docs.live.net/4580135ffe976ee5/Documentos/TFG_deepLearning%20(2).docx#_Toc75278509

Índice de tablas
Tabla 1. Presupuesto del proyecto ................................................................................ 108

Acrónimos

AI Artificial Intelligence
API Application Programming Interfaces
ARM Advanced Risc Machine
CPU Central Processing Unit
DL Deep Learning
DSP Digital Signal Processor
HAL Heuristically Programmed Algorithmic
HSV Hue, Saturation, Value
I2C Inter Integrated Circuits
IA Inteligencia Artificial
IDE Integrated Development Environment
IOT Internet Of Things
JP Jumper
MACC Multiply–Accumulate Operation
MCU Microcontroller Unit
MDK Microcontroller Development Kit
MEMS Microelectromechanical Systems
MFCC Mel Frequency Cepstral Coefficients
ML Machine Learning
NN Neural Network
RAM Rando Access Memory
RGB Red Green Blue
TF TensorFlow
UART Universal Asynchronous Receiver/Transmitter
UNESCO United Nations Educational, Scientific And Cultural Organization
USART Universal Synchronous/Asynchronous Receiver/Transmitter
USB Universal Serial Bus
VCC Common Collector Voltage

Capítulo 1. Introducción y objetivos del proyecto.

1.1 Introducción del proyecto
La inteligencia artificial (IA) en estos últimos días, ha dejado atrás la ciencia ficción y los
laboratorios de investigación para abrirse al mundo profano [1]. La vida empresarial se
ha visto sumergida en una gran revolución tecnológica. La revolución de los datos [2].
¿Pero quién tiro la primera piedra? El primer referente histórico en la materia es Alan
Turing, Cuando en 1950 publicaba un artículo titulado «Computing machinery and
intelligence» en la revista Mind, donde lanzaba al mundo la pregunta ¿Pueden las
maquinas pensar? El método propuesto en aquellas líneas, el Test de Turing, contiene los
fundamentos teóricos de la IA actual [3].

Desde ese momento a la actualidad, la inteligencia artificial fue ganando terreno con hitos
históricos como la victoria en 1997 del Deep Blue de IBM al campeón mundial de
Ajedrez, Gari Kasparov [4]. Un poco más adelante, en 2005, comenzaron a despuntar las
técnicas de aprendizaje profundo, un enfoque basado en la neurociencia, inspirado por los
estudios de Santiago Ramón y Cajal acerca de cómo funcionaba el sistema nervioso [5]
[6]. Esta técnica basada en redes neuronales y principiosmatemáticos generales empezó
a estudiarse en contextos de investigación e innovación hasta su irrupción en 2012. La
aparición de los asistentes virtuales Siri, Cortana y Google Now aparecieron entre las
primeros productos que hacían uso de esta novedosa técnica [7].

En la actualidad, la inteligencia artificial se ha convertido en una de las competencias más
demandas del mercado. Existiendo más oferta que demanda. La demanda aumentó un
92% en España en tan solo dos años y en IMF School calculan que para 2022, el trabajo
de una de cada cinco personas estará relacionada con la inteligencia artificial [8].

La aparición de estos nuevos perfiles de trabajo da pie a la gran necesidad de las diferentes
instituciones en crear material y herramientas de formación que ayuden a equilibrar la
balanza.

1.2 Contexto
A raíz de esta necesidad de formar diferentes perfiles es necesario en primer lugar
diferenciar entre los tres conceptos más conocidos relacionados con este ámbito y que
pueden generar confusión en la lectura de noticias, documentos especializados o
búsqueda de información. Esta figura representa gráficamente, la relación que existe entre
Artificial Intelligence, Machine Learning y Deep Learning.

Ilustración 1. Artificial Intelligence, Machine Learning y Deep Learning. [9]

• La inteligencia artificial (Artificial Intelligence): se puede definir como el
esfuerzo por automatizar las tareas intelectuales que normalmente realiza una
persona. Esta abarca el aprendizaje automático y el aprendizaje profundo pero
incluye más enfoques que no implican ningún aprendizaje. Como los programas
de ajedrez, que solo contaban con reglas codificadas por programadores y que no
implicaban al aprendizaje profundo. Este tipo de soluciones, conocidas como IA
Simbólica, popular en los ochenta, solo resuelve problemas bien definidos como
el ajedrez pero no son extrapolables a problemas más complejos como el
reconocimiento de voz o de imágenes [9].

• El aprendizaje automático (Machine Learning): busca responder a la pregunta de
si un ordenador sería capaz de aprender por sí mismo a realizar una tarea
específica solo mirando los datos. Es decir, en lugar que los programadores
diseñen las reglas de procesamiento de datos, sean las maquinas las que aprendan
a hacerlo introduciendo los datos de entrada y salida del problema a resolver.
Estos sistemas necesitan un entrenamiento, en lugar de ser programados. Estos
sistemas están orientados a la ingeniería. Es una disciplina practica en las que las
ideas se prueban más empíricamente que de forma teórica [9].

Para hablar del deep learning es necesario hablar de representaciones. Una representación
es ver los datos bajo un determinado enfoque. Una imagen se puede codificar en RGB,
donde es más fácil identificar un color, o en HSV, donde podemos ajustar mejor la
saturación por ejemplo. Son dos representaciones diferentes de los mismos datos. La tarea
a resolver será la que determine el tipo de representación que mejor casa con el problema.

• El aprendizaje profundo (Deep Learning): El aprendizaje profundo es un
subcampo del aprendizaje automático basado en capas sucesivas de
representaciones cada vez más significativas. El número de capas es lo que
constituye la profundidad del modelo. Normalmente cuenta con decenas o
centenas de capas sucesivas. Cuando se habla de una o dos capas se trata de
aprendizaje superficial [9].

Este último término, es el que se desarrolla en las líneas de este proyecto.

1.3 Justificación y objetivos del trabajo fin de grado
Un estudio de Juniper Research estima que para 2024 existirán 83.000 millones de
conexiones IoT. Esto representa un crecimiento del 130% en los próximos cuatro años
[10]. Este aumento de dispositivos conectados a la red va a generar en un futuro próximo
problemas en el ancho de banda de la red. Creando problemas de latencia. La alta
dependencia de las aplicaciones conectadas a la nube dificulta su implementación en áreas
con poca o nula conectividad a la red. En respuesta a este problema las tecnologías Edge
Computing se presentan como una solución probable. Esta técnica ayudaría a reducir
considerablemente la sobrecarga de la red, ahorrando energía para la comunicación de
datos y reducir la latencia.

Las soluciones basadas en Deep Learning han conseguido muy buenos resultados en
aplicaciones complejas, como el procesamiento del lenguaje natural, la clasificación de
imágenes, el reconocimiento facial, etc. Estas aplicaciones requieren en muchas
ocasiones de ciertos recursos hardware para llevar acabo sus operaciones de cálculo. Por
eso las aplicaciones implantan sus soluciones a través de servicios en la nube conectados
a servidores de alto rendimiento. Esto potencia la aparición de sistemas IoT [11].

Este proyecto se presenta partidaria de las tecnologías “in the Edge” que buscan
desarrollar aplicaciones de deep learning en microcontroladores, en este caso ARM. Con
los retos que plantean estas tecnologías. Donde los modelos entrenados se tienen que
comprimir para reducir el tamaño de la red neuronal y evitar cálculos de punto flotante
que tienen un mayor coste computacional.

Los principales objetivos de este proyecto se pueden desglosar en:

• Presentar una guía práctica a seguir para implementar una red neuronal desde la idea
a la implementación. Como crear un modelo, como entrenar la red neuronal y cómo
obtener la aplicación funcional de inferencia en un microcontrolador de
STMicroelectronics de Cortex de la familia M.

• Realizar una aplicación sencilla y funcional que siga las pautas de la guía presentada.

1.4 Metodología de trabajo
La metodología de trabajo seguida para desarrollar este proyecto se puede dividir en tres
fases:
• Estudio: En primer lugar se desarrolla un proceso de documentación y formación en
los conceptos teóricos y prácticos. Donde se estudian las redes neuronales, cómo
funcionan, los tipos que hay, las aplicaciones que existen para microcontroladores. Las
limitaciones que pueden existir. Se emplean buscadores especializados para encontrar
documentación útil donde se revisan repositorios Github, se localizan papers, cursos
de formación online, etc.
• Diseño: Una vez adquiridos los conocimientos teóricos y prácticos se elabora una línea
secuencial de los procesos a seguir en la guía. Desde la idea hasta la implementación,
viendo que herramientas son necesarias en cada momento y que información útil se ha
recopilado para desarrollar cada parte. Conjuntamente se piensa un ejemplo de red
neuronal para implantarse en la fase de diseño y entrenamiento de la red.
• Implementación y pruebas: Se ejecuta el diseño planeado y se realizan las pruebas y
test con diferentes entradas para garantizar el correcto funcionamiento del sistema y
poder sacar conclusiones para su implementación final. En esta fase se realiza la
elaboración de la memoria recogiendo todos los pasos con capturas y anotaciones .
Finalmente se realiza la memoria que detalle todo el proceso seguido para elaborar el
proyecto.

Ilustración 2. Fases de la metodología de trabajo del proyecto.
Proceso
documentación
Diseño de la
solución
Implementación Pruebas Memoria

1.5 Organización de la memoria
En este documento queda recogida la memoria del proyecto donde se explica su
desarrollo, tras la introducción presentada en el presente capitulo, el trabajo se estructura
de la siguiente forma:
Capítulo 2 – Estado del arte: En este capítulo se recogen los conceptos teóricos y prácticos
necesarios para la elaboración de este proyecto. Abarcando que son las redes neuronales,
cómo funcionan, los tipos que hay. Una introducción al ML embebido y los desarrollos
existentes en la materia, comentando las librerías principales y las herramientas y
plataformas de desarrollo actuales. Se comentaran también las herramientas de
STMicroelectronics y las característicasdel dispositivo empleado. Así como la red
neuronal inicial.
Capítulo 3 – Planteamiento del problema y Diseño de la solución. En este capítulo se
aborda el diseño del sistema y la configuración del entorno.
Capítulo 4 – Implementación y pruebas: En este capítulo se presenta el desarrollo práctico
de este proyecto. Se justifica la elección de las herramientas utilizadas así como una guía
detallada de pasos a seguir para implementar una red en un microcontrolador Cortex-M.
Capítulo 5 – Conclusiones y trabajos futuros: En este capítulo se recogen las conclusiones
del proyecto y se enumeran posibles trabajos futuros.

Capítulo 2. Estado del arte.

2.1 Conceptos teóricos

2.1.1 Introducción a Redes Neuronales Artificiales

Cuando se habla de redes neuronales es importante hablar sobre el aprendizaje profundo
y cómo los recientes avances en este campo han llevado a desarrollar increíbles
aplicaciones. Algunas de estas implementaciones son la restauración del color, donde una
imagen en escala de grises es automáticamente convertida en una de color [12]. La
generación automática de escritura a mano. Otra aplicación es la traducción automática,
donde las redes neuronales convolucionales se utilizan para traducir texto en una imagen
sobre la marcha [13]. Otra aplicación interesante es la agregación automática de sonidos
a las películas del cine mudo, donde un modelo utiliza una base de datos de sonidos
pregrabados para seleccionar el sonido que mejor encaje con lo que está sucediendo en la
escena [14]. No se pueden dejar fuera las populares aplicaciones de clasificación de
objetos en imágenes y los coches de conducción autónoma.

Todos estos algoritmos basados en el aprendizaje profundo están inspirados en gran
medida por la forma en que funcionan las neuronas y las redes neuronales. Las redes
neuronales fueron dibujadas por primera vez por Santiago Ramón y Cajal, en 1899
después de colocar la lente del microscopio en el cerebro de una paloma. Santiago es
conocido como el padre de la neurociencia moderna [5].

Ilustración 3. Esquema neurona y neurona artificial.
Las redes neuronales artificiales generalmente se dividen en diferentes capas, la primera
capa, donde se introducen los datos en la red se conoce como la capa de entrada. El
conjunto de nodos que proporciona la salida de la red se llama capa de salida. Y cualquier
conjunto de nodos entre las capas de entrada y salida se denominan capas ocultas [15].

Ilustración 4. Esquema red neuronal artificial.

Cuando se trabaja con redes neuronales, los tres temas principales a tratar son la
propagación directa (forward propagation), la retro propagación (back propagation), y
las funciones de activación (Activation functions).

2.1.2 Conceptos a tener en cuenta en redes neuronales.

La propagación directa

La propagación directa es el proceso a través del cual los datos pasan a través de capas
de neuronas en una red neuronal desde la capa de entrada hasta la capa de salida.

Ilustración 5. Esquema pesos neurona.

• Cada conexión tiene un peso específico por el cual se regula el flujo de datos.
• x1 y x2 son los valores de entrada, estos pueden ser int o float.
• Cuando las entradas pasan a través de las conexiones se ajustan dependiendo de los
pesos de conexión, w1 y w2.
• La neurona procesa entonces esta información generando una suma ponderada de
estas entradas y agrega una constante a la suma que se conoce como el sesgo (b1).
• Quedando a la salida la combinación lineal de las entradas y pesos junto con el
sesgo (z).

Sin embargo, simplemente la salida de una suma ponderada de las entradas no va a
resolver gran cosa. Es necesario realizar un mejor procesamiento de los datos, esto se
hace asignando la suma ponderada a un espacio no lineal. Estas transformaciones no
lineales se conocen como funciones de activación y son otra importante característica de
las redes neuronales. Una red neuronal sin una función de activación es únicamente un
modelo de regresión lineal [16].

Funciones de activación, descenso del gradiente y gradiente de fuga.

Las funciones de activación deciden si una neurona debe ser activada o no. Viendo si la
información que la neurona está recibiendo es relevante o debe ser ignorada. La función
de activación realiza la transformación no lineal a la entrada permitiendo a la red neuronal
realizar tareas más complejas, como clasificaciones de imágenes y traducción de textos.

Una de las funciones que más popularidad tuvo fue la función sigmoide, donde si la suma
ponderada es un número positivo muy grande, entonces la salida de la neurona está cerca
de uno, y si la suma ponderada es un número negativo muy grande, entonces la salida de
la neurona está cerca de cero.

Es importante también conocer qué es el descenso del gradiente. Principalmente consiste
en un algoritmo de optimización iterativo para encontrar el mínimo de una función. Para
realizar esta tarea, se toman pasos proporcionales a el negativo del gradiente de la función
en el punto actual. Cuanto mayor sea la tasa de aprendizaje, mayor es el paso que se da,
y cuando menor es la tasa de aprendizaje, más pequeño es el paso que hay que dar. En
este punto, se reajustan los pesos y se repite el mismo proceso. El nuevo peso es el antiguo
peso menos la tasa de aprendizaje. Este paso se repite hasta alcanzar el mínimo o un valor
de la función de costo que está muy cerca del mínimo , dentro de un pequeño umbral
predefinido. Hay que ser cuidadoso a la hora de elegir la tasa de aprendizaje, ya que una
gran tasa de aprendizaje puede conducir a grandes pasos y eventualmente perder el
mínimo. Por otro lado, una pequeña tasa de aprendizaje puede resultar en pasos muy
pequeños y por lo tanto, haciendo que el algoritmo tome mucho tiempo para encontrar el
punto mínimo. Con cada iteración , el peso se actualiza de una manera que es proporcional
al negativo del gradiente de la función en el punto actual . Por lo tanto, si inicializa el
peso a un valor que es a la derecha del mínimo, entonces el gradiente positivo dará como
resultado que se mueva hacia la izquierda hacia el mínimo [16].

Ilustración 6. Representación del descenso del gradiente.
Por otro lado, el entrenamiento de las redes neuronales se realiza en un entorno de
aprendizaje supervisado, donde cada punto de datos tiene una etiqueta correspondiente,
también conocido como la verdad del terreno. El entrenamiento es necesario cuando el
valor predicho por la red neuronal claramente no coincide con la verdad del terreno para
una entrada dada.

El algoritmo de entrenamiento se puede resumir en los siguientes pasos:

En primer lugar se inicializan los pesos y sesgos a valores aleatorios.

Luego se repiten iterativamente los siguientes pasos :

1. Se calcula la salida de red utilizando la propagación directa.
2. Se calcula el error entre la verdad del terreno y la salida estimada o pronosticada de
la red.
3. Se actualizan los pesos y los sesgos a través de la retro propagación.

Estos tres pasos se repiten hasta que se alcance el número de iteraciones o épocas, o el
error entre la verdad del terreno y la salida prevista esté por debajo de un umbral
predefinido.

La función de activación sigmoide tiene un problema, el gradiente de fuga . El uso de
esta función provoca que todos los valores intermedios en la red estén entre 0 y 1. Así
que cuando se realiza la retro propagación se siguen multiplicando factores que están
entre 0 y 1, provocando que sus gradientes tiendan a hacerse cada vez más y más pequeños
a medida que se propaga hacia atrás dentro de la red. Esto significa quelas neuronas en
las primeras capas aprenden más lento en comparación con las neuronas en las últimas
capas de la red. Las primeras capas de la red son las más lentas de entrenar. El resultado
es un proceso de entrenamiento que lleva demasiado tiempo y la precisión de las
predicciones queda comprometida. En consecuencia, esta es la razón por la que no se usan
la función sigmoide o funciones similares como funciones de activación, ya que son
propensas al problema del gradiente de fuga. Existen otras funciones de activación para
utilizar en las capas ocultas, y que ayudan a superar este problema [16].

Las funciones de activación juegan un papel importante en el proceso de aprendizaje de
una red neuronal entre las más eficientes y las que presentan un mayor número de
aplicaciones están:

• La función binaria de paso (Binary Step Function),
• La función lineal (Linear Function)
• La función sigmoide (Sigmoid Function)
• La función tangente hiperbólica (Hyperbolic Tangent Function).
• La función lineal rectificada unidad (RelU)(Rectified Linear Unit)
• La función RelU de fuga (Leaky RelU)
• La función Softmax (Softmax Function)

La función sigmoide

Ilustración 7, Función Sigmoide
En esta función, si la suma ponderada es un número positivo muy grande, entonces la
salida de la neurona está cerca de uno, y si la suma ponderada es un número negativo muy
grande, entonces la salida de la neurona está cerca de cero.

El problema que presenta es que la función es bastante plana más allá de la región +3 y -
3 . Esto significa que una vez que la función cae en esa región, los gradientes se vuelven

muy pequeños dando como resultado el problema del gradiente de y a medida que los
gradientes se acercan a 0, la red realmente no aprende. Otro problema con la función
sigmoide es que los valores solo varían de 0 a 1. Esto significa que la función sigmoide
no es simétrica alrededor del origen

La función tangente hiperbólica

Ilustración 8. Función tangente hiperbólica

Esta es la función tangente hiperbólica , o tanh. Es muy similar a la función sigmoide. Es
en realidad solo una versión escalada de la función sigmoide, pero a diferencia de la
primera, es simétrica sobre el origen. Va de -1 a +1. Sin embargo, aunque supera la falta
de simetría, también conduce al problema del gradiente de fuga en redes neuronales muy
profundas.

La función rectificada de unidad lineal (ReLU)

Ilustración 9. Función rectificada de unidad lineal (ReLU)
La función rectificada de unidad lineal, o ReLU, es la función de activación más utilizada
al diseñar redes hoy en dia. Además de ser no lineal, la principal ventaja de usar la función
ReLU, sobre las otras funciones de activación es que no activa todas las neuronas al
mismo tiempo. De acuerdo con la trama, si la entrada es negativa se convertirá a 0, y la
neurona no se activa. Esto significa que a la vez, sólo unas pocas neuronas se activan,
haciendo que la red sea más ligera y por consiguiente más eficiente. Además, la función
ReLU fue uno de los principales avances en el campo del aprendizaje profundo que
condujo a superar el problema de la fuga de gradiente.

La función Softmax

Ilustración 10. Función Softmax

La función Softmax también es un tipo de función sigmoide , pero es útil cuando estamos
tratando de manejar problemas de clasificación. La función Softmax se utiliza idealmente
en la capa de salida del clasificador donde estamos tratando de obtener las probabilidades
para definir la clase de cada entrada. Por lo tanto, si una red con 3 neuronas en la capa de
salida salidas [1.6, 0.55, 0.98] entonces con una función de activación Softmax , las salidas
se convierten a [0.51, 0.18, 0.31] para que en total la suma de todos los valores de 1. De
esta manera, es más fácil para nosotros clasificar un punto de datos dado y determinar a
qué categoría pertenece.

Conclusiones sobre los conceptos de redes neuronales:

• El sigmoide y las funciones tanh se evitan en muchas aplicaciones hoy en día ya
que pueden conducir al problema de fuga del gradiente.

• La función ReLU es la función que es ampliamente utilizada hoy en día, y es
importante tener en cuenta que sólo se usa en las capas ocultas.

• Finalmente, al construir un modelo, puede comenzar con la función ReLU y luego
puede cambiar a otras funciones de activación si la opción de la función ReLU no
ofrece un buen rendimiento .

• La función Softmax se utiliza idealmente en la capa de salida del clasificador
donde estamos tratando de obtener las probabilidades para definir la clase de cada
entrada.

2.1.4 Introducción a Machine Learning Embebido (TinyML)

Los recientes avances en la arquitectura de microprocesadores y el diseño de algoritmos
han conseguido ejecutar sofisticadas aplicaciones de Machine Learning en pequeños
integrados, la rama del Machine Learning encargada de diseñar y llevar a cabo estas
aplicaciones se conoce como TinyML [17]. Algunas de las ventajas que presentan estos
dispositivos se presentan con el acrónimo acuñado por Jeff Bier como BLERP por las
siglas en ingles de los siguientes términos [18]:

• Bandwidth (Ancho de banda): Los algoritmos ML en dispositivos periféricos
pueden obtener información significativa de datos que no podría realizarse de otro
modo debido al ancho de banda. En un espacio inundado de cámaras como un
casino o un invernadero, no existe forma de subir a la nube toda la información
recopilada, saturaría la red. Se tienen que manejar localmente.

• Latency (Latencia): Los modelos embebidos en dispositivos pueden responder en
tiempo real, aplicaciones como los coches autónomos no serían viables si
dependieran de la latencia de su conexión a internet.

• Economics (Economía): Se evitan gastos de transmisión de datos a través de una
red y de recursos de procesamiento en la nube. A pesar del abaratamiento de las
conexiones y el procesamiento computacional, pueden potencialmente suponer un
gran gasto en conjunto.

• Reliability (Fiabilidad): Los modelos controlados localmente son más fiables que
los dependientes de una conexión a internet. Si se usa el reconocimiento facial
para desbloquear el teléfono o abrir su casa, si no tiene conexión no podrá acceder
a ello.

• Privacy (Privacidad): Si la información se procesa en el sistema y no se transmiten
a la nube serán más seguros y se tendrá una privacidad mayor, nadie podrá
interceptar o abusar de la información.

A pesar de lo poderosa que puede resultar esta tecnología, algunas de las limitaciones que
se pueden encontrar en el Machine Learning y en mayor rango en TinyML son:

• Los resultados obtenidos son estimaciones y aproximaciones, no respuestas
exactas.
• Los modelos pueden necesitar una gran capacidad computacional de ejecución en
casos complejos.
• Los datos de entrenamiento pueden requerir mucho tiempo y ser costosos de
obtener.

Mas concretamente en el caso de TinyML:

• Cuenta con un número limitado de operaciones, debido a su capacidad de cálculo
limitada. Por tanto, las estimaciones que realicen, en consecuencia tendrán que ser
simplificadas.

2.2 Desarrollos existentes

2.2.1 Bibliotecas principales

Es importante antes de empezar a desarrollar una aplicación IA en dispositivos embebidos
de bajo coste, conocer las diferentes bibliotecas y marcos de aprendizaje que existen. Para
ello se puede empezar por recapitular las principales líneas de trabajo existentes que
pueden resultar interesantes para el desarrollo del proyecto.

Theano

Ilustración 11. Logotipo Theano

En el año 2007, el Instituto de Algoritmos de Aprendizaje de Montreal elaboró una
biblioteca llamada Theano, en su momento fue la biblioteca principal de aprendizaje
profundo. Sin embargo, sus fundadores no pudieron permitirse apoyarlo y mantenerlo en
el tiempo por lo que la librería perdió su popularidad [19].

TensorFlowIlustración 12. Logotipo TensorFlow
Cogiendo el relevo, la tecnológica Google elabora TensorFlow, actualmente la librería
más popular y que se utiliza principalmente en la elaboración de modelos. Su gran
comunidad y el respaldo de Google la posicionan en el ranking. Se lanzó al público en
2015 y sigue utilizándose activamente en investigación y producción. TensorFlow se
define como una plataforma de código abierto, flexible que permite a investigadores y
desarrolladores implementar redes neuronales en aplicaciones [20].

A parte de su biblioteca principal cuenta con bibliotecas complementarias como:

• TensorFlow.js permite entrenar e implementar modelos en el navegador a través
de JavaScript.

• TensorFlow Lite permite implementar modelos en móviles y dispositivos
integrados. Como limitación, este sistema no permite realizar el entrenamiento
sobre el dispositivo, sino que solo permite integrar redes ya entrenadas.

• TensorFlow Extended permite entrenar, validar e implementar modelos en
entornos de gran producción.

Pytorch

Ilustración 13. Logotipo Pytorch
Facebook no se hizo esperar, en 2016 lanza Pytorch, que admitía algoritmos de
aprendizaje que se ejecutan en GPU. Pytorch es relativamente nuevo en comparación
con TensorFlow pero está ganando popularidad en áreas de investigación donde es
necesario la optimización de expresiones personalizadas. A diferencia de TensorFlow,
Pytorch trabaja con grafos dinámicos, es decir, en ejecución se pueden modificar las
funciones y en consecuencia se modificara el cálculo del gradiente .

Keras

Ilustración 14. Logotipo Keras
A pesar de su popularidad, ambas (Pytorch y TensorFlow) cuentan con una curva de
aprendizaje pronunciada. En este punto entra en escena la librería Keras.

Keras es una API sobre TensorFlow escrita en Python, de alto nivel, ideal para personas
que recién empiezan a entrar en contacto con el aprendizaje profundo. Su facilidad de uso
y su simplicidad sintáctica permiten generar modelos de aprendizaje profundo con unas
pocas líneas de código. En su web se enfocan en que su principal virtud es la rapidez de
pasar de la idea al resultado, clave en la realización de una buena investigación [21].

El flujo típico de trabajo en Keras es el siguiente:

1. Se definen los datos de entrenamiento: tensores de entrada y tensores objetivo.
2. Se define una red de capas (o modelo) que mapee de las entradas a los objetivos.
3. Se configura el proceso de aprendizaje eligiendo una función de pérdida, un
optimizador y algunas métricas para monitorear.
4. Se iteran los datos de entrenamiento llamando al método fit() del modelo.

Hay dos formas de definir un modelo: utilizando la clase Sequential (solo para pilas
lineales de capas, que es la arquitectura de red más común con diferencia) o la API
funcional (para gráficos acíclicos dirigidos de capas, que le permite construir
arquitecturas completamente arbitrarias).

Una vez que se define la arquitectura del modelo, no importa si se utilizó un modelo
secuencial o la API funcional. Todos los pasos que siguen a este son iguales. El proceso
de aprendizaje se configura en el paso de compilación, donde se especifica el optimizador
y las funciones de pérdida que se deben usar en el modelo, así como las métricas que se
desean monitorear durante el entrenamiento. Finalmente, el proceso de aprendizaje
consiste en pasar matrices Numpy de datos de entrada (y los datos de destino
correspondientes) al modelo a través del método fit() [9].

Como conclusión, Se puede emplear la librería Keras para realizar un modelo
rápidamente o si se está aprendiendo, pero si se desea tener más control sobre las
diferentes cuestiones que involucran una red es mejor emplear Pytorch o TensorFlow.

Si se quiere más información sobre redes neuronales en Keras, el libro Deep Learning
with Python, es el sitio idóneo para hacerlo [9].

2.2.2 Herramientas y plataformas de desarrollo

Edge Impulse

Ilustración 15. Logotipo Edge Impulse
Edge Impulse aparece en 2019, como una plataforma para el desarrollo de aplicaciones
de ML en sistemas embebidos. Cuenta con el respaldo de grandes fabricantes del sector
como ARM, STMicroelectronics y Arduino entre otros. Ofrece soporte, según se
incrementa su popularidad, a sistemas compatibles en los que cargar el modelo que se
genere en la plataforma, en caso de no contar con soporte nativo permite convertir el
modelo a una librería en C++ o Java. Entre las placas a las que se ofrece soporte se
encuentra B-L475E-IOT01A, el microcontrolador Cortex-M empleado en este proyecto
[22].

Una de las principales ventajas que ofrece Edge Impulse es cómo permite desarrollar
aplicaciones de ML sin necesidad de escribir ni una línea de código. Ofrece soporte en
todas las partes del proceso ML acelerando el desarrollo de los proyectos, que pueden ser
implementados tanto en MCUs como en CPUs. Su ciclo de trabajo es el siguiente:

Ilustración 16. Ciclo de trabajo Edge Impulse
Las herramientas están centradas en la manipulación de datos, adquisición, visualización,
análisis, procesamiento y filtrado y creación de datasets entre otras opciones.

A continuación se muestran algunas capturas de un ejemplo de una red entrenada para
detectar un silbido generado para este proyecto. Una aplicación que podría resultar como
un primer paso para la detección de silbidos más concretos, útil para la traducción del
Silbo Gomero, el lenguaje silbado de La Gomera que fue declarado en 2009 Patrimonio
Cultural Inmaterial de la Humanidad por la UNESCO [23].

En primer lugar al crear un proyecto, se ofrecen diferentes opciones de proyectos, desde
lecturas en acelerómetro, escuchas de audio, reconocimiento de imágenes, o cualquier
otro sensor conectado.

Ilustración 17. Captura de bienvenida a nuevo proyecto
Para cada uno, ofrecerá conectar una placa de desarrollo, importar datos y ofrece
tutoriales paso a paso con ejemplos de aplicaciones sencillas. En este caso se ha seguido
el tutorial para reconocimiento de audio [24]. Pero en este caso aplicarlo a silbidos.

Ilustración 18. Captura con opciones iniciales sobre el diseño de redes con entrada de audio

Una vez iniciado, se presenta un desplegable, a la izquierda, con los diferentes pasos a
seguir dentro del proyecto de ML.

Ilustración 19. Menú desplegable con las diferentes etapas del proyecto.

La ventana principal, Dashboard, presenta un resumen del proyecto, con información de
la adquisición de datos, los dispositivos conectados, los colaboradores del proyecto,
opciones de descarga y de configuración general del proyecto.

Ilustración 20. Captura Dashboard del proyecto

En Devices, se pueden apreciar los dispositivos conectados al proyecto, en este caso
R2D2, es el microcontrolador B-L475E-IOT01A.

Ilustración 21. Captura dispositivos conectados. Pestaña Devices

En la adquisición de datos, se han recogido dos tipos de datos, audios con ruido y audios
con silbidos. Se han recogido 11 minutos de audio en total. Como se puede apreciar en la
captura se ofrecen diferentes opciones de configuración de los datos. A la hora de entrenar
la red es importante capturar diferentes situaciones. Situaciones de ruido como puede ser
silencio, personas hablando, ruido de la calle y Situaciones de silbido, en las que
únicamente se oiga un silbido, un silbido mientras se graba personas hablando, etc.

Ilustración 22. Captura de pestaña adquisición de datos.

En cuanto a la creación del impulso, tenemos en un primer lugar un cuadro de mando
donde aparecen las diferentes partes de la misma:

Ilustración 23. Captura creación del impulso.
A continuación se muestran las diferentes capturas del MFCC para procesar el audio, con
los parámetros y las características generales, se pueden observar algunos gráficos que
representan larecolección de datos de audio.

Ilustración 24. Captura pestaña Generate features del MFCC.

Ilustración 25. Captura pestaña Parameters del MFCC

En la siguiente captura se puede configurar la red neuronal en Keras, así como ver
diferentes datos de precisión y perdidas. Se puede optar por configurar la red a través de
una versión descriptiva como se observa en la segunda captura.

Ilustración 26. Captura pestaña diseño red neuronal, para edición codificada.

Ilustración 27. Captura pestaña diseño red neuronal, para edición con versión descriptiva

Como se menciona anteriormente, la red neuronal generada se puede exportar aunque no
se cuente con alguno de los dispositivos recomendados por la plataforma. Puedes crear
una librería C++ o Un librería Arduino entre las diferentes opciones que se presentan en
la captura.

Ilustración 28. Captura opciones de exportación del proyecto.

Antes de concluir este apartado, como curiosidad, su Cofundador Jan Jongboom sigue
respondiendo el mismo a todas las cuestiones que se plantean en el blog oficial de Edge
Impulse en unos pocos días. Si realizando algun proyecto surgieran dudas, el mismo Jan
será probablemente quien resuelva la duda a través del blog.

TensorFlow Lite para Microcontroladores

Una de las ramificaciones que TensorFlow ofrece es TensorFlow Lite para
Microcontroladores, diseñado para ejecutar modelos de aprendizaje profundo en
microcontroladores u otros dispositivos utilizando unos pocos kilobytes de memoria. No
requiere compatibilidad con el sistema operativo, ni ninguna biblioteca C ni asignación
dinámica de memoria. El sistema se probó exhaustivamente con arquitecturas ARM
Cortex-M y se ha probado en otras arquitecturas como ESP32 [25].

El flujo de trabajo consiste en entrenar un modelo y realizar inferencias. Al entrenar el
modelo se siguen tres pasos:

1. Generar el modelo de TensorFlow que pueda adaptarse al dispositivo usando las
operaciones compatibles
2. Realizar la conversión a un modelo TensorFlow Lite con el conversor de
TensorFlow Lite [26].
3. Convertir a un arreglo de bytes en C para almacenarlo en una memoria de solo
lectura en el dispositivo.

La plataforma ofrece diferentes ejemplos en diferentes placas, pero desafortunadamente
la documentación en este punto es liosa y cada ejemplo sigue una línea diferente de
trabajo enfocada a un único dispositivo. Además de esto se deben tener en cuenta las
siguientes limitaciones:

• La compatibilidad del sistema con el conjunto de operaciones que se permiten usar de
TensorFlow.
• La compatibilidad con el conjunto de dispositivos limitados.
• La API de C++ es a bajo nivel y se necesita la administración manual de la memoria.
• No es compatible con el entrenamiento en dispositivos.

CMSIS-NN

CMSIS-NN se describe en la biblioteca CMSIS como una colección de núcleos de redes
neuronales eficientes, desarrollados para maximizar el rendimiento y minimizar el uso de
memoria en núcleos de procesador Cortex-M. La biblioteca se divide en una serie de
funciones (Convolución, activación, agrupación, Softmax, funciones de capa y de
matemáticas básicas), clasificadas en dos bloques, las funciones heredadas de que
permiten la cuantificación simétrica interna de ARM y las funciones que admiten el marco
de trabajo de TensorFlow Lite con cuantificación simétrica [27].

Actualmente está en desarrollo y aún necesita mejorar en diferentes aspectos como la
seguridad, la validación, la legibilidad del código así como tener una API estable y que
se pueda evitar pasar muchas variables por valor.

Intentar arrancar un proyecto desde este punto, así como intentar realizar una
transformación de una red neuronal basada en TensorFlow, es una tarea titánica que
necesita de un conocimiento exhaustivo de los Núcleos DSP de CMSIS, programación a
bajo nivel y un conocimiento profundo sobre las redes neuronales. Han sido varios los
intentos por integrar esta tecnología en el proyecto. Finalmente se ha realizado una
integración parcial, como se explicara más adelante.

MCUNet

MCUNet se trata de un sistema que ofrece la capacidad de generar redes neuronales
integradas que ofrecen gran precisión y máxima velocidad a pesar de las limitaciones de
memoria, emplea conjuntamente dos tecnologías desarrolladas por el MIT. El algoritmo
de TinyNAS busca la arquitectura de red neuronal que mejor respuesta de a las
limitaciones del sistema como pueden ser la latencia, memoria, tipo de dispositivo, etc. y
ofrece redes de tamaño personalizado al dispositivo. Por su parte, TinyEngine se emplea
como motor de inferencia para dirigir la gestión de recursos, incluyendo los recursos
básicos necesarios para su funcionamiento, adaptando la programación de la memoria de
acuerdo a su tipología de red en vez de optimizar por capas. Todo esto reduce el tiempo
de compilación, el uso de memoria y acelera la inferencia en comparación con el uso de
TF-Lite o CMSIS-NN como se puede observar en la siguiente figura [28].

Ilustración 29. Comparación del uso de la memoria y el tiempo de inferencia [28]

Herramientas de STMicroelectronics
Los fabricantes de microcontroladores presentan, cada vez con más frecuencia, como
parte del software, un entorno de desarrollo donde programar de forma sencilla y hacer
debug sobre sus productos. El ecosistema de STMicroelectronics recibe el nombre de
STM32Cube ecosystem. En él se recogen una combinación de herramientas y librerías
integradas que cubren todas las fases del ciclo de desarrollo de proyectos. Es la
herramienta idónea sobre la que desarrollar proyectos sobre microcontroladores STM32.

Ilustración 30. Ecosistema de desarrollo STM32Cube

A la hora de elaborar el proyecto, se plantearon otras alternativas como el entorno de
MDK, pero el entorno MDK recurría a las herramientas de STM32CubeMX para realizar
la configuración de los periféricos. El uso de sus librerías no termina de compatibilizar,
principalmente cuando se trata de la librería X-CUBE-AI donde era necesario realizar
diferentes modificaciones a bajo nivel que no eran de interés en la elaboración de este
proyecto que busca, ante todo, presentar una solución que no resulte engorrosa de seguir.
Si se quiere adaptar la red a MDK, se ofrecen tutoriales para solucionar algunos de los
problemas que se presentan a la hora de adaptar el proyecto [29] [30]. Se intentó en varias
ocasiones, sin éxito, finalmente se optó por el ecosistema de STMicroelectronics para
tener todas las fases del desarrollo bajo una misma plataforma.
En este proyecto se van a emplear principalmente dos herramientas de STM32Cube, la
herramienta de configuración STM32CubeMX y el entorno de desarrollo
STM32CubeIDE.
STM32CubeIDE
Esta herramienta de desarrollo para C/C++ incluye entre otras cosas, la configuración de
periféricos, generación de código, compilación y debug para los microcontroladores de
la familia STM32. El framework empleado está basado en el framework de Eclipse /CDT
y GCC como toolchain y GDB para realizar acciones de debug. Por tanto, permite la
integración de gran parte de los plugins existentes en el IDE. Su principal ventaja es la
integración de herramientas como STM32CubeMX, dando lugar a menor número de
errores al tener todo dentro del mismo entorno de desarrollo.
STM32CubeMX
La plataforma STM32CubeMX es una herramienta grafica que facilita la configuración
de los microcontroladores de STM32, ayudando a generar el código C necesario para la
inicialización de los kernel ARM Cortex-M. Algunas de las características que presenta
la herramienta son las siguientes:
• Se puede seleccionar fácilmente cualquier dispositivo de la cartera de
microcontroladores de STM32.
• Permite configurar fácilmente los pines, periféricos, reloj y middleware),
generando el código C correspondiente.
• Calcula el consumo de energía para aplicacionesdefinidas por el usuario.
• Las actualizaciones se realizan automáticamente.
• Se pueden generar proyectos para importar a un IDE para una selección de
entornos. Todos los proyectos generados incluyen código C de inicialización,
drivers HAL para STM32 y middleware para la configuración de usuario.
El ciclo de configuración es el siguiente:

Ilustración 31. Ciclo de configuración STM32CubeMX
Software Pack: X-CUBE-IA
Dentro de los Software Packs que se pueden añadir al proyecto, destaca, en proyectos
TinyML, el paquete X-CUBE-AI que es el que permite la introducción de redes
neuronales al proyecto. Donde se proporcionan herramientas de mapeo de NN automática
y avanzada para generar e implementar una implementación de modelo C optimizada y
robusta de una red neuronal (modelo DL) previamente entrenada para los sistemas
integrados con recursos de hardware limitados y restringidos. La biblioteca STM32 NN
generada (tanto partes más especializadas como genéricas) se puede integrar directamente
en un proyecto IDE o en un sistema de compilación basado en archivos MAKE.
Es importante mencionar que papel juega CMSIS-NN, antes mencionado, dentro del
paquete. La biblioteca de tiempo de ejecución de red se basa parcialmente en la biblioteca
CMSIS. CMSIS es una capa de abstracción de hardware independiente del proveedor para
microcontroladores basados en procesadores de Cortex ARM. El subcomponente
CMSIS-NN y una parte menor del subcomponente CMSIS-DSP se incrustan en la
biblioteca network_runtime.a para asegurarse de que los archivos solicitados se compilan
con las opciones óptimas.

Ilustración 32. Versiones CMSIS en X-CUBE-AI
Una parte de las funciones del kernel de reenvío se asignan directamente en el CMSIS-
NN (compatibilidad heredada del formato Qmn) cuando está disponible, pero la parte
principal, son las implementaciones optimizadas (formato entero y flotante) solamente
basadas en las definiciones de tipo CMSIS para la portabilidad en las familias STM32.

Ilustración 33. Esquema X-CUBE-AI

El paquete X-CUBE-AI permite la posibilidad de validar los modelos tanto el PC como
en las placas, así como medir el rendimiento en los dispositivos. Para ello ofrece tres
opciones para desarrollar ágilmente los proyectos, estas aplicaciones son [31]:
• ApplicationTemplate: Actúa a modo de template como base de aplicaciones IA, el
problema es que el propio código creado no imprime texto por pantalla a través del
USART, ya que su template hace uso del printf, pero la función está definida de
forma débil en el código de ST y debe reescribirse. Pero el principal problema es,
como se avisa en el manual, que dicho proyecto no es realmente un template
completo, en realidad, únicamente proporciona la estructura para redes con una unca
entrada y con una única salida y si se desea modificar, lo cual es prácticamente
fundamental para cualquier aplicación IA, es confuso y se necesitan hacer numerosos
cambios en código externo que no está definido en el main.c [32], haciendo un
traspaso de datos complejos, perdiendo de vista el flujo principal del código. Ante
esta problemática, se planteó la idea de crear un framework, añadido en el main que
permita al usuario utilizar una o varias redes neuronales previamente cargadas con
STM32CubeMX, manteniendo el control sobre el código. Es por ello que no se
necesita introducir ninguna aplicación y únicamente será necesario marcar la pestaña
del Core de la librería de X-CUBE-AI para generar las librerías y los pesos de la red.
Gracias a este framework se podrán implementar cualquier tipo de red, siempre y
cuando se cumplan los límites de espacio de la placa.
• SystemPerformance y Validation: Son aplicaciones de prueba para ejecutar de forma
independiente con la finalidad de analizar el rendimiento de redes neuronales.

2.3 Red neuronal ST

En este apartado se va a presentar la red neuronal sobre la que se basa este proyecto. Mas
adelante se comentaran los cambios realizados en dicha red.

La red se puede descargar del Github de STMicroelectronics [32], en formato “.h5” para
su implementación en STM32CubeMX. Las modificaciones en dicha red, se realizan a
través de la herramienta Google Colaboratory [33], un servicio cloud basado en los
cuadernos (notebooks) de Jupyter. No necesita configuración previa y se puede compartir
con facilidad.

La red distingue tres tipos de movimientos: Estacionar, caminar y correr. Para ello hace
uso de un dataset propio, el cual se encuentra disponible también en el Github. Algunas
de las gráficas de movimientos son las siguientes:

Ilustración 34. Graficas de HAR del dataset de la red neuronal de ST.
## Conv1D based model
model = tf.keras.models.Sequential([
tf.keras.layers.Conv1D(filters=16, kernel_size=3, activation=’relu’,
input_shape=(26, 3)),
tf.keras.layers.Conv1D(filters=8, kernel_size=3, activation=’relu’),
tf.keras.layers.Dropout(0.5),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(64, activation=’relu’),
tf.keras.layers.Dense(3, activation=’softmax’)
])
model.compile(optimizer=’adam’,
loss=’sparse_categorical_crossentropy’,
metrics=[’accuracy’])
model.fit(x_train, y_train, epochs=30)
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print("Test loss:", test_loss)
print("Test acc:", test_acc)
model.summary()

La red cuenta con seis capas apiladas, con un tensor de entrada y salida cada una. Esta
construida sobre un modelo Keras secuencial. La estructura es la siguiente:
Las capas tienen la siguiente configuración:

• Capa 1: Es la capa de entrada, se emplea una capa de tipo Conv1D que crea un
kernel (núcleo) de convolución que convoluciona en la entrada para obtener un
tensor de salida. En kernel size, se especifica el número de variables de entrada,
en este caso son 3 entradas. Como función de activación se emplea ReLU,
recomendable en las primeras capas que en general son las que tienen un
aprendizaje más lento, con ReLU se obtiene un aprendizaje más rápido. En
imput shape se introduce el tamaño del array que se va introducir, 26 conjuntos
de datos de tres coordenadas.

• Capa 2: La segunda capa es también de tipo Conv1D, con función de activación
ReLU y tres variables de entrada.

• Capa 3: La tercera capa es una capa de Dropout, empleada para llevar a cabo
técnicas de regularización con el objetivo de reducir el overfitting (sobreajuste)
omitiendo neuronas de forma aleatoria, tanto ocultas como visibles, durante la
fase de entrenamiento de la red.

• Capa 4: La cuarta capa, Flatten (Aplanamiento) transforma los datos de entrada
multidimensionales en un vector de salida 1D.

• Capa 5: La siguiente capa recibe como entrada el vector de la capa 4, en esta
capa de tipo Dense, cada neurona recibe información de todas las neuronas de la
capa 4.

• Capa 6: Finalmente la capa de salida, tiene como se recomendó anteriormente,
una función de activación de tipo Softmax, la cual permite asignar probabilidad
porcentual a cada tipo de salida (En este caso, estacionado, andar o correr) hasta
sumar 1.

Es de vital importancia destacar que la red emplea TensorFlow 1.15, ya que a día de hoy
las librerías empleadas por X-CUBE-IA no soportan la versión 2.2 de TensorFlow.

Nota: Jupyter es un entorno basado en web de desarrollo interactivo de código. Es una herramienta flexible que admite un amplio
espectro de flujos de trabajo en ciencia de datos, informática científica y aprendizaje profundo. Jupyter admite más de 40 lenguajes
de programación, incluidos Python, R, Julia y Scala [34].

2.4 Hardware Empleado

2.4.1 Introducción

El hardware empleado para este proyecto es el Discovery Kit STM32L4 para nodos IoT
es el B-L475E-IOT01A que permite entre otras cosas desarrollar aplicaciones con
conexión directa a servidores en la nube. Los microcontroladores STM32 ofrecen de
forma sencilla y asequible de desarrollarprototipos aprovechando su rendimiento y
consumo. Ofrece también soporte para conectar Arduino Uno V3, ofreciendo gran
cantidad de módulos de expansión compatibles [35].

En este apartado se recopila información de interés de la guía de usuario del dispositivo
B-L475E-IOT01A. Es una de las cuestiones fundamentales a la hora de desarrollar un
proyecto TinyML. En primer lugar porque es importante conocer con qué sistema se va a
trabajar o el proceso contrario, para elegir el dispositivo, es necesario determinar qué
características debería tener el dispositivo para cumplir con los requisitos del proyecto.

En este caso se abordan las diferentes cuestiones de interés para este proyecto, donde es
necesario conocer los periféricos disponibles, las conexiones, etc. En este caso es
importante determinar la fuente de alimentación, fuentes de reloj, el reset, cómo se
configura el virtual COM port o el uso que tienen los jumpers en el sistema. Para otro
tipo de proyectos en la misma línea sería interesante además conocer los periféricos que
se van a emplear. En este proyecto habrá que determinar cómo funciona el acelerómetro,
los botones y leds disponibles entre otras cosas.

En las siguientes figuras, se pueden observar las diferentes vistas del dispositivo (top and
bottom view), obtenidas de la guía de usuario:

Nota: Se han recuadrado en rojo algunas de las partes que serán utilizadas en este proyecto.

Ilustración 35, Vista Top B-L475E-IOT01A

Ilustración 36. Vista Bottom B-L475E-IOT01A

2.4.2 Características generales

Entre las características con las que cuenta el microcontrolador se encuentran las
siguientes:

• MCU de la serie STM32L4 de ultra bajo consumo basados en el núcleo Arm
Cortex-M4 con 1 Mbyte de memoria Flash y 128 Kbytes de SRAM, en paquete
LQFP100
• Memoria Flash Quad-SPI (Macronix) de 64 Mbit
• Bluetooth V4. 1 módulo (SPBTLE-RF)
• Módulo RF sub-GHz (868 o 915 MHz) programable de baja potencia (SPSGRF-
868 o SPSGRF-915)
• Módulo Wi-Fi Inventek ISM43362-M3G-L44 (802.11 b / g / n compatible)
• Etiqueta NFC dinámica basada en M24SR con su antena NFC impresa
• micrófonos omnidireccionales digitales (MP34DT01)
• Sensor digital capacitivo para humedad relativa y temperatura (HTS221)
• Magnetómetro de 3 ejes de alto rendimiento (LIS3MDL)
• Acelerómetro 3D y giroscopio 3D (LSM6DSL)
• Barómetro de salida digital absoluta de 260-1260 hPa (LPS22HB)
• Sensor de tiempo de vuelo y detección de gestos (VL53L0X)
• pulsadores (usuario y reinicio)
• USB OTG FS con Micro-AB conector
• Conectores de expansión de placa:
- Arduino Uno V3
- PMOD
• Opciones de fuente de alimentación flexibles: ST-LINK USB VBUS o fuentes
externas
• Depurador ST-LINK / V2-1 integrado / programador con capacidad de
reenumeración USB: almacenamiento masivo, puerto COM virtual y puerto de
depuración
• Software gratuito completo que incluye una variedad de ejemplos, como parte del
paquete STM32Cube, así como una expansión de software de conector en la nube,
que permite el acceso directo a los servidores en la nube
• Admite una amplia variedad de entornos de desarrollo integrados (IDE), incluidos
IAR , Keil, IDE basados en GCC, Arm mbed Enabled

2.4.3 B-L475E-IOT01A en detalle

Entre las diferentes cuestiones que se abordan en la guía del dispositivo [35], las que
tienen una relación directa con el proyecto son las siguientes:

Fuente de alimentación

El kit de IoT está diseñado para funcionar con una fuente de alimentación de 5 V CC.
Es posible configurar el Discovery Kit STM32L4 para usar cualquiera de las siguientes
cinco fuentes para la fuente de alimentación: 5V_ST_LINK, 5V_ARD, 5V_USB_FS,
5V_VBAT y 5V_USB_CHARGER. En este proyecto se va a emplear la primera
configuración: 5V_ST_LINK.

La configuración se obtiene colocando el jumper JP4 en los pines de las posiciones 1 y
2 como se observa en la siguiente figura:

Ilustración 37. Configuración Jumper J4 del dispositivo B-L475E-IOT01A.
La alimentación que se consigue es la del conector USB tipo Micro-B de ST-LINK / V2-
1de 5 V CC con limitación de CN7. Ésta es la configuración predeterminada. Si la
enumeración USB tiene éxito, se habilita la alimentación 5V_ST_LINK, afirmando la
señal PWR_ENn. Este pin está conectado a un interruptor de encendido ST890, que
alimenta la placa. Este interruptor de encendido también cuenta con una limitación de
corriente para proteger la PC en caso de un cortocircuito (más de 750 mA).

El kit STM32L4 Discovery para el nodo IoT se puede alimentar desde el conector USB
ST-LINK CN7, pero solo el circuito ST-LINK tiene la energía antes de la enumeración
USB, porque la PC host solo proporciona 100 mA a la placa en ese momento. Durante la
enumeración USB, el kit STM32L4 Discovery para el nodo IoT solicita la alimentación
de 500 mA a la PC host. Si el host puede proporcionar la energía requerida, la
enumeración finaliza con un comando "SetConfiguration" y luego, el transistor de
potencia ST890 se enciende, el LED rojo LD7 se enciende, por lo que el kit de
descubrimiento STM32L4 para el nodo IoT consume hasta Corriente de 500 mA, pero no
más. Si el anfitrión no puede proporcionar la corriente solicitada, la enumeración falla.
Por lo tanto, el ST890 permanece OFF y la parte de la MCU, incluida la placa de
extensión, no recibe alimentación. Como consecuencia, el LED LD7 rojo permanece
OFF. En este caso es obligatorio utilizar una fuente de alimentación externa.

Fuentes de reloj
Las tres fuentes de reloj de las que dispone el microprocesador son:
• X1, que es el oscilador de 8 MHz para el microcontrolador STM32L475VG. Este
reloj no está implementado en una configuración básica.
• X2 que es el cristal de 32,768 KHz para el RTC integrado STM32L475VG
• X3 que es el reloj de 8 MHz de ST-LINK MCU para el microcontrolador
STM32L475VG.

Fuentes de reset

La señal de reset es activa a nivel bajo y entre sus fuentes cuenta con un botón de reinicio
B1 (El botón negro).

Virtual COM port

Es importante saber que la interfaz serial USART1 está disponible directamente como un
puerto COM virtual del PC conectado al conector ST-LINK / V2-1 USB CN7.
Los ajustes del puerto COM virtual se configuran como:
• Speed:115200 b / s
• Data: 8 bits
• Parity: Sin paridad
• Stop bits:1 bit de parada
• Flow Control: Sin control de flujo.

Esta información será imprescindible a la hora de configurar los periféricos y configurar
el puerto cuando se quiera utilizar Putty o Tera term.

3D accelerometer and 3D gyroscope (LSM6DSL)

El LSM6DSL es un system-in-package que presenta un acelerómetro digital 3D y un
giroscopio digital 3D que funcionan a 0,65 mA en modo de alto rendimiento y que
habilitan funciones siempre activas de bajo consumo para una experiencia de movimiento
óptima para el consumidor.

Las interrupciones de detección de eventos permiten un seguimiento de movimiento
eficiente y confiable y conciencia contextual, implementando el reconocimiento de
hardware de eventos de caída libre, orientación 6D, detección de clic y doble clic,
actividad o inactividad y eventos de activación.

El LSM6DSL admite los principales requisitos del sistema operativo, ofreciendo sensores
reales, virtuales y por lotes con 4 Kbytes para el procesamiento por lotes de datos
dinámicos.

El LSM6DSL ha sido diseñado para implementar características como movimiento
significativo, inclinación, funciones de podómetro, detector de pasos y contador de pasos,
sellado de tiempo y para respaldar la adquisición de datos de un magnetómetro externo
con corrección de planchado (duro, suave).

El LSM6DSL tiene un rango de aceleración a escala completa de ± 2 / ± 4 / ± 8 / ± 16 g
y un rango de velocidad angular de ± 125 / ± 245 / ± 500 / ± 1000 / ± 2000 dps.

Es importante destacar que se puede acceder a los registros integrados dentro del
LSM6DSL a través de las interfaces