UNIVERSIDAD POLITÉCNICA DE MADRID

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA DE SISTEMAS

INFORMÁTICOS

DEPARTAMENTO DE INTELIGENCIA ARTIFICIAL

TRABAJO DE FIN DE GRADO

GRADO EN INGENIERÍA DE COMPUTADORES

Sistema de Reconocimiento de Comandos por

Voz Basado en Redes de Neuronas LSTM

Autor:
Juan Manuel Vicente Cabero

Tutor:
Francisco Serradilla Garcı́a

Junio 2018
 Abstract

Artificial Intelligence has experienced a huge growth in the last few years,
thanks to the increase in computing power and the emergence of tools that
allow complex calculations to be performed more efficiently. In addition, the
rise of smartphones has increased the volume of data generated by users,
opening up a range of new possibilities for the application of Artificial Inte-
lligence in consumer electronics. Among these applications are virtual assis-
tants, which allow the execution of certain instructions by voice command
recognition. This project aims to develop a Recurrent Neural Network, spe-
cifically a LSTM network, capable of recognizing 24 instructions, to test the
effectiveness of LSTM networks in Automatic Speech Recognition (ASR) and
to provide the basis for a future virtual assistant. The system will take as
input audio files in WAVE format, pre-process the acoustic signal and extract
the features of interest, which will serve as input for the neural network.
The output from the network will be a vector of 24 integers, one for each
class, with all of them being ’0’ except the class predicted by the network
with the highest percentage of confidence, which will take the value ’1’. The
system will interpret this vector and display the name of the analyzed file,
the command it contains and the command predicted by the network.
 Resumen

La Inteligencia Artificial ha experimentado un gran crecimiento durante los

últimos años, gracias al aumento de la capacidad de cómputo y la apari-
ción de herramientas que permiten realizar cálculos complejos de una forma
más eficiente. Además, el auge de los smartphones ha permitido aumentar el
volumen de datos generados por los usuarios, abriendo un abanico de nue-
vas posibilidades en cuanto a la aplicación de la Inteligencia Artificial en
la electrónica de consumo. Una de estas aplicaciones son los asistentes vir-
tuales, que permiten la ejecución de determinadas instrucciones mediante el
reconocimiento de comandos por voz. Este proyecto tiene como objetivo el
desarrollo de una Red de Neuronas Recurrente del tipo LSTM, capaz de re-
conocer 24 instrucciones, para comprobar la efectividad de las redes LSTM
en el Reconocimiento del Habla (ASR); ası́ como suponer la base para un
futurible asistente virtual. El sistema tomará como entrada ficheros de audio
en formato WAVE, realizará el preprocesado de la señal acústica y extraerá
los atributos de interés, que servirán como entrada para la red de neuronas.
La salida de la red será un vector de 24 enteros, uno por cada clase, siendo
todos ellos ’0’ salvo la clase predicha por la red con un mayor porcentaje de
confianza, que tomará el valor ’1’. El sistema interpretará este vector y mos-
trará por pantalla el nombre del fichero analizado, el comando que contiene
y el comando predicho por la red.
Dedicatoria

A Andrea y mi familia, por brindarme a lo largo de todos estos años un

apoyo que ha sido fundamental para afrontar las dificultades que he encon-
trado en el camino, y para crecer como persona.

A Fran, Álvaro y Diego, cuya compañı́a me ha permitido crecer como pro-

fesional durante mi etapa universitaria, y a quienes considero mis ingenieros
de referencia.
Índice general

Lista de figuras VI

Lista de tablas VIII

1. Introducción 1
1.1. Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2. Impacto social . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2. Fundamentos teóricos 4
2.1. Inteligencia Artificial . . . . . . . . . . . . . . . . . . . . . . . 4
2.2. Machine Learning . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.3. Deep Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.4. Redes de Neuronas . . . . . . . . . . . . . . . . . . . . . . . . 6
2.5. Redes de Neuronas Recurrentes . . . . . . . . . . . . . . . . . 7
2.6. Long Short-Term Memory . . . . . . . . . . . . . . . . . . . . 8
2.6.1. Descartando información: Forget gate layer . . . . . . . 11
2.6.2. Añadiendo nueva información . . . . . . . . . . . . . . 11
2.6.3. Actualizando el cell state . . . . . . . . . . . . . . . . . 12
2.6.4. Generando la salida . . . . . . . . . . . . . . . . . . . . 14
2.7. Aprendizaje supervisado . . . . . . . . . . . . . . . . . . . . . 15
2.7.1. Algoritmo de aprendizaje: Backpropagation . . . . . . . 15

II
 2.8. Funciones de activación . . . . . . . . . . . . . . . . . . . . . . 16
2.8.1. Tanh . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.8.2. Softmax . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.9. Métricas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.9.1. Precisión . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.9.2. Pérdida . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.10. Optimización del descenso de gradiente . . . . . . . . . . . . . 19
2.10.1. Adagrad . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.10.2. Adam . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.11. Regularización . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.11.1. Dropout . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.11.2. L2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.12. Procesado de audio . . . . . . . . . . . . . . . . . . . . . . . . 22
2.12.1. Preénfasis . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.12.2. Enmarcado . . . . . . . . . . . . . . . . . . . . . . . . 24
2.12.3. Función de ventana de Hamming . . . . . . . . . . . . 25
2.12.4. Transformada de Fourier de Tiempo Reducido (STFT ) 26
2.12.5. Bancos de filtros de Escala Mel . . . . . . . . . . . . . 27
2.12.6. Coeficientes Cepstrales en Frecuencias de Mel (MFCCs) 29
2.12.7. Normalización . . . . . . . . . . . . . . . . . . . . . . . 30

3. Herramientas 31
3.1. Dataset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.1.1. Speech Recognition . . . . . . . . . . . . . . . . . . . . 32
3.1.2. Keyword Spotting . . . . . . . . . . . . . . . . . . . . . 33
3.2. Librerı́as de manipulación de datos . . . . . . . . . . . . . . . 34
3.2.1. NumPy . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.2.2. SciPy Library . . . . . . . . . . . . . . . . . . . . . . . 35

III
 3.2.3. Pandas . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.3. Librerı́as de Machine Learning . . . . . . . . . . . . . . . . . . 36
3.3.1. SciKit-Learn . . . . . . . . . . . . . . . . . . . . . . . . 36
3.3.2. PyTorch . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.3.3. Theano . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.3.4. TensorFlow . . . . . . . . . . . . . . . . . . . . . . . . 37
3.3.5. Keras . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.4. Lenguaje de programación . . . . . . . . . . . . . . . . . . . . 38
3.5. Entorno de desarrollo . . . . . . . . . . . . . . . . . . . . . . . 39
3.6. Hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

4. Diseño 41
4.1. Descripción del problema . . . . . . . . . . . . . . . . . . . . . 41
4.1.1. Preprocesado . . . . . . . . . . . . . . . . . . . . . . . 42
4.1.2. Partición del dataset . . . . . . . . . . . . . . . . . . . 43
4.1.3. Entrenamiento de la red de neuronas . . . . . . . . . . 44
4.2. Estructura del proyecto . . . . . . . . . . . . . . . . . . . . . . 45
4.3. Arquitectura de la Red de Neuronas . . . . . . . . . . . . . . . 46

5. Experimentación 47
5.1. Primer alcance: Speech Recognition . . . . . . . . . . . . . . . 47
5.2. Segundo alcance: Keyword Spotting . . . . . . . . . . . . . . . 49
5.2.1. Modelo 1 . . . . . . . . . . . . . . . . . . . . . . . . . 50
5.2.2. Modelo 7 . . . . . . . . . . . . . . . . . . . . . . . . . 52
5.2.3. Modelo 15 . . . . . . . . . . . . . . . . . . . . . . . . . 53
5.2.4. Modelo 18 . . . . . . . . . . . . . . . . . . . . . . . . . 55
5.2.5. Modelo 19 . . . . . . . . . . . . . . . . . . . . . . . . . 58
5.2.6. Modelo 20 . . . . . . . . . . . . . . . . . . . . . . . . . 60

IV
 5.2.7. Pruebas . . . . . . . . . . . . . . . . . . . . . . . . . . 63
5.3. Evaluación de resultados . . . . . . . . . . . . . . . . . . . . . 65

6. Conclusiones 66

7. Futuros Proyectos 68
7.1. Streams de audio con ruido . . . . . . . . . . . . . . . . . . . 68
7.2. Integración con una aplicación final . . . . . . . . . . . . . . . 69
7.3. Aumento del conjunto de comandos . . . . . . . . . . . . . . . 69
7.4. Comparativa de arquitecturas . . . . . . . . . . . . . . . . . . 70

Bibliografı́a 71

V
Índice de figuras

2.1. Representación de una RNN. Fuente: Colah’s blog . . . . . . . 8

2.2. Notación de los diagramas para las celdas LSTM. Fuente: Co-
lah’s blog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3. Representación detallada de una celda LSTM. Fuente: Colah’s
blog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.4. Representación del estado de celda (cell state). Fuente: Colah’s
blog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.5. Representación de una puerta (gate). Fuente: Colah’s blog . . 10
2.6. Representación de la capa forget gate. Fuente: Colah’s blog . . 12
2.7. Representación de las capas de actualización del cell state.
Fuente: Colah’s blog . . . . . . . . . . . . . . . . . . . . . . . 13
2.8. Representación de las operaciones de actualización del cell sta-
te. Fuente: Colah’s blog . . . . . . . . . . . . . . . . . . . . . . 13
2.9. Representación de la generación de la salida. Fuente: Colah’s
blog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.10. Representación de la función Tangente Hiperbólica. Fuente:
Wikipedia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.11. Señal de audio contenida en un fichero WAVE. Fuente: Haytham
Fayek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

VI
2.12. Señal de audio tras aplicar el filtro de preénfasis. Fuente: Hayt-
ham Fayek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.13. Representación de la función de ventana de Hamming. Fuente:
Haytham Fayek . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.14. Representación de un banco de filtros en escala Mel. Fuente:
Haytham Fayek . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.15. Espectrograma de la señal de ejemplo. Fuente: Haytham Fayek 28
2.16. Representación de los MFCCs obtenidos de la señal de ejem-
plo. Fuente: Haytham Fayek . . . . . . . . . . . . . . . . . . . 29
2.17. Representación de los MFCCs normalizados. Fuente: Haytham
Fayek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

4.1. Descripción del problema. . . . . . . . . . . . . . . . . . . . . 42

4.2. Representación de la arquitectura de la red de neuronas. . . . 46

5.1. Métricas del modelo 7. . . . . . . . . . . . . . . . . . . . . . . 53

5.2. Métricas del modelo 15. . . . . . . . . . . . . . . . . . . . . . 55
5.3. Métricas del modelo 18. . . . . . . . . . . . . . . . . . . . . . 57
5.4. Métricas relativas del modelo 18. . . . . . . . . . . . . . . . . 58
5.5. Métricas del modelo 19. . . . . . . . . . . . . . . . . . . . . . 60
5.6. Métricas del modelo 20. . . . . . . . . . . . . . . . . . . . . . 61
5.7. Métricas relativas del modelo 20. . . . . . . . . . . . . . . . . 62
5.8. Muestra de la salida de la ejecución de Test-app.ipynb. . . . 64

VII
Índice de tablas

5.1. Resultados del modelo 7. . . . . . . . . . . . . . . . . . . . . . 52

5.2. Resultados del modelo 15 . . . . . . . . . . . . . . . . . . . . . 54
5.3. Resultados del modelo 18. . . . . . . . . . . . . . . . . . . . . 56
5.4. Resultados del modelo 19 . . . . . . . . . . . . . . . . . . . . . 59
5.5. Resultados del modelo 20 . . . . . . . . . . . . . . . . . . . . . 61
5.6. Ficheros mal clasificados en la fase de pruebas. . . . . . . . . . 64

VIII
Capı́tulo 1

Introducción

En los últimos años se ha producido un crecimiento de la inversión en el

campo de la Inteligencia Artificial, aprovechando el aumento de la capacidad
de cómputo y la aparición de herramientas que mejoran la eficiencia a la hora
de trabajar con cálculos complejos, o bien que simplifican la realización de
los mismos, tales como CUDA o TensorFlow respectivamente.

Esta circunstancia, junto al auge de los smartphones, ha permitido que

comiencen a desarrollarse soluciones comerciales basadas en Inteligencia Ar-
tificial que puedan ser usadas por un gran volumen de usuarios. Entre estas
soluciones se encuentran los asistentes virtuales.

Las grandes empresas del sector tecnológico han apostado recientemen-

te por el desarrollo de asistentes virtuales, pudiendo encontrar disponibles
soluciones de Apple (Siri), Microsoft (Cortana), Google (Google Assistant y
Google Now), Amazon (Alexa) y Samsung (Bixby), entre otras. Los disposi-
tivos compatibles para cada una de las soluciones anteriores dependen direc-
tamente de los intereses de su correspondiente empresa. No obstante, todas
ellas tienen el mismo objetivo: permitir al usuario la realización de accio-

1
nes mediante comandos por voz, tales como búsquedas en Internet, agendar
eventos en el calendario o la creación de alarmas.

El reconocimiento de comandos por voz puede englobarse de forma gene-

ral dentro del Reconocimiento del Habla (Speech Recognition) y, dentro de
esta disciplina, la actuación de dichos comandos como disparadores de deter-
minadas acciones se conoce como Keyword Spotting. Si bien las arquitecturas
más sencillas para tal finalidad se basan en Redes de Neuronas Convolu-
cionales, desde 2014 han comenzado a recuperar protagonismo las Redes de
Neuronas Recurrentes y, más en concreto, las LSTM [5], en parte gracias a la
publicación de artı́culos que explicaban su funcionamiento de una forma más
simplificada [6] que las originales, y al incremento de la potencia de cómputo
del hardware comercial.

1.1. Objetivos
El objetivo de este proyecto es el diseño, implementación y entrenamiento
de una red de neuronas basada en LSTM que permita reconocer el comando
dictado, de 24 posibles, por un determinado locutor, tomando como entrada
un fichero de audio en formato WAVE.

Para el entrenamiento, se ha hecho uso del dataset Speech Commands v2,

de Google, que contiene 35 posibles comandos, de los cuales hemos seleccio-
nado los 24 que nos pueden resultar interés. Una vez entrenado, utilizamos
el modelo para realizar predicciones a modo de prueba sobre un conjunto
de 47 ficheros, 2 por cada comando, elegidos aleatoriamente entre todo el
dataset, mostrando por pantalla el nombre, la etiqueta y la predicción para
cada fichero.

2
 La finalidad del proyecto es demostrar las capacidades de las celdas LSTM
para Keyword Spotting frente a las Redes de Neuronas Convolucionales (CNN ),
las utilizadas habitualmente para este tipo de aplicaciones.

1.2. Impacto social

Los asistentes virtuales mencionados anteriormente, como Alexa o Siri,
permiten el control de dispositivos electrónicos mediante la voz. Para la ma-
yorı́a de usuarios, esto supone una mera comodidad que reduce la necesidad
de escribir o realizar cualquier otra interacción con la pantalla.

No obstante, es necesario recordar que hay usuarios que no pueden inter-

actuar con normalidad con estos dispositivos. Algunos usuarios tienen pro-
blemas de visión que les impiden enfocar correctamente a una distancia tan
corta como la de un móvil, otros pueden tener dificultades debido a que el
tamaño de las letras o de los diferentes menús de las interfaces gráficas son
demasiado pequeños, o incluso pueden carecer de la capacidad de ver en su
totalidad.

Más allá de los problemas de visión, hay usuarios que tampoco pueden
hacer un uso normal de los dispositivos debido a problemas de psicomo-
tricidad o a otras formas de discapacidad fı́sica. Para todos estos usuarios,
la posibilidad de que un dispositivo reconozca una serie de comandos que
realicen determinadas acciones básicas les permite hacer uso de los mismos
sin depender de otra persona, haciéndoles ganar autonomı́a y mejorando su
calidad de vida.

3
Capı́tulo 2

Fundamentos teóricos

El Keyword Spotting, como parte del reconocimiento del habla (Speech

Recognition), se basa principalmente en la utilización de Redes de Neuronas,
pudiendo englobarse dentro del campo del Deep Learning, a su vez com-
prendido dentro del Machine Learning o Aprendizaje Automático, y de la
Inteligencia Artificial, respectivamente. El conocimiento de estos conceptos,
ası́ como su correspondiente base matemática, resultan fundamentales para
el entendimiento del proyecto, sus objetivos, sus recursos y sus limitaciones.

El presente capı́tulo introduce todos los conceptos considerados de in-

terés en el ámbito del proyecto, ası́ como el estado del arte del campo del
reconocimiento del habla.

2.1. Inteligencia Artificial

El término Inteligencia Artificial (IA) fue utilizado por primera vez por
John McCarthy en el año 1956. La IA engloba la realización de tareas carac-
terı́sticas de la inteligencia humana por parte de máquinas, entiendiéndolas

4
como aquellas cuya realización resulta simple para las personas y que, a su
vez, resultan difı́ciles de describir [1, 2].

2.2. Machine Learning

Para solucionar los problemas planteados por el amplio campo de la Inteli-
gencia Artificial, es necesario dotar a los sistemas de conocimiento. El Apren-
dizaje Automático o Machine Learning comprende todas aquellas técnicas y
algoritmos que permiten que los sistemas adquieran su propio conocimiento
mediante la extracción de patrones de datos no procesados.

La introducción del Machine Learning permitió la utilización de máquinas

para resolver problemas que requerı́an conocimiento del mundo real, ası́ como
la toma de decisiones aparentemente subjetivas [1]. Entre los problemas que
pueden resolver algoritmos simples de Machine Learning están el filtrado de
emails considerados como correo basura o spam, o la clasificación de 3 especies
de plantas de la familia Iridaceae, cuyas componentes se conocen comúnmente
como lirios, mediante la utilización del Iris Dataset [3] recopilado por Ronald
Fisher en 1936 [4].

El funcionamiento de los algoritmos de Aprendizaje Automático depende

en gran medida del formato de representación de los datos que se les propor-
ciona, dado que este define los fragmentos en los que se pueden dividir los
datos, llamados atributos o features.

5
2.3. Deep Learning
El Aprendizaje Profundo o Deep Learning es uno de los muchos posibles
enfoques del Machine Learning, como también lo son los árboles de decisión y
la agrupación (clustering), entre otros. Se basa en el entendimiento del mun-
do como una jerarquı́a de conceptos, permitiendo a las máquinas aprender
conceptos complejos en base a otros más simples con los que tengan relación.
Si representamos esta jerarquı́a de conceptos en forma de grafo obtenemos
uno de gran profundidad, en lo que respecta al número de capas, dando lugar
al nombre de Deep Learning [1].

2.4. Redes de Neuronas

Las Redes de Neuronas (Neural Networks, NN ), también conocidas como
Redes de Neuronas Artificiales (Artificial Neural Networks, ANN ), son mo-
delos matemáticos que permiten solucionar problemas siguiendo el enfoque
del Deep Learning. Su estructura se basa en grafos divididos en capas, com-
puestas por una serie de nodos (neuronas), que se interconectan permitiendo
fluir la información, de forma que cada neurona aprende a identificar un de-
terminado concepto (atributo), filtrándose ası́ la información hasta obtener
una salida.

Las Redes de Neuronas deben diseñarse en función del problema a re-

solver y del formato de los datos con los que se pretende realizar la ingesta
al modelo. No obstante, independientemente de la topologı́a (Feedforward,
Recurrente) y la arquitectura de la red, esta siempre tiene un mı́nimo de dos
capas, correspondiéndose con la entrada de datos y la salida de los resultados.

6
Además, puede tener un número indefinido de capas ocultas.

Tras diseñar la arquitectura, es necesaria la adaptación del modelo para

que reconozca los atributos de los datos que recibe y que filtre correctamente
la información. Esta fase de adaptación, conocida como entrenamiento, se
basa en el reajuste de los pesos de las conexiones entre neuronas basándose
en un conjunto de datos, con el mismo formato de representación que los
que serán proporcionados cuando el modelo se encuentre en funcionamiento,
entendiéndose como la utilización del modelo para realizar predicciones en
base a los datos introducidos. Para el entrenamiento se pueden utilizar di-
versos métodos de aprendizaje (supervisado, no supervisado, por refuerzo) y
algoritmos de reajuste de pesos, aunque generalmente se recurre al Algoritmo
de Retropropagación o Backpropagation.

2.5. Redes de Neuronas Recurrentes

Las Redes de Neuronas con topologı́a Recurrente (Recurrent Neural Net-
work, RNN ) son aquellas que, además de presentar interconexiones con pro-
pagación de información de una determinada capa hacia las siguientes, per-
miten interconexiones con capas anteriores. Entendiendo la representación
de una red de neuronas como un grafo, las redes recurrentes son aquellas que
permiten la presencia de bucles. Generalmente, estas conexiones se suelen
utilizar como retroalimentación, de forma que la salida de una capa determi-
nada se propaga hacia la primera capa oculta, haciéndola funcionar a modo
de capa de entrada.

El objetivo perseguido por esta topologı́a es la capacidad de modelizar

7
secuencias de datos x1 , . . . , xn , permitiendo escalar la red a secuencias de
entrada de un tamaño mucho mayor del que puede resultar práctico para
redes sin esta especialización. Además, la mayorı́a de las redes recurrentes
permiten procesar secuencias de longitud variable [1].

Figura 2.1: Representación de una RNN. Fuente: Colah’s blog

En la figura 2.1 encontramos un diagrama que muestra, de forma simplifi-

cada, la arquitectura de una red recurrente. La capa de entrada se representa
como xt y la capa de salida como ht , siendo t en ambas el instante temporal;
mientras que A representa las capas ocultas de la red. A la derecha de la
figura podemos ver una versión ”desenrrollada”de la red, en la que el bucle
se representa como una secuencia temporal, teniendo por tanto una secuen-
cia de entrada x1 , . . . , xt y una de salida h1 , . . . , ht , en este caso siendo t el
instante actual.

2.6. Long Short-Term Memory

Dentro de las diversas tipologı́as de Redes de Neuronas Recurrentes exis-
tentes, nuestro proyecto se basa en la utilización de las denominadas redes
Long Short-Term Memory (LSTM) [5]. Estas redes se caracterizan por que

8
su unidad atómica es la celda LSTM, a diferencia de las redes de neuronas
tradicionales cuya unidad atómica es la neurona.

Las celdas LSTM pretenden dotar a la red de la capacidad de ”memo-

rizar”, permitiendo mantener un contexto a largo plazo y no únicamente el
actual a la hora de calcular la salida de cada celda [6]. Esta función de me-
moria es la que se denomina el estado de celda, que determina la información
a almacenarse en una celda LSTM determinada. Cada celda LSTM está for-
mada por 4 capas de una Red de Neuronas estándar, que interactúan entre
sı́ mediante determinadas operaciones que detallaremos a continuación.

En la figura 2.2 detallamos la notación a seguir en todos los diagramas

de la presente sección.

Figura 2.2: Notación de los diagramas para las celdas LSTM.

Fuente: Colah’s blog

La idea principal detrás de las celdas LSTM es el estado de celda (cell

state), representado en la figura 2.4. Es un flujo de información que atraviesa
la red de principio a fin, experimentando únicamente algunas operaciones
lineales, que facilitan que la información fluya inmutable por la red cuando
sea conveniente.

9
 Figura 2.3: Representación detallada de una celda LSTM.
Fuente: Colah’s blog

Figura 2.4: Representación del estado de celda (cell state).

Fuente: Colah’s blog

Para controlar el cell state se recurre a estructuras llamadas puertas (ga-

tes), compuestas de una capa sigmoide de Red Neuronal y un producto de
funciones entre la salida de dicha capa y el contenido del cell state. Podemos
ver una representación de esta estructura en la figura 2.5.

Figura 2.5: Representación de una puerta (gate). Fuente: Colah’s blog

10
 La capa sigmoide produce una salida con un valor entre 0 y 1, describien-
do en qué medida debe dejarse pasar el componente en cuestión, pudiendo
entender el valor como un porcentaje.

En los siguientes apartados, detallaremos el flujo que sigue la información

a través de una celda LSTM hasta producir la salida, con el fin de comprender
plenamente su funcionamiento.

2.6.1. Descartando información: Forget gate layer

La capa de puerta de olvido, comúnmente conocida por su nombre en

inglés forget gate layer, es el primer paso a realizar para decidir qué infor-
mación del cell state debe conservarse. La forget gate consiste únicamente de
una capa sigmoide, que toma como entradas la salida del estado anterior ht−1
y la entrada del estado actual xt , produciendo como salida ft . La función de
la capa forget gate queda definida en la ecuación (2.1).

ft = σ(Wf · [ht−1 , xt ] + bf ) (2.1)

En la ecuación anterior, Wf representa la matriz de pesos de la capa en

cuestión, y bf representa el (bias) de la misma.

2.6.2. Añadiendo nueva información

Tras la capa forget gate, el siguiente paso en el flujo de información es la

decisión de qué nueva información se añade al cell state. Este paso se divide
en dos partes: una capa sigmoide, denominada capa de puerta de entrada o

11
 Figura 2.6: Representación de la capa forget gate. Fuente: Colah’s blog

input gate layer, y una capa tanh. La capa input gate, cuya función queda
definida en la ecuación (2.2), se encargará de determinar qué valores van a
ser actualizados.

it = σ(Wi · [ht−1 , xt ] + bi ) (2.2)

Por su parte, la capa tanh crea, mediante la función definida en la ecua-

ción (2.3), un vector de nuevos valores candidatos (C̃t ) a ser añadidos al
estado.

C̃t = tanh (WC · [ht−1 , xt ] + bC ) (2.3)

2.6.3. Actualizando el cell state

Una vez ejecutados los pasos anteriores, es el momento de aplicar las

actualizaciones al cell-state, transformando Ct−1 en Ct . Multiplicaremos el
estado anterior por el resultado de la capa forget gate para olvidar la in-
formación que corresponda y, a continuación, agregamos la información que

12
 Figura 2.7: Representación de las capas de actualización del cell state.
Fuente: Colah’s blog

hemos decidido añadir mediante la capa input gate de los posibles candidatos
obtenidos en la capa tanh.

Las actualizaciones a aplicar en el cell state Ct quedan definidas en la

ecuación (2.4).

Ct = ft ∗ Ct + it ∗ C̃t (2.4)

Figura 2.8: Representación de las operaciones de actualización del cell state.

Fuente: Colah’s blog

13
2.6.4. Generando la salida

Por último, debe determinarse la salida de la celda en función del cell state
y de la salida del estado anterior ht−1 , realizándose este proceso mediante 2
operaciones.

En primer lugar, debemos ejecutar la capa output gate (ot ), nuevamente

de tipo sigmoide, que toma como entrada ht−1 . y queda definida en la ecuación
(2.5). A continuación, se filtra el cell state mediante la aplicación de la función
tanh para reajustar la escala de los valores de esta entre -1 y 1. Por último,
se realiza el producto de funciones del resultado de tanh y ot para obtener
la salida del estado actual ht , tal y como se define en la ecuación 2.6.

ot = σ(Wo · [ht−1 , xt ] + bo ) (2.5)

ht = ot ∗ tanh (Ct ) (2.6)

Figura 2.9: Representación de la generación de la salida.

Fuente: Colah’s blog

14
2.7. Aprendizaje supervisado
Una vez definidos todos los componentes de la arquitectura de la red de
neuronas, es necesario determinar la metodologı́a de aprendizaje a aplicar
para el entrenamiento de la misma. Podemos optar por aprendizaje supervi-
sado, no supervisado o por refuerzo.

Por la naturaleza de los datos con los que se realiza la ingesta, y a fin
de disminuir lo máximo posible el tiempo de entrenamiento, la opción más
adecuada de las 3 planteadas anteriormente es la del aprendizaje supervisado.

Esta metodologı́a se basa en proporcionar a la red un conjunto de datos

de entrada junto con el conjunto de salidas esperadas, dotándola de un cono-
cimiento a priori de los resultados que deberı́a obtener para cada conjunto de
atributos. Permite un aprendizaje más rápido que las otras dos metodologı́as
al conocer de antemano la categorı́a de cada entrada, buscando los patrones
comunes entre los ficheros de una misma clase.

2.7.1. Algoritmo de aprendizaje: Backpropagation

Para realizar el entrenamiento de la red, es necesario comparar la salida

esperada de la red con la salida obtenida. El objetivo es minimizar el error en
la salida mediante el reajuste de los pesos de las conexiones entre neuronas.

Para este fin es necesario recurrir a un algoritmo que tome el error de

la salida y reajuste los pesos en consecuencia. El algoritmo más utilizado,
y al que recurrimos en este proyecto, es el algoritmo de retropropagación o
Backpropagation.

15
 Este algoritmo parte de la salida obtenida por la red, y comienza a re-
ajustar los pesos propagando su error hacia atrás, de forma iterativa, hasta
llegar a la capa de entrada.

Las Redes de Neuronas Recurrentes presentan el problema del Desvane-

cimiento de Gradiente (Vanishing Gradient) [7], al reducirse el gradiente en
estas propagaciones hacia atrás de forma paulatina hasta llegar a 0, provo-
cando un estancamiento en el entrenamiento de la red; aunque este problema
queda solventado con la introducción de celdas LSTM debido a su capacidad
para mantener los contextos a largo plazo.

2.8. Funciones de activación

Tal y como se ha mencionado anteriormente, cada nodo (neurona) tiene
una función de activación que permite determinar cuál debe ser su salida en
base a la entrada recibida. Generalmente, todas las neuronas de una misma
capa utilizan la misma función de activación por lo que, dependiendo del tipo
de capa y de la finalidad de la red, se debe optar por unas u otras funciones
de activación. Esta elección también influye en el tiempo de entrenamiento,
dado que algunas funciones requieren más tiempo de cómputo que otras para
su proceso.

En esta sección introducimos las funciones de activación utilizadas en la

arquitectura final de nuestra solución.

16
2.8.1. Tanh

La utilización de la función Tangente Hiperbólica (tanh) en las celdas

LSTM se ve motivada por el paper original de Hochreiter et al. [5], donde se
presentan las redes LSTM recurriendo en sus celdas a la función de activación
que nos ocupa. Esta función queda definida por la gráfica representada en la
figura 2.10.

Figura 2.10: Representación de la función Tangente Hiperbólica.

Fuente: Wikipedia

La función de activación tanh se consideró ideal para su utilización en las

redes LSTM debido a la necesidad de que la segunda derivada de la función
de activación fuese capaz de mantener su valor durante un cierto periodo de
tiempo antes de llegar a 0, para poder dotar a las celdas de la capacidad de
retener contextos a largo plazo.

El principal inconveniente de la función tanh es el alto coste de compu-

tación que requiere para su cálculo respecto a otras funciones. Sigue siendo el
estándar en las redes LSTM por la ausencia de alternativas que cumplan las
caracterı́sticas necesarias. No obstante, se han encontrado algunas referencias
a la función Softsign, la cual es menos propensa a la saturación (desvane-

17
cimiento de gradiente) y permite mantener contextos a largo plazo con un
coste de cómputo menor que tanh, reduciéndose notablemente el tiempo de
entrenamiento [8].

2.8.2. Softmax

Nuestra solución al problema se plantea como un clasificador de múltiples

clases, en el que cada entrada pertenece a una única clase. Esto hace ideal
la utilización de la función Softmax, dado que esta nos devuelve una lista
de probabilidades de pertenencia a cada una de las posibles clases, sumando
un total del 100 %, y asignando la salida a la clase con mayor probabilidad.
Dada su naturaleza, únicamente es utilizada en la capa de salida de la red.

2.9. Métricas
La construcción de un modelo de Machine Learning requiere de la aplica-
ción de métricas que nos permitan cuantificar los resultados obtenidos. Las
métricas a evaluar se eligen en base a la naturaleza del problema a resolver
y a las funciones de activación utilizadas, aunque se pueden distinguir dos
tipos de métricas que resultarán de interés, y que exponemos en esta sección.

2.9.1. Precisión

En primer lugar, es conveniente conocer la proporción de aciertos en el

total de predicciones del modelo. Hay diferentes métricas que nos permiten
conocer este dato dado que, en ocasiones, la naturaleza del problema hace

18
que el cociente entre aciertos y el total no sea suficiente para determinar la
calidad del desempeño del modelo.

El alcance actual de nuestro proyecto define un clasificador sin ningún

requerimiento especial, por lo que optamos por utilizar la versión por defecto
de la precisión (accuracy) proporcionada por Keras.

2.9.2. Pérdida

La pérdida nos permite conocer la evolución del error en las predicciones

del modelo, resultando la métrica más fiable para monitorizar el entrenamien-
to de la red. Cuanto menor sea su valor, mayor capacidad de generalización
tiene el modelo.

Dado que utilizamos la función de activación Softmax en la capa de sali-

da, la función de pérdida más adecuada es categorical crossentropy, ya
que que su valor se incrementa en función a la divergencia de la predicción
respecto al valor esperado. Se diferencia de la función binary crossentropy
en que nos permite trabajar con más de una clase.

2.10. Optimización del descenso de gradiente

Una vez definidos los parámetros de la arquitectura y las métricas a uti-
lizar para cuantificar el desempeño del modelo, resulta de interés recurrir a
algoritmos que modifiquen durante el entrenamiento, y de forma automáti-
ca, los valores de los hiperparámetros, como la tasa de aprendizaje, en base
a los resultados que se obtienen en cada momento. El fin de estos algorit-

19
mos es optimizar la evolución del descenso de gradiente, en la búsqueda de
la convergencia de la función de pérdida. El algoritmo a utilizar depende
de la naturaleza del problema, y de los hiperparámetros cuya modificación
consideremos de interés para optimizar los resultados.

En esta sección introducimos los dos algoritmos de optimización de des-

censo de gradiente que hemos valorado para el desarrollo del proyecto. Ambos
permiten modificar automáticamente la tasa de aprendizaje, aunque final-
mente nos decantamos por la utilización de Adam, debido a las caracterı́sticas
que exponemos en los siguientes apartados.

2.10.1. Adagrad

Adagrad [9] es un algoritmo que adapta el valor de la tasa de aprendizaje

en base a los parámetros, realizando actualizaciones más pequeñas (reducción
de la tasa de aprendizaje) para parámetros asociados a atributos con una
ocurrencia frecuente, y grandes (aumento de la tasa de aprendizaje) ante
atributos infrecuentes [10]. Esto permite que al inicio del entrenamiento,
cuando la función de pérdida aún está lejos de converger, se pueda tomar
una tasa de aprendizaje alta debido a que los atributos aún son infrecuentes;
y que, a medida que avanza el mismo, se disminuya progresivamente el valor
de la tasa de aprendizaje para alcanzar la convergencia.

La principal debilidad de Adagrad es su acumulación de los cuadrados

de los gradientes, que lleva al estancamiento de la tasa de aprendizaje y,
eventualmente, a tomar un valor infinitesimal próximo a 0, impidiendo que
el modelo adquiera nuevo conocimiento [10].

20
2.10.2. Adam

Adam (Adaptive Moment Estimation) [11] pretende mitigar la principal

debilidad de Adagrad mediante la reducción exponencial de la media de los
cuadrados de los gradientes anteriores, como también hacen Adadelta [12] y
RMSProp [10].

El factor diferencial de Adam frente a otros algoritmos de optimización del

descenso de gradiente es que, además de lo expuesto anteriormente, mantiene
una reducción exponencial de la media de los gradientes anteriores, y no sólo
de sus cuadrados. Los autores muestran empı́ricamente que Adam reporta
un buen funcionamiento, y que obtiene resultados favorables en comparación
a otros algoritmos de adaptación del aprendizaje [11].

2.11. Regularización
Las técnicas de regularización permiten mitigar el sobreentrenamiento
mediante la penalización de los modelos complejos, actuando sobre los datos
o sobre las conexiones de la red, en función de la técnica en cuestión. En esta
sección introducimos las dos técnicas de regularización que hemos valorado
durante el desarrollo del proyecto.

2.11.1. Dropout

La técnica de Dropout [13] consiste en desechar sistemáticamente un por-

centaje determinado de las conexiones de la capa donde se aplique, lo que se
ha probado como una medida simple y efectiva para mitigar el sobreentrena-
miento.

21
 Hemos recurrido a la técnica de Dropout en las capas LSTM de nuestro
modelo, tanto sobre las conexiones entre capas como sobre las conexiones
recurrentes, desechando un 20 % (valor por defecto) de las conexiones en
cada caso.

2.11.2. L2

La técnica de regularización L2 [14] nos permite cuantificar la compleji-

dad de los modelos, definiéndose como la suma de los cuadrados de todos
los pesos de los atributos, como se muestra en la ecuación (2.7). En esta
fórmula, los pesos cercanos a 0 tienen un efecto prácticamente despreciable
en la complejidad del modelo, aumentándose notablemente el impacto en la
complejidad cuanto mayores sean esos pesos.

L2 regularization term = ||w||22 = w12 + w22 + . . . + wn2 (2.7)

A pesar de haberse valorado, finalmente no se ha considerado necesaria su

aplicación debido a la obtención de buenos resultados aplicando únicamente
Dropout.

2.12. Procesado de audio

De forma previa a la ingesta de datos a la red, estos deben pasar por una
fase de preprocesado que permita extraer los atributos o features de interés,
dado que la red no puede trabajar con los datos en bruto, es decir, con los
ficheros de audio como entrada.

22
 A la hora de preprocesar los datos se puede optar por dos enfoques:
obtener los espectrogramas y diseñar una red que trabaje con imágenes con
entrada, o bien tratarlos como secuencias de vectores de números en coma
flotante (floats). Dado el objetivo perseguido por nuestro proyecto, se opta
por el segundo enfoque.

El procesado de audio requiere una serie de operaciones [15] , a realizar

de forma secuencial, sobre la señal contenida en cada uno de los ficheros
WAVE que componen el dataset. Esta sección expone detalladamente en qué
consisten dichas operaciones.

2.12.1. Preénfasis

El primer paso a realizar sobre la señal de audio es un filtro de preénfasis,

con el objetivo de amplificar las frecuencias altas. Este filtrado nos permite
equilibrar el espectro de frecuencias, dado que las frecuencias altas suelen
tener, generalmente, magnitudes inferiores que las frecuencias bajas; evitar
problemas numéricos en el cálculo de la transformada de Fourier que se reali-
zará posteriormente; ası́ como puede mejorar la relación señal/ruido (SNR).
En la figura 2.11 podemos observar una señal de ejemplo, sobre la que ob-
servaremos los resultados de aplicación de las siguientes operaciones.

El filtrado puede aplicarse a una señal x tal y como se define en la ecuación

(2.8), siendo α el coeficiente de filtro, que suele tomar un valor de 0,95 o 0,97.
En nuestro caso, tomaremos α = 0,97.

y(t) = x(t) − αx(t − 1) (2.8)

23
 Figura 2.11: Señal de audio contenida en un fichero WAVE.
Fuente: Haytham Fayek

En la figura 2.12 podemos observar la señal de ejemplo tras aplicar el

filtro de preénfasis, siendo apreciables a simple vista los cambios en la forma
de onda.

Figura 2.12: Señal de audio tras aplicar el filtro de preénfasis.

Fuente: Haytham Fayek

2.12.2. Enmarcado

Una vez aplicado el preénfasis es necesario dividir la señal en marcos de

tiempo reducido, dado que las frecuencias en una señal cambian con el paso
del tiempo por lo que, en la mayorı́a de los casos, no tiene sentido aplicar la
transformada de Fourier sobre la señal completa ya que perderı́amos contor-
nos de frecuencia a lo largo del tiempo. Para evitarlo, podemos asumir que
las frecuencias en una señal son estacionarias en cortos periodos de tiempo,

24
por lo que podemos aplicar la transformada de Fourier sobre estos marcos de
tiempo para obtener una buena aproximación de los contornos de frecuencia
de la señal mediante la concatenación de marcos adyacentes.

La longitud de estos marcos es generalmente, para procesamiento de voz,

de entre 20 y 40 milisegundos con en torno a un 50 % (±10 %) de solapamiento
entre marcos consecutivos. Los valores tı́picos son una longitud de marco de
25ms y un solapamiento de 15ms.

2.12.3. Función de ventana de Hamming

La Transformada Rápida de Fourier (FFT ) que aplicaremos posterior-

mente asume que los datos sobre los que se aplica son infinitos. Para con-
trarrestar esta circunstancia, ası́ como reducir la pérdida espectral, debemos
aplicar una función de ventana sobre cada marco de los calculados previa-
mente.

Recurrimos a la función de ventana de Hamming, definida por la ecuación

(2.9), donde 0 ≤ n ≤ N − 1 y N es la longitud de marco, en nuestro caso
N = 0,025 (25ms).

2πn
w[n] = 0,54 − 0,46 cos (2.9)
N −1

25
 Figura 2.13: Representación de la función de ventana de Hamming.
Fuente: Haytham Fayek

2.12.4. Transformada de Fourier de Tiempo Reducido

(STFT )

El siguiente paso es la aplicación de una FFT de N -puntos sobre cada

marco para calcular el espectro de frecuencia, también conocida como Trans-
formada de Fourier de tiempo reducido (STFT ), donde habitualmente N
toma como valor 256 o 512.

|F F T (xi )2 |
P = (2.10)
N

Tomamos N = 512 y, a continuación, calculamos el espectro de frecuencia

(periodograma) mediante la ecuación (2.10), donde xi es el i-ésimo marco de
la señal x.

26
2.12.5. Bancos de filtros de Escala Mel

En este punto, podemos proceder a calcular los bancos de filtros mediante

la aplicación de filtros triangulares en escala Mel, generalmente 40, sobre el
espectro de potencia, con el objetivo de extraer bandas de frecuencia.

La escala Mel tiene como objetivo emular la forma no lineal de percibir el

sonido por parte del oı́do humano, siendo más discriminatorio con las bajas
frecuencias y menos con las frecuencias altas. Se puede convertir entre la
frecuencia en Hercios (f ) y la frecuencia en Mel (m) haciendo uso de las
ecuaciones (2.11) y (2.12).

f
m = 2595log10 (1 + ) (2.11)
700

f = 700(10m/2595 − 1) (2.12)

Figura 2.14: Representación de un banco de filtros en escala Mel.

Fuente: Haytham Fayek

27
 Podemos modelar los bancos de filtros mediante la ecuación (2.13).


0 k < f (m − 1)





k − f (m − 1)


f (m − 1) ≤ k < f (m)



 f (m) − f (m − 1)



Hm (k) = 1 k = f (m) (2.13)



 f (m + 1) − k
f (m) < k ≤ f (m + 1)


f (m + 1) − f (m)






0 k > f (m − 1)



Tras aplicar el banco de filtros al espectro de potencia de la señal, obte-

nemos el espectrograma de la figura 2.15.

Figura 2.15: Espectrograma de la señal de ejemplo.

Fuente: Haytham Fayek

28
2.12.6. Coeficientes Cepstrales en Frecuencias de Mel
(MFCCs)

Los bancos de filtros calculados anteriormente están altamente correlacio-

nados, lo que puede resultar conflictivo en algunos modelos de Machine Lear-
ning. Por prevención, podemos aplicar la Transformada Discreta del Coseno
(DCT ) para eliminar la correlación y producir una representación comprimi-
da de los bancos de filtros, lo que da lugar a los Coeficientes Cepstrales en
Frecuencias de Mel (MFCCs). Generalmente, para reconocimiento del habla,
se toman los coeficientes cepstrales resultantes del 2 al 13, descartando el
resto dado que representan cambios rápidos en los coeficientes de los bancos
de filtros, datos demasiado detallados que no aportan nada para tal fin. En
la figura 2.16 podemos observar los MFCCs obtenidos.

Figura 2.16: Representación de los MFCCs obtenidos de la señal de ejemplo.

Fuente: Haytham Fayek

29
2.12.7. Normalización

En última instancia podemos normalizar los MFCCs, equilibrando el es-

pectro y mejorando la relación señal/ruido (SNR), mediante la resta de la
media de los coeficientes de todos los marcos. El resultado final de la fase de
preprocesado se encuentra representado en la figura 2.17.

Figura 2.17: Representación de los MFCCs normalizados.

Fuente: Haytham Fayek

30
Capı́tulo 3

Herramientas

El diseño e implementación de modelos de Machine Learning requiere

una fase de investigación previa para elegir las herramientas a utilizar para
el desarrollo. Entre estas herramientas se encuentran el conjunto de datos
(dataset) con el que entrenaremos el modelo, las librerı́as de Machine Lear-
ning, el lenguaje de programación y el entorno de desarrollo, ası́ como el
hardware a utilizar para el entrenamiento.

En el caso de tratarse de un proyecto a desplegar, y no uno meramente

experimental como el descrito en este documento, también deberı́a evaluarse
el hardware sobre el que se pretende ejecutar el modelo para obtener predic-
ciones.

31
3.1. Dataset
Durante el diseño de un modelo de Machine Learning es fundamental
elegir correctamente el dataset a utilizar, pues influirá directamente en los
resultados obtenidos. En el caso del Procesado de Lenguaje Natural (NLP,
por sus siglas en inglés) los datasets reciben el nombre de corpus, debido a
la estrecha relación de este campo con la lingüı́stica.

En función del posible enfoque del proyecto, el tipo de dataset a escoger

ha sido diferente, aunque en ambos ha sido necesario que el dataset incluyese
ficheros de audio en formato WAVE o MP3 con sus respectivas transcripciones.
Todos los datasets valorados incluyen audios y transcripciones en inglés, dado
que permite que el sistema a desarrollar tenga un mayor impacto potencial
al ser un idioma ampliamente extendido en el ámbito tecnológico.

3.1.1. Speech Recognition

Durante el primer enfoque, en el cuál se pretendı́a conseguir reconocer el

inglés al completo, para posteriormente extraer las instrucciones a reconocer,
era necesario recurrir a un corpus de gran tamaño para poder generalizar al
máximo posible.

La mayor parte de los corpus disponibles para el reconocimiento de voz o

Speech Recognition se distribuyen de forma comercial, debido al tamaño y a la
calidad que estos deben presentar para ser utilizados por los investigadores.
Entre los corpus de pago podemos encontrar TIMIT [16] y los corpus de
Wall Street Journal [17, 18]. De los anteriores, TIMIT es el más habitual
para tomar métricas en sistemas de Reconocimiento Automático del Habla

32
(ASR, Automatic Speech Recognition).

A pesar de que su uso esté menos extendido, también existen corpus de

libre distribución, entre los que destacan TED-LIUM [19], LibriSpeech [20],
VoxForge [21] y Mozilla Common Voice [22]. En el primer enfoque del proyec-
to nos decantamos por el dataset Common Voice, por ser el de publicación
más reciente (2017) y no haber encontrado ningún trabajo previo basado en
él.

3.1.2. Keyword Spotting

El segundo enfoque del proyecto consiste en el reconocimiento de coman-

dos, que actuarı́an como disparadores de una determinada acción por parte
de un hipotético sistema. Este reconocimiento de expresiones a modo de dis-
parador se denomina Keyword Spotting.

La búsqueda de datasets para el nuevo alcance del proyecto nos llevó

a decantarnos por el dataset Speech Commands de Google [23], cuya ver-
sión 2 habı́a sido lanzada la misma semana que se encontró el reporte de la
incidencia mencionada en párrafos anteriores.

La versión 2 de Speech Commands contiene 34 palabras diferentes, de

las cuáles 24 de ellas han sido elegidas para ser útiles para su uso en aplica-
ciones del campo de Internet de las Cosas (IoT, Internet of Things) o de la
robótica. Estas 24 palabras son los comandos a reconocer por nuestra red de
neuronas, componiéndose el conjunto por los dı́gitos del 0 al 9 (cero-nueve)
y las siguientes palabras:

33
 Backward Learn Right

Down Left
Stop
Follow No
Up
Forward Off

Go On Yes

El subconjunto a utilizar del dataset cuenta, tras el preprocesado, con un

total de 49313 ficheros de entrenamiento, 12735 ficheros de validación y 14448
ficheros de test. Los ficheros de audio tienen como máximo un segundo de
longitud, en formato WAVE (.wav), con los datos de la muestra codificados
como valores PCM lineales de 16 bits de un solo canal, a una frecuencia
de 16KHz. Se han registrado 2.618 locutores, cada uno con un identificador
hexadecimal único de ocho dı́gitos.

3.2. Librerı́as de manipulación de datos

Una vez seleccionada la fuente de datos con la que alimentaremos el mode-
lo de Machine Learning, debemos manipular los mismos para eliminar datos
anómalos o corruptos, ası́ como los que no sean de nuestro interés, y poste-
riormente darles el formato adecuado.

Esta fase se denomina preprocesado, y para llevarla a cabo resulta intere-

sante apoyarse en algunas librerı́as con el objetivo de operar sobre los datos
de la forma más sencilla y óptima posible.

34
3.2.1. NumPy

Considerada como la librerı́a fundamental para realizar cualquier tipo de

cálculo cientı́fico en Python. Dispone de una abundante cantidad de opera-
ciones sobre arrays n-dimensionales (ndarrays) y matrices.

Esta librerı́a proporciona la vectorización de operaciones matemáticas

sobre el tipo de array de NumPy (numpy.array), mejorando el rendimiento
y acelerando la ejecución de las mismas.

3.2.2. SciPy Library

La librerı́a SciPy proporciona una gran cantidad rutinas numéricas efi-

cientes y sencillas de usar, tales como rutinas para integración y optimización
numérica. Se apoya en NumPy, por lo que utiliza su tipo de array en sus ru-
tinas.

En nuestro caso, ha resultado especialmente útil para las operaciones ne-

cesarias para el procesado de los ficheros de audio, tales como la obtención
de espectrogramas y el cálculo de Transformadas de Fourier de Tiempo Re-
ducido (Short-Time Fourier Transform).

3.2.3. Pandas

Pandas es una librerı́a de Python que permite trabajar de forma simple

e intuitiva con datos etiquetados y relacionales. Incluye métodos para ma-
nipular y visualizar datos rápidamente. Todo ello la convierte en la librerı́a
ideal para almacenar los datos extraı́dos del dataset, y para operar con ellos
posteriormente.

35
3.3. Librerı́as de Machine Learning
El auge del Deep Learning durante los últimos años ha propiciado la apa-
rición de diversas librerı́as que permiten el desarrollo de modelos de Machine
Learning de una forma mucho más simple, incluyendo incluso la implemen-
tación de los modelos más básicos y de los más utilizados.

El objetivo de esta sección es mostrar una pequeña descripción de las

librerı́as más populares en la actualidad, ası́ como la justificación de las li-
brerı́as elegidas.

3.3.1. SciKit-Learn

SciKit-Learn es un paquete basado en SciPy, haciendo un uso intenso

de sus operaciones matemáticas. Proporciona una interfaz concisa y consis-
tente para los algoritmos de Machine Learning más comunes, facilitando su
incorporación en sistemas en producción.

La librerı́a combina un código de calidad y una buena documentación, ası́

como una sencillez de uso y un alto rendimiento. Todo esto la ha convertido
en la librerı́a estándar para desarrollar modelos de Machine Learning en
Python.

3.3.2. PyTorch

PyTorch es un framework de Deep Learning para una experimentación

rápida y flexible. Permite la computación con tensores con una potente ace-
leración por GPU.

36
 Usualmente, se utiliza como sustituta a NumPy para aprovechar la po-
tencia de cómputo de las GPUs, proporcionando integración con librerı́as de
aceleración de GPU como Intel MKL y NVIDIA CuDNN.

3.3.3. Theano

Theano es una librerı́a que define arrays multidimensionales de una for-

ma similar a NumPy, ası́ como operaciones y expresiones matemáticas. Se
proporciona compilada, de forma que puede ejecutarse de forma eficiente en
todas las arquitecturas.

Destaca por su estrecha integración con NumPy a bajo nivel para sus
operaciones, ası́ como su optimización de uso de GPU y CPU, incrementando
el rendimiento para la computación intensiva de datos. Además, sus ajustes
de eficiencia y estabilidad permiten obtener resultados mucho más precisos,
incluso con valores muy pequeños.

3.3.4. TensorFlow

Desarrollada inicialmente por Google, desde la liberación de su código

ha ganado popularidad rápidamente, eclipsando en gran medida a las otras
alternativas.

Se basa en grafos de computación de flujo de datos, y destaca por su

sistema de nodos multicapa que permite un rápido entrenamiento de redes
de neuronas en grandes datasets. Además, se ha usado para una variedad de
aplicaciones del mundo real, como los servicios de Google para reconocimiento
de voz (Google Voice Recognition) y de identificación de objetos en imágenes

37
(Google Image Recognition).

3.3.5. Keras

Keras es una librerı́a que permite construir redes de neuronas a alto nivel,
de forma sencilla y minimalista. Está escrita en Python y permite trabajar
sobre Theano, TensorFlow y Microsoft Cognitive Toolkit (CNTK).

Keras es altamente modular y escalable, además de permitir el prototi-

pado rápido de redes de neuronas por su sencillez. Los datos se preparan en
tensores y sus modelos se basan en capas, con una capa para los tensores de
entrada, otra para los de salida y un número indeterminado de capas ocultas.

Al poder utilizar varios frameworks como back-end supone una opción

flexible, por lo que ha sido la elegida para el desarrollo del proyecto. En el
caso del back-end, hemos optado por TensorFlow, al tratarse de la opción con
más caracterı́sticas y soporte en la actualidad.

3.4. Lenguaje de programación

La mayorı́a de la documentación encontrada relativa al diseño e imple-
mentación de redes de neuronas estaba orientada a Python. Todas las librerı́as
de uso extendido en el sector, ya sean de manipulación de datos o de Ma-
chine Learning, son compatibles con este lenguaje, o directamente han sido
desarrolladas con él.

En adición a la sencillez del propio lenguaje y a su sintaxis simple, que

38
facilita el despliegue y mantenimiento del código, desde un principio se valoró
como la opción más adecuada para el desarrollo del proyecto.

También es importante destacar que se ha optado por Python 3, ya que

es la versión que más soporte recibe en la actualidad.

3.5. Entorno de desarrollo

La elección del entorno de desarrollo no influye en los resultados a obtener
en el proyecto, pero sı́ que tiene relevancia en términos de productividad. El
entorno debe permitir trabajar de forma sencilla y eficiente, dando facilidades
para poder hacer debugging sobre el código y ası́ localizar más rápido los po-
sibles errores. Además, debe ser compatible con el lenguaje de programación
elegido, mencionado en la sección anterior.

Teniendo en cuenta todas estas caracterı́sticas, desde un principio se ha

optado por recurrir a la herramienta Jupyter Notebook. Esta nos permite
desarrollar código en Python dividiéndolo en celdas, de forma que se pueden
ejecutar de forma independiente sin necesidad de ejecutar el script completo,
y observar la salida de cada fragmento de código fácilmente. Cada vez que
se ejecuta una celda, se guardan sus resultados en memoria para permitir su
utilización en las celdas que dependan de la misma.

Además, otra caracterı́stica por la que destaca Jupyter es por permitir

intercalar estas celdas de código con celdas de texto en lenguaje de marcado
Markdown. Esto permite documentar el código de una forma mucho más
extensa y legible, siendo más fácil mantenerlo y escalarlo.

39
3.6. Hardware
La elección del hardware, al contrario que el entorno de desarrollo, sı́
que influye de forma crı́tica en los resultados obtenidos en el proyecto. De él
dependerán la velocidad de procesamiento de los datos y de las operaciones
a realizar, ası́ como los recursos disponibles para el entrenamiento de la red
y la predicción con la misma. El hardware se ha elegido en función de los
recursos necesarios para cada etapa del proyecto.

En primer lugar, para la fase de preprocesado, se ha recurrido a un equipo

con procesador Intel Core i5-2400 de 4 núcleos a una frecuencia de 3.1GHz
y 10GB de memoria RAM DDR3 a 1333MHz.

Para la fase de entrenamiento de la red de neuronas el procesamiento

por CPU podrı́a resultar extremadamente lento debido a la utilización del
algoritmo de retropropagación (backpropagation), que demanda una gran po-
tencia de cómputo, por lo que es recomendable recurrir a la aceleración por
GPU. El estándar en aceleración por GPU es la librerı́a NVIDIA CUDA,
que dispone de un módulo especifico para tareas de Deep Learning llamado
CuDNN.

El equipo utilizado para la fase de preprocesado no dispone de una tar-

jeta gráfica de NVIDIA, por lo que ha sido necesario recurrir a otro equipo
distinto. Este segundo equipo dispone de un procesador Intel Core i7-4510U
con 2 núcleos y 4 hilos a una frecuencia de 3.1GHz, 16GB de memoria RAM
DDR3L y una tarjeta gráfica NVIDIA Geforce 840m con 2GB de VRAM
DDR3 y 384 núcleos CUDA. Este hardware ha sido suficiente para el desa-
rrollo del proyecto debido a que se desarrolla una arquitectura relativamente
simple para la red de neuronas, dado que trabajamos con un dataset pequeño.

40
Capı́tulo 4

Diseño

Este capı́tulo sirve para describir el problema a resolver y presentar la

estructura del proyecto, ası́ como de la arquitectura de la red de neuronas
propuesta como solución.

4.1. Descripción del problema

La detección de comandos disparadores, conocida como Keyword Spot-
ting, consiste en la distinción de determinadas palabras en una grabación de
audio, de forma que permitan lanzar de forma automática acciones por parte
del sistema. Por tanto, la solución deberá tomar como entrada ficheros de
audio. Si bien en un entorno real el sistema recibe un stream de audio de
forma continua, en el que se percibe ruido y palabras que no actúan como
disparadores, o que son desconocidas al sistema, en el alcance del proyecto
solo se contempla una primera aproximación, en la cual el sistema recibe
ficheros de audio con una duración acotada, una mı́nima cantidad de ruido,
y que siempre contienen uno de los comandos a reconocer por el sistema.

41
 “backward”

Fichero MFCCs Red de Comando

WAV neuronas reconocido

Figura 4.1: Descripción del problema.

Para abordar la solución del problema de una forma más eficiente, se opta
por dividirlo en problemas de menor complejidad, que definirán las diferentes
fases del proyecto. Estas fases se exponen en los siguientes subapartados.

4.1.1. Preprocesado

Una vez introducido un fichero de audio en el sistema, este debe ser

capaz de procesarlo para extraer los atributos o features que representan el
contenido del fichero. Para ello, tiene que realizar las siguientes operaciones:

1. Preénfasis, con un coeficiente de filtro (α) de 0,97.

2. Enmarcado, con un tamaño de marco de 25ms y un solapamiento de

10ms.

3. Aplicación de la función de ventana de Hamming.

4. Aplicación de la Transformada de Fourier de Tiempo Reducido (STFT ),

obteniendo el espectro de potencia.

5. Cálculo de los bancos de filtros en Escala Mel, obtenidos mediante

filtros triangulares. El número tı́pico de filtros triangulares a aplicar es
de 40.

42
 6. Cálculo de los Coeficientes Cepstrales en las Frecuencias de Mel (MFCC )
mediante la aplicación de la Transformada Discreta del Coseno (DCT ).
Al tratarse de un problema de Reconocimiento Automático del Habla
(ASR), nos interesa el contenido de los coeficientes cepstrales 2 a 13,
por lo que tendremos que trabajar con un total de 12.

7. Normalización, para equilibrar el espectro y mejorar la Relación Señal/Ruido

(SNR)

4.1.2. Partición del dataset

El dataset Speech Commands v2 se proporciona estructurado en carpetas,

con una carpeta por cada comando a reconocer. Por tanto, el nombre de
la carpeta en la que está contenido el fichero que se está procesando en un
determinado momento es utilizado como la etiqueta del mismo. La utilización
de una etiqueta por cada fichero es necesaria debido a que trabajamos con
aprendizaje supervisado, por lo que la red de neuronas sabe de antemano
cuál debe ser el valor inferido cuando se introduzcan los atributos.

La estructura en carpetas en función del comando nos permite también

hacer de forma sencilla el listado de ficheros a procesar, ignorando los co-
mandos que no se hayan contemplado. Dentro de cada carpeta, los ficheros
tienen un nombre en formato {HASH} nohash {NUMFICHERO}.wav, tomando
HASH el número obtenido de la función hash aplicada al nombre del locutor
del audio, con el fin de anonimizar los datos, y NUMFICHERO el número de
fichero de ese mismo locutor para ese comando. El HASH es utilizado, junto
con los porcentajes de partición del dataset, para determinar a qué partición

43
(train/dev/test) pertenece cada fichero, para lo cual se utiliza una función
del código de ejemplo proporcionado en el repositorio de TensorFlow [24].

Una vez hecha la partición de los conjuntos de entrenamiento (64 %),

validación (16 %) y test (20 %); y obtenidos los atributos y las etiquetas de
todos los ficheros de los comandos a reconocer, se deben guardar los datos
en estructuras que permitan operar fácilmente con ellos. La naturaleza de
los datos hace que la estructura ideal sean los Data Frame de la librerı́a
Pandas, donde se representa cada fichero con una columna. El encabezado
de la columna toma como valor la ruta del fichero, compuesta por el nombre
de la carpeta y el nombre del propio fichero; la primera fila toma el valor
de la etiqueta, en formato string, y la segunda fila se utiliza para almacenar
los atributos extraı́dos del fichero, compuesto por un vector de floats de
dimensiones 98x12.

4.1.3. Entrenamiento de la red de neuronas

Una vez preprocesado y particionado el dataset, los datos están listos para
ser introducidos en la red de neuronas diseñada para solucionar el problema
de Keyword Spotting. La arquitectura de la red queda definida en la sección
3 de este capı́tulo.

Los pesos de las conexiones entre neuronas deben modificarse para que la
red se adapte al problema propuesto. Esta fase de modificación de los pesos
se conoce como entrenamiento, y generalmente se realiza apoyándose en el
algoritmo de retropropagación (backpropagation).

44
4.2. Estructura del proyecto
Debido a que los requerimientos de hardware de la fase de preprocesado
del dataset y de la de entrenamiento de la red de neuronas son diferentes,
se decidió separar el código de ambas. En adición a la necesidad de testear
el sistema completo, nuestro planteamiento da lugar a que el proyecto se
estructure en 3 notebooks de Jupyter:

Preprocessing.ipynb Contiene todo el código relativo al preprocesado del

dataset, donde se toman como entrada los ficheros de audio y se obtie-
nen los MFCCs en forma de arrays de floats.

ANN-LSTM.ipynb Incluye el código de la red de neuronas. Toma los fi-

cheros obtenidos en el notebook anterior como entrada, hace una última
etapa de preprocesado para adaptar los datos al formato de entrada de
la red y, por último, define la arquitectura de la misma y permite su
entrenamiento y evaluación.

Testing-app.ipynb Sirve como plataforma para probar el funcionamiento

global del sistema desarrollado. Acepta un fichero de audio como en-
trada, realiza el preprocesado, carga la estructura y los pesos obtenidos
durante el entrenamiento de la red de neuronas, y la utiliza para inferir
el comando contenido en el fichero de audio, mostrándose este último
por pantalla.

45
4.3. Arquitectura de la Red de Neuronas
Para la creación de la arquitectura de nuestra red de neuronas hacemos
uso de 2 capas de 100 y 50 celdas LSTM [28], respectivamente, a modo de capa
de entrada en el caso de la primera y de capa oculta en la segunda. En ambas
se utilizará tanh como función de activación respetando el planteamiento
original de las celdas LSTM [5], además de aplicarse sobre ellas Dropout y
Dropout recurrente del 20 %. La capa de salida es una densamente conectada
[30] de 24 neuronas, una por cada posible clase (comando) a reconocer, todas
ellas con función de activación Softmax.

La arquitectura de nuestra red neuronal queda representada por la figura

4.2.

100 LSTM cells 50 LSTM cells 24 Dense units

LSTM LSTM Dense

input LSTM LSTM Dense output

. . .
. . .
. . .

LSTM LSTM Dense

Input layer Hidden layer Output layer

Figura 4.2: Representación de la arquitectura de la red de neuronas.

46
Capı́tulo 5

Experimentación

Tomando el planteamiento del proyecto expuesto en el capı́tulo ”Diseño”,

abordamos de forma secuencial las fases en las que se ha dividido el desa-
rrollo de la solución. En este capı́tulo se exponen los distintos experimentos
realizados durante cada una de las fases, con los obstáculos encontrados y la
forma en la que se han solventado.

5.1. Primer alcance: Speech Recognition

En un primer momento, se decidió plantear el proyecto para diseñar un
sistema de ASR completo en inglés, es decir, capaz de reconocer frases ha-
bladas en inglés, con diferentes acentos, para obtener sus transcripciones.
De esta forma, se podı́a definir un conjunto de comandos disparadores más
amplio, ası́ como reconocer el resto del contenido de una frase, permitiendo
realizar una mayor cantidad de acciones.

La complejidad del proyecto era notablemente más alta que en el segundo

alcance y, por tanto, fue necesaria una extensa fase de investigación a fin de

47
evaluar todas las posibles herramientas, arquitecturas y métricas de interés,
relacionados con las redes de neuronas de tipo LSTM [5, 6] para el desarrollo
del proyecto.

Entre los diversos datasets de libre distribución encontrados, se decidió

optar por Mozilla Common Voice, publicado en 2017, y del que no se en-
contró ningún proyecto de investigación basado en él. A pesar de no ser un
dataset especialmente grande, incluı́a una gran cantidad de ficheros de audio
en formato WAVE, con buena calidad de sonido, con frases cortas grabadas en
inglés por locutores con diferentes acentos, obteniendo de esta forma una di-
versidad geográfica de vital importancia para la capacidad de generalización
del sistema.

Tras unos meses trabajando con Common Voice se encontró una inciden-
cia reportada en la comunidad del proyecto, donde se exponı́a que el conjunto
de datos de entrenamiento (train) tenı́a solapamientos de frases y locutores
con los conjuntos de validación (dev) y test, lo que implica que cualquier
modelo basado en este corpus tenderá a sobreentrenar. El solapamiento de
frases se podı́a solucionar con un simple algoritmo de búsqueda para limpiar
los conjuntos, pero tras su aplicación quedaban únicamente 9 frases para
validación y 7 para test, insuficientes para obtener métricas de valor. No
obstante, aunque el número de frases hubiera sido suficiente, las métricas se-
guirı́an careciendo de valor por el solapamiento de locutores, que dificultarı́a
la generalización del modelo, y que no puede solucionarse salvo revisando de
forma manual el dataset.

El origen de esta incidencia está en el diseño del sistema de recolección

de frases grabadas por usuarios anónimos. Los desarrolladores han comuni-

48
cado que, a fecha de 3 de abril de 2018, el problema en la recolección está
resuelto. La resolución será efectiva para el lanzamiento de la versión 2 del
dataset, en la que se tomarán todos los datos de la versión 1 como conjunto
de entrenamiento.

5.2. Segundo alcance: Keyword Spotting

Tras el fracaso del anterior experimento, y al desconocerse la fecha de
lanzamiento de la versión 2 del dataset, se optó por cambiar el enfoque del
proyecto para limitar el alcance al propuesto en el anteproyecto, centrándonos
en el reconocimiento de entre 20 y 30 instrucciones.

Al reducirse la complejidad, dejan de resultar interesantes los posibles

modelos en los que basarnos para la arquitectura, tales como los modelos
de atención [25], Neural Speech Recognizer [26] o Connectionist Temporal
Classification [27]; dado que pueden diseñarse arquitecturas más simples para
resolver el problema.

Nuestra arquitectura se basa únicamente en celdas LSTM [5], comenzan-

do con un modelo lo más simple posible y ampliándolo en función de los
resultados obtenidos.

Dado que se utiliza Keras con TensorFlow como backend, y se pretende

recurrir a aceleración por GPU para el entrenamiento, se opta por utilizar
una implementación de LSTM especı́fica de Keras y optimizada para CUDA,
llamada CuDNNLSTM [29], cuyo funcionamiento es entre 3 y 6 veces más
rápido que la implementación tradicional de LSTM [28], siendo mayor la
diferencia de rendimiento cuanto mayor es el tamaño de la red. Es importante

49
destacar que esta implementación sólo funciona ejecutando sobre GPU y
TensorFlow, y que los datos de mejora de rendimiento proporcionados se
basan en afirmaciones del creador de Keras, François Chollet, sin haberse
aportado pruebas empı́ricas.

La fase completa de experimentación se compone de 20 posibles modelos,

donde se presentarán diferentes arquitecturas o, en algunas ocasiones, varia-
ciones de las opciones activas en cada una de las capas incluidas. Todos estos
modelos tienen como factor común una capa LSTM como entrada, sea cual
sea su implementación [28, 29], y una capa Dense [30] de 25 neuronas (24
neuronas en los modelos 19 y 20), tantas como clases a reconocer, y función
de activación Softmax, al tratarse de una red de neuronas de clases múltiples.

De estos 20 modelos, dado que algunos tienen pequeñas variaciones a

nivel de diseño o de resultados, únicamente se hace mención de los que se
han considerado más relevantes, detallándolos en los siguientes apartados.

5.2.1. Modelo 1

El primer modelo planteado tiene una arquitectura extremadamente sim-

ple, a fin de suponer una primera toma de contacto con Keras y el funciona-
miento de las capas CuDNNLSTM. Se plantea un modelo sin capas ocultas,
teniendo como capa de entrada una CuDNNLSTM de 5 celdas y la capa de
salida Dense de 25 neuronas, una por cada comando a reconocer más la clase
desconocida, donde se engloba al resto. Se plantea entrenar una única epoch.

Al tratarse de la primera experiencia trabajando con Keras surgieron, tal

y como estaba previsto, incidencias que impedı́an la ejecución del entrena-

50
miento. La primera, y la más grave, de las encontradas era relativa al formato
de entrada de los datos. La red no llegaba a iniciar el entrenamiento por una
contradicción entre el formato de entrada de los datos (2D) y el formato de
entrada esperado por la red (3D). Teóricamente, los datos de entrada debı́an
tener 3D, al tratarse de una matriz con una entrada por cada fichero, ca-
da una de ellas compuesta por una matriz de dos dimensiones: 98x12, 98
atributos de 12 MFCCs.

Tras analizar detenidamente los datos, se detectó que la forma en la que se

estaban consolidando los diferentes vectores durante la construcción de cada
uno de los conjuntos era la causa de la incidencia. El origen de la misma
radicaba en que se estaban tratando los arrays como objetos de tipo array, y
no como listas, por lo que la estructura en realidad no era una matriz 3D. Para
solucionar el problema fue necesario definir una nueva función para consolidar
los datos correctamente, llamada inputs targets split, y situada en el
notebook ANN-LSTM.ipynb.

Una vez solventado el problema con el formato de los datos de entrada,

surgió una nueva incidencia con los mismos. La función anterior lanzaba una
excepción al intentar añadir la matriz de atributos a la matriz final. Tras
analizar nuevamente el conjunto de datos de entrenamiento, se observó que
habı́a algunas entradas que tenı́an menos de 98 atributos. Se revisaron a
mano algunos de los ficheros que mostraban esta anomalı́a y se descubrió
que eran ficheros de audio incompletos, en los cuales se habı́a finalizado la
grabación antes de tiempo y no se habı́a recogido por completo el comando
correspondiente. Se solucionó el problema filtrando estos ficheros dentro de
la propia función inputs targets split, de forma que cuando se intentaba
añadir una matriz sin éxito, se guardaba la posición del vector anómalo en

51
una lista. Al terminar el procesado de datos de entrada, se eliminaban las
posiciones pertinentes de la lista de objetivos (targets).

Después de esta última modificación, se consiguió realizar el primer entre-

namiento de la red. Las métricas obtenidas carecen de relevancia pues, como
hemos expuesto inicialmente, el objetivo de este modelo era la familiarización
con Keras y el funcionamiento de las capas CuDNNLSTM.

5.2.2. Modelo 7

En los modelos 2 a 7 se fueron añadiendo unidades (celdas) a las capas

CuDNNLSTM, se aumentó el número de epochs a ejecutar a 25, configurando
una parada anticipada (EarlyStop) tras 1 epoch sin mejora de la precisión
en validación (val acc), y se aumentó el tamaño de lote (batch size) del
valor por defecto (32) a 64. Estos modelos tenı́an la finalidad de observar
la variación de las métricas a medida que se aumentaba tanto el número de
capas como el tamaño de las mismas.

El modelo 7 presenta una arquitectura con la capa de entrada de 50 uni-

dades CuDNNLSTM, dos capas ocultas CuDNNLSTM, con 50 y 25 unidades
respectivamente, y la capa de salida Dense de 24 neuronas. El modelo en-
trenó durante 12 epochs antes de hacer una parada anticipada, obteniéndose
los resultados mostrados en la tabla 5.1.

Métrica Entrenamiento Validación Test

Precisión (acc) 73,4 % 72,5 % 68,2 %
Pérdida (loss) 0,77 0,84 0,92

Tabla 5.1: Resultados del modelo 7.

52
 Figura 5.1: Métricas del modelo 7.

Con los datos anteriores se puede concluir que, si bien se consigue au-
mentar la precisión de la red, esta no termina de aprender correctamente,
viéndose reflejado en los altos valores de la pérdida.

5.2.3. Modelo 15

En los modelos 8 a 15 se continuó aumentando las dimensiones de la red,

en busca de validar si se conseguı́a mejorar los resultados de los modelos
anteriores.

53
 El modelo 15 tiene 200 unidades en su capa CuDNNLSTM de entrada,
ası́ como en las 5 capas CuDNNLSTM ocultas, y 25 unidades en la capa
Dense de salida. Además, se decidió utilizar capas de Dropout [31], con una
ratio del 20 % (0,2), a modo de regularización para probar si tenı́an algún
efecto positivo en el entrenamiento de la red. Se ejecutó durante 17 epochs
antes de realizar una parada anticipada, donde se obtuvieron los resultados
mostrados en la tabla 5.2.

Métrica Entrenamiento Validación Test

Precisión (acc) 83,7 % 70,5 % -
Pérdida (loss) 0,45 1,04 -

Tabla 5.2: Resultados del modelo 15

Los resultados anteriores muestran un claro sobreentrenamiento (overfit-

ting), dada la varianza entre la pérdida en entrenamiento y validación. No se
muestran datos de test debido a que, tras ver gráficamente los signos de over-
fitting, se decidió parar la ejecución de forma manual. Se identificó como posi-
ble causa un valor demasiado alto en la tasa de aprendizaje (learning rate),
siendo por defecto de 0,001, para el tamaño del dataset utilizado. Se decidió
reducirlo a 0,00001 para los siguientes modelos.

También se decidió incrementar el número de epochs sin mejora en la

precisión de validación antes de hacer la parada anticipada, pasando de 1
a 5; y el número total de epochs, situándolo en valores los suficientemente
altos como para dar tiempo a converger al modelo, tomando como referen-
cia el número de epochs antes de la parada anticipada del anterior modelo
entrenado.

54
 Figura 5.2: Métricas del modelo 15.

5.2.4. Modelo 18

Los cambios expuestos en el apartado anterior se aplicaron sobre el mo-

delo 17, observando unos resultados muy pobres al no llegar a converger la
gráfica de la pérdida. Se determinó que se debı́a a que el valor de la tasa de
aprendizaje era demasiado bajo, por lo que en el modelo 18 pasó a ser de
0,0001. También se planteó que podrı́a resultar útil la utilización de capas
de Dropout [31] como regularización de la red, de forma que se mitigase el
sobreentrenamiento.

Sin embargo, se identificó un punto crı́tico que podrı́a estar provocando

el sobreentrenamiento. Hasta ese momento, el entrenamiento se realizaba
con 25 posibles clases, por todos los comandos más el desconocido. La clase

55
’unknown’ contenı́a las 10 clases restantes del dataset, provocando que este
no estuviera equilibrado al haber muchas más muestras (samples) de esta
clase que del resto, lo que supone una causa del overfitting.

Ante la situación anterior, se decidió preprocesar el dataset de nuevo,

ignorando en este caso todos los comandos que no fueran a ser reconocidos,
pues el ser capaces de reconocerlos como ’unknown’ no garantizaba que el
modelo fuera capaz de generalizar ante cualquier palabra que no se encontrase
entre los comandos a reconocer.

En adición a lo anterior, se decidió seguir las pautas de ajuste de hiper-

parámetros (hyperparameter tuning) recomendadas por los desarrolladores
de la librerı́a DeepLearning4J [8], adaptando el tamaño de la red de forma
que el número de parámetros a entrenar por la red fuera próximo al número
de muestras que componı́an el conjunto de datos de entrenamiento. Por todo
ello, se decidió volver al enfoque inicial de diseñar una arquitectura lo más
simple posible, para aumentarla en función de los resultados obtenidos.

Se planteó el modelo de 18 como una red de una única capa CuDNNLSTM

de 100 unidades, además de la capa Dense de salida, con 24 unidades; dan-
do lugar a 48024 parámetros entrenables, frente a las 49313 muestras que
componen el conjunto de entrenamiento. La red entrenó durante 212 epochs,
habiéndose establecido el máximo en 1000, antes de la paradada anticipada,
y mostraba los resultados de la tabla 5.3, sin haber llegado a converger.

Métrica Entrenamiento Validación Test

Precisión (acc) 56,7 % 46,3 % 44,9 %
Pérdida (loss) 1,46 1,85 1,92

Tabla 5.3: Resultados del modelo 18.

56
 Figura 5.3: Métricas del modelo 18.

Las mesetas que podemos observar en las gráficas de la figura 5.3 se

deben a que TensorBoard toma como parámetros para graficar la fecha y
hora absolutas de ejecución de cada epoch, y el entrenamiento se ejecutó
en dos etapas: epochs 1 a 100 (azul) y epochs 101 a 212 (rojo). Podemos
observar la evolución de ambas etapas por separado en la figura 5.3.

Estos resultados mostraban que seguı́a habiendo un problema de varianza,

por la diferencia entre los resultados de entrenamiento y validación/test, y
un evidente sobreentrenamiento a pesar de haber equilibrado el dataset.

57
 Figura 5.4: Métricas relativas del modelo 18.

5.2.5. Modelo 19

Tras concluir como fallidas todas las pruebas anteriores, mostrando so-
breentrenamiento y sin conseguir corregirlo, se vio la necesidad de aplicar
técnicas de regularización sobre las capas CuDNNLSTM. Se decidió comen-
zar aplicando un Dropout del 20 % (0,2), pero se observó que este sólo podı́a
aplicarse sobre la salida de cada capa LSTM hacia la siguiente, introduciendo
una capa Dropout [31] entre ellas.

Ante esta situación, se decidió cambiar el tipo de capa a utilizar, dado

que la implementación clásica de LSTM [28] permite un mayor número de
parámetros a controlar, entre ellos la aplicación de Dropout y de Dropout
recurrente, además de tratarse de una implementación ampliamente probada,

58
al contrario que la CuDNNLSTM.

El modelo 19 tiene una arquitectura igual al modelo 18, pero cambiando la

capa CuDNNLSTM por LSTM, y añadiéndole Dropout y Dropout recurrente
de 0,2. Se obtuvieron resultados satisfactorios en cuanto al sobreentrenamien-
to, pues desapareció completamente. El entrenamiento se ejecutó durante 148
epochs antes de la parada anticipada, obteniéndose los resultados de la tabla
5.4.

Métrica Entrenamiento Validación Test

precisión (acc) 46,9 % 54,8 % 52,9 %
pérdida (loss) 1,8 1,53 1,63

Tabla 5.4: Resultados del modelo 19

Observamos en los resultados que, si bien habı́a desaparecido el sobreen-

trenamiento, el modelo presentaba falta de adaptación (underfitting), proba-
blemente causada por tratarse de un modelo demasiado simple.

59
 Figura 5.5: Métricas del modelo 19.

5.2.6. Modelo 20

El modelo anterior mostraba resultados positivos, pero también falta de

complejidad para poder adaptarse al problema planteado, por lo que se de-
cidió añadir una capa LSTM más a fin de comprobar la evolución de las
métricas obtenidas.

El modelo 20 se compone de dos capas LSTM, la primera con 100 celdas

y la segunda con 50, además de la capa Dense de salida con 24 neuronas.
En ambas se utiliza tanh como función de activación, la usada por defec-
to, respetando la implementación original; y se aplica Dropout y Dropout
recurrente de 0,2.

60
 Los resultados obtenidos quedan recogidos en la tabla 5.5. En esta ocasión,
la convergencia se alcanza con buenas métricas, por lo que concluimos que
el modelo es capaz de aprender y lo tomamos como una solución válida al
problema planteado.

Métrica Entrenamiento Validación Test

Precisión (acc) 76,8 % 82,7 % 78,7 %
Pérdida (loss) 0,75 0,57 0,69

Tabla 5.5: Resultados del modelo 20

Figura 5.6: Métricas del modelo 20.

En la figura 5.6 podemos observar los resultados del entrenamiento por las
gráficas generadas por TensorBoard. Estas gráficas se generan distribuidas en

61
el tiempo, a ello se deben las mesetas que se pueden observar en las mismas,
ya que el entrenamiento no se completó en una única ejecución debido a la
limitada disponibilidad del equipo utilizado.

En la figura 5.7 podemos observar los datos relativos de las 3 ejecuciones,

donde se ve el avance del entrenamiento omitiendo las mesetas. El entrena-
miento completo necesitó 183 epochs y 21 horas para completarse.

Figura 5.7: Métricas relativas del modelo 20.

62
5.2.7. Pruebas

Hemos abordado el desarrollo del proyecto dividiéndolo en fases, de forma

que ya hemos comprobado de forma independiente que funcionan el preproce-
sado y el entrenamiento del modelo, obteniendo las métricas de su funciona-
miento. No obstante, debemos finalizar el desarrollo del proyecto con una fase
de pruebas, en la cual comprobemos el funcionamiento del proceso completo
de la solución propuesta, desde la ingesta de ficheros de audio hasta la salida
del comando reconocido para cada fichero. Esta fase está implementada en
el notebook Test-app.ipynb.

A fin de agilizar la fase de pruebas, tomamos 2 ficheros de cada clase

a reconocer del dataset. Estos ficheros fueron elegidos de forma aleatoria, y
se pueden encontrar en la carpeta /test app samples del directorio raiz del
fichero que contiene la implementación del presente Trabajo de Fin de Grado.
Los ficheros están distribuidos de igual forma que en el dataset original,
dividiéndose por carpetas en función del comando contenido en el fichero.

La ejecución de las pruebas concluye con 6 ficheros mal clasificados de

los 47 que componen el conjunto de datos definido para este fin, suponiendo
aproximadamente un 12,8 % del total. Al tratarse de un conjunto notable-
mente más pequeño que el dataset completo no podemos comparar los por-
centajes de error, no obstante, nos sirve para validar que el modelo funciona
correctamente en la mayor parte de los casos.

En la tabla 5.6 podemos observar que, entre los 6 ficheros mal clasifica-
dos, 2 de ellos son del mismo locutor (37dca74f), y en ambos la predicción
es three. En futuras iteraciones del proyecto serı́a de utilidad analizar los
resultados en todos los ficheros de los locutores que aparecen en esta tabla,

63
 Figura 5.8: Muestra de la salida de la ejecución de Test-app.ipynb.

pues recordemos que los ficheros han sido elegidos al azar, y esta coincidencia
con el locutor 37dca74f nos lleva a plantear la hipótesis de que algunos de
los fallos encontrados podrı́an deberse a pronunciaciones singulares, con poca
representación en el dataset.

Fichero Etiqueta Predicción

37dca74f nohash 2 zero three
5ebc1cda nohash 5 six right
37dca74f nohash 1 eight three
bdd22e4d nohash 4 forward one
ff4ed4f3 nohash 1 no nine
5f9cd2eb nohash 4 learn go

Tabla 5.6: Ficheros mal clasificados en la fase de pruebas.

64
5.3. Evaluación de resultados
Los resultados obtenidos, si bien no alcanzan el estado del arte, no se
alejan en exceso. Tomamos como referencia los resultados expuestos en el
paper de publicación de la versión 2 del dataset [23], donde se reporta una
precisión de test del 88,2 % al realizar entrenamiento y test con esa versión.

No obstante, cabe destacar que los resultados del paper original y los
obtenidos en este proyecto no son del todo equiparabales pues, en primer
lugar, el tipo de red de neuronas utilizado es diferente, al haber recurrido
a celdas LSTM frente a la red convolucional utilizada en el paper original,
donde se recurrió a la arquitectura ofrecida por defecto para Keyword Spotting
en TensorFlow [32]. Además, tampoco se han utilizado las mismas métricas,
ya que el paper original implementa caracterı́sticas que quedan fuera del
alcance de nuestro proyecto, al trabajar directamente sobre streams de audio,
utilizando como métrica Top-One Error en lugar de accuracy.

En adición a lo anterior, el objetivo del proyecto era evaluar las capaci-

dades de las redes LSTM, y no alcanzar de forma imperativa el estado del
arte actual. No obstante, quedan pendientes ampliaciones del proyecto para
evaluar si es posible mejorar los resultados mediante, por ejemplo, la inclu-
sión de técnicas de regularización, la variación de la función de activación de
las celdas LSTM o el aumento de dimensiones de la red.

65
Capı́tulo 6

Conclusiones

Las celdas LSTM muestran un buen funcionamiento para Keyword Spot-

ting. A pesar de haber logrado una precisión menor que los datos de referencia
[23], no se considera que se haya explotado al máximo el potencial de esta
tecnologı́a, por lo que se espera obtener resultados similares a los logrados
con redes convolucionales en futuras iteraciones del proyecto.

Al contrario de lo previsto al principio del proyecto, la fase más compleja

del mismo no ha sido el diseño y entrenamiento de la red de neuronas sino la
elección y el preprocesado del dataset. Esto se vio especialmente acentuado
con la necesidad de pivotar en el alcance del proyecto, pasando de un sistema
de Reconocimiento Automático del Habla en el que podrı́amos identificar
comandos a un sistema de Keyword Spotting, debido a los fallos de diseño
presentados por el dataset Mozilla Common Voice y al plazo restante para
la entrega del proyecto.

Una vez cambiado el alcance del proyecto, también encontramos proble-

mas en la preparación de los datos para su ingesta al modelo en la fase de
entrenamiento, al tener que construir las estructuras de datos (DataFrames

66
de Pandas, arrays n-dimensionales de NumPy) con los resultados obtenidos
por la fase de preprocesado de audio.

A pesar de haber planteado menos problemas de los esperados, también

ha sido necesario lidiar con la tendencia al sobreentrenamiento de las celdas
LSTM, aunque en este caso se ha solucionado simplemente con la inclusión
de técnicas de regularización y mediante experimentación con las diferentes
arquitecturas planteadas para la red de neuronas.

La fase de investigación previa al proyecto fue extensa debido al descono-

cimiento del funcionamiento de la mayorı́a de las tecnologı́as y herramientas
utilizadas. En adición a tratarse del primer proyecto de estas caracterı́sticas
que realizamos, y a los problemas que ha habido que afrontar, se puede con-
cluir que el proyecto ha permitido una notable mejora respecto a nuestro nivel
de partida, suponiendo una base de experiencia que, sin duda alguna, será de
gran utilidad en futuros proyectos a realizar en el ámbito de la Inteligencia
Artificial.

67
Capı́tulo 7

Futuros Proyectos

El presente proyecto pretende suponer la primera iteración para un fu-

turible asistente virtual que funcione de forma similar Alexa o Siri. En esta
sección, detallamos algunas de las vı́as de ampliación del alcance del proyecto
desarrollado.

7.1. Streams de audio con ruido

La siguiente iteración a realizar sobre la base ya desarrollada serı́a la
capacidad de reconocer comandos contenidos en streams de audio de longitud
indeterminada, pudiendo incluirse varios comandos en un mismo stream.

Idealmente, estos streams también contendrı́an ruido de fondo, a fin de

lograr entrenar la red en un entorno lo más similar posible al real, donde
los comandos se reconocerı́an en un stream continuo obtenido mediante el
micrófono de un dispositivo, como por ejemplo un smartphone, pudiendo
estar el usuario en la calle o en cualquier lugar público, ya que no es común
que este se encuentre en un entorno libre de ruido.

68
7.2. Integración con una aplicación final
Tras añadir la capacidad de reconocimiento de los comandos en streams
de audio con ruido, el siguiente paso natural serı́a la integración del sistema
con una aplicación final en plataformas que pudieran resultar de interés, tales
como iOS y Android.

Esta integración tendrı́a como finalidad el poder utilizar el sistema en

tiempo real en un entorno no controlado, pudiendo medir ası́ de forma defi-
nitiva su efectividad, ası́ como poder ofrecer un servicio a los usuarios a pesar
de la limitación del número de instrucciones.

7.3. Aumento del conjunto de comandos

En relación con la sección anterior, llegado cierto punto de madurez de la
solución resultarı́a de utilidad añadir nuevos comandos al conjunto actual, a
fin de añadir más funcionalidades al asistente y poder integrar la aplicación
final con aplicaciones de terceros.

Este cambio de alcance podrı́a abordarse bien con un dataset más gran-
de, continuando con el planteamiento de Keyword Spotting, o bien retomar
el planteamiento de Reconocimiento Automático del Habla (ASR). Lo más
conveniente serı́a optar por el ASR, dado que nos permitirı́a reconocer tantos
comandos como quisiéramos, mejorando ası́ la escalabilidad del sistema; ası́
como por la disponibilidad de un mayor número de datasets.

69
7.4. Comparativa de arquitecturas
Con una finalidad más orientada a la investigación, serı́a deseable com-
parar con otros modelos los resultados obtenidos únicamente haciendo uso
de LSTM, una vez hayamos conseguido explotar al máximo su potencial.

Entre estos modelos, se podrı́a evaluar los resultados que se obtengan con
una combinación de LSTM con Redes de Neuronas Convolucionales (CNN),
en las que se basa la arquitectura del paper que hemos tomado como refe-
rencia [23, 32]; redes LSTM bidireccionales, en las cuales no sólo se tiene
en cuenta el contexto pasado (de estados anteriores) sino también el futuro
(estados siguientes) [33]; el desempeño de modelos de atención [25], o de las
más recientes Grid LSTM [34].

70
Bibliografı́a

[1] Goodfellow, I., Bengio, Y. and Courville, A. 2017. Deep learning. Cam-
bridge, Mass: The MIT Press.

[2] McClelland, C. 2017. The Difference Between Artificial Intelligence,

Machine Learning, and Deep Learning. Medium [en lı́nea]. [Consulta:
7 febrero 2018]. Disponible en: https://medium.com/iotforall/the-
difference-between-artificial-intelligence-machine-learning-and-deep-
learning-3aa67bff5991.

[3] Iris Dataset. UCI Machine Learning Repository [en lı́nea]. [Consulta: 28-
05-2018]. Disponible en: http://archive.ics.uci.edu/ml/datasets/Iris.

[4] Fisher,R.A. 1936. The use of multiple measurements in taxonomic pro-

blems. Annual Eugenics, 7, Part II, pp. 179-188.

[5] Hochreiter, S. and Schmidhuber, J. 1997. Long Short-Term Memory. Neu-

ral Computation. Vol. 9, pp. 1735-1780.

[6] Colah, C. 2015. Understanding LSTM Networks. GitHub [en lı́nea]. [Con-
sulta: 19-02-2018]. Disponible en: http://colah.github.io/posts/2015-08-
Understanding-LSTMs/.

[7] Grosse, R. Lecture 15: Exploding and Vanishing Gradients.

71
[8] A Beginner’s Guide to Recurrent Networks and LSTMs. Dee-
plearning4j.org [en lı́nea]. [Consulta: 10-05-2018]. Disponible en:
https://deeplearning4j.org/lstm.html.

[9] Duchi, J., Hazan, E., and Singer, Y. 2011. Adaptive Subgradient Methods
for Online Learning and Stochastic Optimization. Journal of Machine
Learning Research, 12, 2121-2159

[10] Ruder, S. 2017. An overview of gradient descent optimization algorithms.

arXiv:1609.04747

[11] Kingma, D. P., and Ba, J. L. 2015. Adam: a Method for Stochastic Op-
timization. International Conference on Learning Representations, 1–13.

[12] Zeiler, M. D. 2012. ADADELTA: An Adaptive Learning Rate Method.

arXiv:1212.5701.

[13] Srivastava, N., Hinton, G., Krizhevsky, A., Sutskever, I. and Salakhutdi-
nov, R. 2014. Dropout: A Simple Way To Prevent Neural Networks from
Overfitting. Journal of Machine Learning Research, 15, 1929-1958.

[14] Regularization for simplicity: L2 Regularization. Machine Learning

Crash Course with TensorFlow API [en lı́nea]. [Consulta: 19-03-2018].
Disponible en: https://developers.google.com/machine-learning/crash-
course/regularization-for-simplicity/l2-regularization.

[15] Fayek, H. 2016. Speech Processing for Machine Learning: Filter

banks, Mel-Frequency Cepstral Coefficients (MFCCs) and What’s In-
Between. Haythamfayek.com [en lı́nea]. [Consulta: 24-02-2018]. Dispo-
nible en: http://haythamfayek.com/2016/04/21/speech-processing-for-
machine-learning.html.

72
[16] Garofolo, John S., et al. TIMIT Acoustic-Phonetic Continuous Speech
Corpus LDC93S1. Web Download. Philadelphia: Linguistic Data Consor-
tium, 1993.

[17] Garofolo, John, et al. CSR-I (WSJ0) Sennheiser LDC93S6B. Web Down-
load. Philadelphia: Linguistic Data Consortium, 1993.

[18] CSR-II (WSJ1) Sennheiser LDC94S13B. DVD. Philadelphia: Linguistic

Data Consortium, 1994.

[19] A. Rousseau, P. Deléglise, and Y. Estève. 2012. ”TED-LIUM: an au-

tomatic speech recognition dedicated corpus”, in Proceedings of the
Eighth International Conference on Language Resources and Evaluation
(LREC’12).

[20] Panayotov, V., Chen, G., Povey, D., and Khudanpur, S. 2015. Libris-
peech: an asr corpus based on public domain audio books. In Acoustics,
Speech and Signal Processing (ICASSP), 2015 IEEE International Con-
ference, pp. 5206-5210. IEEE.

[21] VoxForge Repository [en lı́nea]. [consulta 15-02-2018]. Disponible en:

http://www.repository.voxforge1.org/downloads/SpeechCorpus/Trunk/.

[22] Mozilla Common Voice Dataset [en lı́nea]. [consulta 17-02-2018]. Dispo-
nible en: http://voice.mozilla.org/.

[23] Warden, P. 2018. Speech Commands: A Dataset for Limited-Vocabulary

Speech Recognition.

73
[24] Repositorio de Speech Commands para TensorFlow en GitHub, fichero
input data.py. GitHub [en lı́nea]. [consulta 18-04-2018]. Disponible
en: https://github.com/tensorflow/tensorflow/blob/master/tensorflow
/examples/speech commands/input data.py.

[25] Chan, W., Jaitly, N., Le, Q. V., and Vinyals, O. 2015. Listen, Attend
and Spell. arXiv:1508.01211

[26] Soltau, H., Liao, H., Sak, H. 2016. Neural Speech Recognizer: Acoustic-
to-Word LSTM Model for Large Vocabulary Speech Recognition. ar-
Xiv:1610.09975

[27] Graves, A., Fernández, S., Gomez, F., and Schmidhuber, J. 2006. Con-
nectionist Temporal Classification: Labelling Unsegmented Sequence Da-
ta with Recurrent Neural Networks.

[28] LSTM Layer. Keras Documentation [en lı́nea]. [Consulta: 20-04-2018].

Disponible en: https://keras.io/layers/recurrent/#lstm.

[29] CuDNNLSTM Layer. Keras Documentation [en lı́nea]. [Consulta: 20-04-

2018]. Disponible en: https://keras.io/layers/recurrent/#cudnnlstm.

[30] Dense Layer. Keras Documentation [en lı́nea]. [Consulta: 20-04-2018].

Disponible en: https://keras.io/layers/core/#dense.

[31] Dropout Layer. Keras Documentation [en lı́nea]. [Consulta: 10-05-2018].

Disponible en: https://keras.io/layers/core/#dropout.

74
[32] Sainath, T. N. and Parada, C. 2015. Convolutional Neural Net-
works for Small-Footprint Keyword Spotting. Sixteenth Annual Con-
ference of the International Speech Communication Association.
[en lı́nea]. [Consulta: 10-05-2018]. Disponible en: https://www.isca-
speech.org/archive/interspeech 2015/papers/i15 1478.pdf.

[33] Graves, A. and Schmidhuber, J. 2005. Framewise Phoneme Classification

with Bidirectional LSTM and Other Neural Network Architectures.

[34] Kalchbrenner, N., Danihelka, I. and Graves, A. 2015. Grid Long Short-
Term Memory.

75