Universidad Politécnica

de Madrid
Escuela Técnica Superior de
Ingenieros Informáticos

Grado en Ingeniería Informática

Trabajo Fin de Grado

Desarrollo de un Chatbot y Aplicación

Web para Clasificar Sonidos del Cielo
Enfocada a un Público Infantil

Autora: Noelia Martínez Díaz

Tutor(a): Raquel Cedazo León

Madrid, mayo 2021

Este Trabajo Fin de Grado se ha depositado en la ETSI Informáticos de la
Universidad Politécnica de Madrid para su defensa.

Trabajo Fin de Grado

Grado en Ingeniería Informática
Título: Desarrollo de un Chatbot y Aplicación Web para Clasificar Sonidos del
Cielo Enfocada a un Público Infantil
Marzo 2021

Autora: Noelia Martínez Díaz

Tutora:
Raquel Cedazo León
Ingeniería Eléctrica, Electrónica Automática y Física Aplicada
ETSI Informáticos
Universidad Politécnica de Madrid
Resumen
Este trabajo Fin de Grado forma parte del proyecto Sonidos del Cielo, que tiene
como objetivo hacer accesible la ciencia a personas con discapacidad visual así
como al público infantil a través de un experimento de ciencia ciudadana para
la clasificación de meteoros a partir de sus sonidos.
Los sonidos de meteoros empleados en este proyecto se generan a partir de los
datos recogidos por diversas estaciones de radiodetección que registran ecos de
meteoros. Estas estaciones forman parte del proyecto Contadores de Estrellas,
y hacen posible la radiodetección de meteoros, una técnica muy novedosa para
estudiar estos objetos ampliamente conocidos como estrellas fugaces.
En este trabajo en particular, se aborda el diseño y desarrollo de la aplicación
centrada en el público infantil que hace posible la clasificación de meteoros a
partir de los sonidos generados. Para ello, se desarrollará una aplicación capaz
de automatizar una conversación inteligente a través del lenguaje natural, con
lo que se conoce generalmente como un chatbot. Gracias a esta herramienta se
podrá gamificar la aplicación y se facilitará el acceso a la aplicación a niños que
no necesariamente sepan leer o escribir.

El proyecto incluye dos fases principales de desarrollo centradas

respectivamente en: desarrollo del chatbot y desarrollo de la aplicación web. Por
un lado, será necesario diseñar un flujo de diálogo que permita una interacción
amigable y clara con niños de primaria e implementarlo para entrenar al agente
o chatbot. Y por otro lado, será necesario crear una aplicación web donde
integrar este chatbot así como los servicios de reconocimiento y síntesis de voz
que permitan recibir y emitir las respuestas.

i
Abstract
This Final Degree Project is part of the Sky Sounds project, a initiative that aims
to make science accessible to people with visual disabilities, as well as to
children, through a Citizen Science experiment for meteor classification based
on sounds.

The meteor sounds used in this project are generated from data collected by
different Radiodetection stations that record meteor echoes. These stations are
part of the project Star Counters (Contadores de Estrellas) and make possible
the use of the novel technique of radio detection for studying the objects widely
known shooting stars.

This work focuses on the design and development of the application for children
that makes possible the classification based on sounds, an application which
could be used trough a natural language conversation with a chatbot. This
technology will allow to gamify the application and to increase its accessibility
regarding children that will not necessarily be able to read.

The complete project includes two main development phases: the development
of the chatbot, and the development of the web application. On the one hand, it
will be necessary to design a dialogue flow that allow a friendly and clear
interaction with elementary school children and to implement this flow to train
the chatbot. And, on the other hand, it will be necessary to create a web
application to integrate this chatbot as well as the voice recognition and
synthesis services that allow receiving inputs and responding.

ii
Tabla de contenidos
1 Introducción ......................................................................................1
1.1 Motivación del proyecto ...................................................................... 1
1.2 Contexto del proyecto ......................................................................... 2
1.3 Objetivos ............................................................................................ 5
1.4 Estructura del documento .................................................................. 6
2 Tecnologías del Proyecto y Estado del Arte ........................................7
2.1 Chatbots ............................................................................................ 7
2.1.1 ¿Qué es un chatbot? .................................................................... 7
2.1.2 Historia de los Chatbots ............................................................... 8
2.1.3 Aplicaciones de los Chatbots ...................................................... 13
2.1.3.1 Medicina ................................................................................. 13
2.1.3.2 Educación............................................................................... 14
2.1.3.3 Atención al cliente .................................................................. 15
2.1.3.4 Información ............................................................................ 16
2.1.3.5 Entretenimiento ...................................................................... 17
2.1.4 Ventajas e Inconvenientes de los Chatbots ................................. 17
2.1.4.1 Ventajas del uso de chatbots .................................................. 17
2.1.4.2 Desventajas del uso de chatbots ............................................. 18
2.1.5 Tecnologías para el Desarrollo de Chatbots ................................ 18
2.1.5.1 Frameworks o plataformas actuales para la creación de chatbots
19
2.1.5.2 Librerías para la creación de chatbots..................................... 23
2.2 Reconocimiento y Síntesis de Voz ..................................................... 25
2.2.1 Reconocimiento de voz ............................................................... 25
2.2.1.1 ¿Qué es el reconocimiento de voz? .......................................... 25
2.2.1.2 Historia del reconocimiento de voz .......................................... 26
2.2.1.3 Tecnologías actuales para el reconocimiento de voz ................ 27
2.2.2 Síntesis de voz ........................................................................... 30
2.2.2.1 ¿Qué es la síntesis de voz? ...................................................... 30
2.2.2.2 Historia de la síntesis de voz ................................................... 31
2.2.2.3 Tecnologías para la síntesis de voz .......................................... 32
2.3 Aplicaciones web .............................................................................. 34
2.3.1 ¿Qué son las aplicaciones web? ................................................. 34
2.3.2 Historia de la web ...................................................................... 36
2.3.3 Tecnologías actuales para el diseño y desarrollo de aplicaciones web
38
2.3.3.1 React ...................................................................................... 38
2.3.3.2 Angular ................................................................................... 39

iii
 2.3.3.3 Vue.js ..................................................................................... 40
3 Desarrollo ........................................................................................41
3.1 Elección de Tecnologías .................................................................... 41
3.1.1 Tecnología para Chatbot ............................................................ 41
3.1.2 Tecnología para Reconocimiento y Síntesis de Voz ..................... 45
3.1.3 Tecnología para Desarrollo Web ................................................. 45
3.2 Arquitectura ..................................................................................... 47
3.3 Chatbot ............................................................................................ 49
3.3.1 Creación del Entorno y Proyecto en Rasa ................................... 49
3.3.2 Diseño del Flujo de Diálogo del Chatbot ..................................... 56
3.3.3 Diseño del Conjunto de Datos para el Chatbot ........................... 59
3.3.4 Implementación de la Lógica del Chatbot ................................... 66
3.3.5 Entrenamiento del Chatbot ........................................................ 76
3.3.6 Pruebas y Correcciones del Chatbot ........................................... 77
3.4 Aplicación web ................................................................................. 79
3.4.1 Diseño de la Interfaz Web ........................................................... 79
3.4.2 Implementación de la primera versión de la interfaz web de la
aplicación ............................................................................................... 83
3.4.3 Creación de Servicios de Reconocimiento y Síntesis de Voz para la
web 84
3.4.4 Creación del Servicio de Procesamiento de Lenguaje para la Web
87
3.4.5 Comprobación y Corrección de la Interfaz Web para el Diseño
Responsive ............................................................................................. 91
3.4.6 Elementos de Gamificación en la Aplicación ............................... 95
3.4.7 Pruebas de funcionamiento básico de la aplicación y correcciones
97
3.5 Despliegue........................................................................................ 98
3.6 Diseño e implementación de mejoras .............................................. 100
4 Resultados y conclusiones .............................................................102
4.1 Resultados ..................................................................................... 102
4.2 Conclusiones .................................................................................. 108
5 Análisis de Impacto .......................................................................111
5.1 Impacto personal ............................................................................ 111
5.2 Impacto empresarial ....................................................................... 111
5.3 Impacto social ................................................................................ 112
5.4 Impacto económico ......................................................................... 112
5.5 Impacto medioambiental ................................................................ 113
5.6 Impacto cultural ............................................................................. 113
6 Bibliografía ....................................................................................115

iv
7 Anexos ...........................................................................................121
7.1 Repositorios del trabajo .................................................................. 121
7.2 Capturas de la API de Rasa ............................................................ 121

v
1 Introducción
1.1 Motivación del proyecto

La principal motivación de este trabajo, así como del proyecto completo Sonidos
del Cielo1, es hacer accesible la Astronomía a la mayor parte de la sociedad, en
este caso, poniendo especial atención a un grupo social: los niños.
Esta idea de hacer accesible la ciencia constituye una de las bases del concepto
Ciencia Ciudadana. De acuerdo con la Comisión Europea, este término engloba
una parte de la ciencia abierta en la que los ciudadanos pueden participar en
la investigación científica de distintas formas, ya sea a través de la observación,
financiación, análisis o aportando datos [1]. Gracias a este trabajo, los usuarios
podrán ayudar a científicos y astrónomos con sus clasificaciones de meteoros
identificando algunas de las características generales del sonido como su
duración o la presencia de variaciones en el mismo.
Además, como se recoge en el artículo Ciencia ciudadana en la sociedad de la
información: nuevas tendencias a nivel mundial, la Ciencia Ciudadana es un tipo
de producción científica que se basa en una participación totalmente voluntaria
en la que no se precisa conocimientos previos [2], por lo que incluso los niños
de corta edad pueden colaborar en este tipo de proyectos. En este experimento
en particular, no es necesario que los niños tengan nociones previas sobre
astronomía, ya que únicamente tendrán que ir respondiendo a unas sencillas
preguntas sobre los sonidos. Asimismo, tampoco será necesario que los niños
sepan leer o escribir dado que se emplean mecanismos de reconocimiento y
síntesis de voz que permitirán a los niños hablar con el chatbot de la aplicación
de forma oral.
Como parte de esta motivación de hacer accesible la ciencia a la mayor parte de
la sociedad, y en concreto a los niños, también cabe destacar la creciente
popularidad y uso de las tecnologías en este colectivo. De acuerdo con el
Instituto Nacional de Estadística de España (INE), tal y como se muestra en la
Figura 1, en el pasado año 2020 un 91% de niños de entre 10 y 15 años hizo
uso del ordenador, un 94,5% hizo uso de internet y un 69,5% disponía ya de
un dispositivo móvil [3]. Estas cifras indican que una gran mayoría de la
población en el rango de edad de 10 y 15 años está familiarizada con las
tecnologías y el acceso a internet, por lo que facilitar el experimento a través de
una aplicación web podría aumentar su alcance entre este público.

Figura 1. Porcentaje de menores usuarios de TIC. 2020 (% de población de 10

a 15 años)

1 http://www.sonidosdelcielo.org/
1
No obstante, dado que el proyecto también va dirigido a niños con edad inferior
a los 10 años, idealmente a niños en educación primaria (de 6 a 12 años),
podrían existir usuarios con menor grado de familiaridad con estas tecnologías.
Con el fin de paliar esta posible brecha en el conocimiento y manejo de estos
recursos, se emplea una interfaz gráfica sencilla con distintos componentes que
gamifican la aplicación y pueden resultar intuitivos y atractivos para los niños
de todas las edades.
Como se recoge en el libro Gamificación: fundamentos y aplicaciones, la
gamificación consiste fundamentalmente en aplicar elementos propios de juegos
en distintos contextos (no lúdicos) para estimular la motivación de las personas
en distintos entornos, como la educación [4]. Con esta motivación y estímulo,
la aplicación podría conseguir atraer a este público infantil y promover así la
ciencia de manera divertida, además podría resultar más intuitiva y familiar a
este colectivo, ya que un gran porcentaje de niños son usuarios habituales de
videojuegos. En concreto, de acuerdo con el anuario de 2019 de la Asociación
Española de Videojuegos (AEVI), un 75% de los niños entre 6 y 10 años jugaban
a videojuegos en España, así como un 68% de los niños entre 11 y 14 años [5].

Figura 2. Perfil de los jugadores según el Anuario 2010 de AEVI.

Estas cifras indican que emplear la gamificación dentro de un proyecto de

ciencia ciudadana como este podría dar buenos resultados, ya que se podría
fomentar la participación de los más pequeños, al presentarse en un formato
familiar para la mayoría de ellos.

1.2 Contexto del proyecto

El presente trabajo surge como parte del proyecto de ciencia ciudadana Sonidos
del Cielo, un proyecto que trata de hacer accesible la Astronomía al público
general, poniendo especial atención en varios grupos sociales específicos: las
personas invidentes y los niños.

2
El proyecto se compone de diversas aplicaciones que permiten la clasificación
de meteoros a partir de los datos obtenidos por varias estaciones de
radiodetección. Estos datos son presentados en forma de gráficas (curvas de luz
y espectrogramas) y sonidos que se generan por ordenador partiendo de dichos
datos, de modo que una persona puede extraer información tanto visualmente
como acústicamente sobre el meteoro.
El proceso de obtención de datos se lleva a cabo por radiodetección de meteoros,
una técnica para estudiar lo que se conoce coloquialmente como estrellas
fugaces. Tal y como se explica en la documentación del proyecto Sonidos del
Cielo, cuando los meteoroides entran en las partes más densas de la atmósfera,
la fricción provoca un aumento importante de su temperatura, de forma que a
una altura entre 80 y 100 kilómetros de la tierra, la temperatura del meteorito
es tan elevada que produce su ablación y sublimación. Este proceso deja un
rastro de electrones libres que refleja las ondas de radio, fenómeno que se
aprovecha para realizar la detección en sí del meteoro. Así pues, cuando un
radar emite una señal y esta se refleja hacia adelante en la estela ionizada de
un meteorito se produce un nuevo registro de eco [6].
La primera herramienta que ofrece Sonidos del Cielo para la clasificación de
meteoros a partir de estas detecciones es el experimento en la plataforma online
de Ciencia Ciudadana Zooniverse. En esta plataforma se encuentran
disponibles dos formas en las que los ciudadanos pueden ayudar a clasificar
meteoros, la Clasificación por sonidos y la Clasificación por imágenes [7].
En la Clasificación por sonidos se reproduce un sonido y se presenta una gráfica
con la frecuencia y una línea de tiempo que refleja visualmente los datos del
sonido. La primera pregunta que se realiza en este experimento pretende
distinguir entre los distintos tipos de estelas. Si la estela dura menos de 1
segundo se considera que se trata de una estela subdensa, es decir, contiene
una densidad de electrones libres por debajo de un umbral; si por el contrario
la estela dura más de un segundo se considera sobredensa, es decir, la densidad
de electrones libres está por encima del umbral. Respecto a este último tipo,
además, se puede distinguir entre estelas sobredensas de corta duración que
duren entre 1 y 5 segundos y estelas sobredensas de larga duración, de más de
9 segundos. Con la segunda pregunta se pretende detectar la presencia de ecos
de meteoroide, que se producen antes que los ecos de estela. Para ello se
pregunta si se escucha al principio un sonido corto (eco de meteoroide) y luego
un silencio o sonido menos intenso (eco de la estela) o si por el contrario no hay
ninguna variación en el sonido. Y finalmente, con la tercera pregunta se
pretende identificar si hay eco de meteoroide con efecto Doppler, por lo que se
pregunta si hay un sonido inicial con un tono distinto al resto.

3
 Figura 3. Clasificación por sonidos de Sonidos del Cielo

En el caso de la Clasificación por imágenes, en lugar de reproducir sonidos se

muestra la curva de luz (a la izquierda) y el espectrograma (a la derecha) de la
detección. En este caso las preguntas varían, aunque se pretende extraer la
misma información. En la primera pregunta se pide seleccionar la forma a la
que más se parece la curva de luz con el objetivo de distinguir si la estela es
subdensa, sobredensa corta o sobredensa larga. En la segunda pregunta se pide
identificar si hay una discontinuidad en la parte baja del espectrograma, lo cual
indicará la presencia de un eco de meteoroide. En la tercera pregunta se pedirá
que se identifique un pico al principio de la curva de luz, para confirmar la
presencia del eco de meteoroide. Y finalmente en la cuarta pregunta se
preguntará acerca de si hay un tramo horizontal en la parte más baja del
espectrograma, ya que tener la señal desplazada en frecuencia indicará la
presencia de efecto Doppler.

Figura 4. Clasificación por imágenes de Sonidos del Cielo

4
Partiendo de este experimento en Zooniverse, se crearán dos aplicaciones más
que traten de adaptar dicho experimento para hacerlo accesible a dos grupos
sociales distintos: las personas invidentes y los niños. Por una parte, la versión
para personas con problemas de visión tendrá que ofrecer una interfaz
plenamente funcional a través de voz. En este caso será una versión muy similar
a la que encontramos en el modo de Clasificación por sonidos de Zooniverse, ya
que se espera que el público al que va dirigida la aplicación comprenda la
formulación de las preguntas, aunque no será necesario incluir gráficas de
sonido (ni ningún otro tipo de elemento gráfico). Y por otra parte, la versión para
niños podrá incluir elementos más gráficos para reforzar la gamificación del
experimento y tendrá una versión adaptada de las preguntas del experimento
en Zooniverse para facilitar su comprensión. En este trabajo se abordará
únicamente el diseño y desarrollo de esta última versión de la aplicación, es
decir, la versión para niños.
El proyecto completo, Sonidos del Cielo, ha sido promovido por el grupo de
investigación Citizen Science Lab de la Universidad Politécnica de Madrid, que
además coordina todas las actividades de desarrollo y divulgación del proyecto.
También colaboran en el proyecto el Instituto Astrofísico de Canarias (IAC), el
Grupo Docente de Astronomía Kepler y la Agrupación Astronómica Madrid Sur
(AAMS). De entre todos los colaboradores, los docentes del Grupo Kepler y
aficionados de la Agrupación de Astronomía Madrid Sur serán los que llevarán
a cabo la mayor parte de las tareas divulgativas ya que estas dos entidades
cuentan con una sede en el Aula de Astronomía de Fuenlabrada (Madrid) con
excelentes instalaciones donde realizan visitas de numerosos colegios. Estos
colaboradores, se encargarán también de supervisar los diálogos de la
aplicación para niños y realizarán talleres con grupos escolares de modo que
los niños puedan aprender sobre los meteoros y puedan también probar la
aplicación una vez desarrollada.
Además de los colaboradores ya mencionados, el proyecto Sonidos del Cielo ha
sido financiado por la Fundación Española para la Ciencia y la Tecnología
(FECYT). En la Figura 5 se muestran los logos de todas las entidades
colaboradores del proyecto que hacen posible su desarrollo.

Figura 5. Clasificación por imágenes de Sonidos del Cielo

1.3 Objetivos

Partiendo de la lista de objetivos iniciales de la propuesta de trabajo y las

especificaciones recogidas en las reuniones iniciales del proyecto, los objetivos
de este trabajo son los que se listan a continuación:
x Estudio y análisis del estado del arte de los chatbots, tecnologías de
reconocimiento y síntesis de voz y tecnologías de desarrollo web.
x Creación de la interfaz conversacional de un chatbot.
x Desarrollo de una interfaz web del experimento de clasificación de
meteoros para público infantil.

5
 x Integración del chatbot en la interfaz web.
x Integración de módulos de reconocimiento y síntesis de voz.
x Realización de pruebas y análisis de resultados obtenidos.
x Desarrollo de una guía de usuario.

1.4 Estructura del documento

El presente documento se estructura en distintos capítulos y subcapítulos tal y

como se recoge en la tabla de contenidos.
En el Capítulo 2 se presenta el estado del arte de las tecnologías necesarias para
el desarrollo del proyecto. Este capítulo contiene además información sobre la
historia y el funcionamiento de las herramientas conocidas como chatbots,
sobre los mecanismos de reconocimiento y síntesis de voz, así como de las
herramientas de desarrollo web actuales.
El Capítulo 3 recoge el desarrollo completo del trabajo. En este capítulo se
encuentra la información relativa a la elección de tecnologías basada en el
estudio y análisis de las herramientas vistas en el Capítulo 2, la elección y
diseño de la arquitectura, el diseño y desarrollo del chatbot, el diseño y
desarrollo de la aplicación web, el despliegue de la aplicación y las mejoras
finales.
El Capítulo 4 se destina a los resultados del trabajo realizado y análisis de las
posibles mejoras y trabajos futuros. Además, se incluye una valoración personal
del trabajo realizado y consideraciones adicionales.
En el Capítulo 5 se realiza un estudio del posible impacto de la aplicación. En
este capítulo se analiza el posible impacto atendiendo al ámbito personal,
empresarial, social, económico, medioambiental y cultural. Aquí se destacan los
beneficios esperados, así como también los posibles efectos perjudiciales de la
aplicación.
En el Capítulo 6 se presenta la Bibliografía del trabajo. En este apartado de la
memoria se encuentran todas las referencias bibliográficas utilizadas en la
memoria del proyecto de acuerdo con el estándar IEEE.
Finalmente, el Capítulo 7 contiene el Anexo donde se recoge la información
relativa a los repositorios en Github empleados durante el proyecto, en los que
se encuentra el código fuente del proyecto completo y las llamadas a la API del
chatbot correspondientes a los flujos programados en el trabajo.

6
2 Tecnologías del Proyecto y Estado del Arte
En este capítulo se presenta el estudio realizado sobre las tecnologías que se
pretenden emplear en el proyecto: Chatbots, Reconocimiento y Síntesis de Voz
y Aplicaciones Web. Este estudio incluye información general sobre las
tecnologías, su historia así como su estado del arte, con el fin de ofrecer una
base de conocimiento suficiente para poder evaluar en adelante qué
herramientas se emplearán en el desarrollo del proyecto.

2.1 Chatbots

2.1.1 ¿Qué es un chatbot?

De acuerdo con la Fundación del Español Urgente, también conocida como

Fundéu, el término chatbot alude a “programas que, basados en Inteligencia
Artificial, permiten mantener una conversación hombre-máquina simulando las
respuestas que daría una persona” [8]. Según esta misma organización,
asesorada por la Real Academia Española (RAE), la palabra chatbot se trata de
un sustantivo creado por acronimia, es decir, uniendo elementos de dos o más
palabras ya existentes, en este caso la palabra chat y la palabra robot.
Distintas fuentes, como el diccionario de gramática inglesa Grammarist,
afirman que el término chatbot, en particular, tiene un origen reciente. Se cree
que Michael Maudlin acuñó el término por primera vez en la década de 1990,
periodo en el cual inventó su chatbot Julia para Windows [9]. Sin embargo,
existen otros ejemplos anteriores a este programa que encajarían en la
definición de chatbot, como se explicará en los próximos apartados del capítulo.
Otros términos para hacer referencia a este mismo concepto son chatterbot,
talkbot o incluso asistente inteligente o virtual, aunque a menudo se considera
que los asistentes no son exactamente chatbots. En el artículo Yes, Chatbots
and Virtual Assistants Are Different! de Forbes, por ejemplo, se establece que los
chatbots carecen de comprensión de emociones humanas, mientras que los
asistentes virtuales son capaces de tratar con estas complejidades que forman
parte del lenguaje. Además, se afirma también que los chatbots no son capaces
de recordar el contexto de la conversación, mientras que los asistentes sí [10].
Algo similar establece el blog de tecnología Freshdesk, en el que van más allá
estableciendo diferencias según la tecnología que emplean, las funcionalidades,
los canales o las interfaces [11], tal y como se muestra en la Tabla 1. Sin
embargo, empresas como IBM o Microsoft suelen utilizar todos estos términos
indistintamente, ya que no hay consenso en si realmente se tratan de
tecnologías diferentes.
Chatbot Asistente virtual
Tecnología x Programas basados en x Machine Learning
reglas x Procesamiento del
x Machine Learning Lenguaje Natural
x Procesamiento del x Comprensión del
Lenguaje Natural Lenguaje Natural
x Inteligencia Artificial

7
 Funcionalidades x Asiste a empresas y x Asiste a los usuarios
clientes en tareas diarias.
x Sirve como plataforma x Encaja en
experimental conversaciones
casuales o divertidas.
Canales x Páginas web x Teléfonos móviles
x Portales de asistencia x Portátiles
x Canales de mensajería x Altavoces inteligentes
x Aplicaciones móviles o dispositivos
x Widgets en aplicaciones interactivos
Interfaz x Interfaz conversacional x Interfaz de chat
de usuario x Comandos de voz

Tabla 1. Diferencias clave entre chatbots y asistentes virtuales según Flashdesk

En este trabajo se utilizarán los términos presentados en este apartado

indistintamente, sin tener en cuenta posibles matices que no hayan sido
ampliamente aceptados.

2.1.2 Historia de los Chatbots

En 1950, la revista Mind publicó el artículo Computing Machinery and

Intelligence [12], uno de los más conocidos escritos de Alan Turing, el prestigioso
matemático considerado hoy en día como uno de los padres de la computación.
Este artículo académico resulto ser muy influyente en distintas áreas como la
informática ya que en él Turing propuso una pregunta revolucionaria “¿Pueden
pensar las máquinas?” (“Can machines think?”, en su versión inglesa).
Para conceptualizar este problema, Turing plantea un juego conocido como
Imitation Game. En este juego participan tres personas: un hombre (A), una
mujer (B) y un interrogador (C) que puede ser de cualquier género. El objetivo
del juego consiste en que el interrogador tiene que determinar quién de los dos
otros dos participantes es el hombre y cual es una mujer, teniendo en cuenta
que no podrá ver ni escuchar a ninguno de las otras dos personas y que solo se
comunicará con ellos por escrito. Con ello, los participantes podrán hacerse
pasar por el otro participante para confundir al interrogador.
Tras plantear esta versión inicial del juego, Turing propone una nueva pregunta:
¿qué pasaría si uno de los participantes fuese una máquina? En este caso, la
máquina tendría que hacerse pasar por una de las dos personas y convencer al
interrogador de que es quien dice ser.

8
Figura 6. Representación gráfica del juego Imitation Game propuesto por Alan
Turing en Computing Machinery and Intelligence (1950)

Este juego es lo que hoy se conoce como el Test de Turing, y la idea en la que
se basa es la que resultó ser uno de los pilares básicos para la Inteligencia
Artificial. Siguiendo con el criterio planteado, una máquina o programa pasaría
el Test de Turing si consiguiese engañar a un humano, haciéndole pensar que
está hablando con un humano, no con una máquina.
Tras el planteamiento de este problema, en 1966, Joseph Weizenbaum creó en
el Instituto Tecnológico de Massachussets (MIT) el primer chatbot que imitaba
la conversación humana: ELIZA. Este chatbot hacía posible mantener una
conversación a través de lenguaje natural con un ordenador a través de
entradas de texto por teclado; era capaz de dada una frase de entrada, generar
respuestas adecuadas gracias al uso de palabras clave y reglas de
descomposición. En concreto, las frases de entrada se analizaban sobre una
base de reglas de descomposición activadas por la aparición de palabras clave
en dichas frases de entrada; hecho esto, las respuestas se generaban aplicando
reglas de reensamblaje asociadas a las reglas de descomposición previamente
seleccionadas [13].
ELIZA tuvo un gran impacto en esta área ya que sirvió de base para la creación
de chatbots posteriores como ChatterBot, un jugador virtual del juego
multiusuario TinyMud creado en 1989. El objetivo de ChatterBot era hablar con
otros usuarios y explorar el juego como cualquier otro jugador. De este modo,
el uso de este chatbot aplicaba directamente el, ya mencionado, Test de Turing
puesto que todos los jugadores asumían que el resto de los jugadores eran
personas y se desconocía la existencia de este jugador virtual [14].
Sin embargo, no todos los chatbots que surgieron después de ELIZA estaban
basados en este chatbot, algunos simplemente fueron inspirados por este
precursor. En 1972, el psiquiatra Kenneth Colby, en Standford, creó a PARRY,
un chatbot que imitaba a una persona con esquizofrenia paranoide. Con este
chatbot se pretendía crear un modelo de simulación por ordenador que
incluyese la teoría que trata de explicar el comportamiento paranoico. En este
caso el modelo se componía de dos partes: el módulo de análisis y el de
interpretación-acción [15]. Los resultados de este proyecto fueron muy positivos,
y la aparición de un nuevo sistema de procesamiento de lenguaje natural capaz
de hablar como un humano hizo posible por fin las conversaciones entre
máquinas. Algunos artículos como Dialogues with Colorful Personalities of Early
AI muestran diálogos entre PARRY y ELIZA en los que se aprecia la diferencia

9
entre sus estilos de habla, como si se tratasen realmente de dos personas
manteniendo una conversación [16]. El encuentro más conocido entre estos dos
chatbots se produjo en la primera conferencia internacional conocida como
International Conference on Computer Communications (ICCC) en 1972.
Años más tarde, en 1995, Richard Wallace creó ALICE (Artificial Linguistic
Internet Computer Entity), un chatbot inspirado en ELIZA que buscaba un
resultado más natural en la conversación. Algunas de las principales novedades
de este chatbot eran su uso del Artificial Intelligence Markup Language (AIML),
su arquitectura estímulo-respuesta, y también que contaba con más de 40.000
categorías de conocimiento, mientras que ELIZA solo disponía de 400. Además
de esto, el uso de ALICE a través de la web permitió la recopilación de muestras
de lenguaje natural a una escala sin precedentes en este campo. A pesar de ello,
el modelo de ALICE era supervisado, por lo que el papel de la persona encargada
del aprendizaje resultaba crucial. Esta persona monitorizaba las conversaciones
del chatbot y creaba nuevo contenido AIML para mejorar las respuestas y hacer
más creíble o humano al chatbot. Estas mejoras hicieron posible que ALICE
ganase el Loebner Prize, un Test de Turing que se realiza anualmente para
premiar chatbot que mejor imite a un humano, hasta en tres ocasiones (en el
2000, 2001 y 2004) [17].
Estos fueron algunos de los chatbots más relevantes en el panorama durante
los primeros años desde su aparición, no obstante, se crearon muchos otros
que ayudaron a cimentar las bases del estudio del procesamiento del lenguaje
natural en la simulación de conversaciones humanas. Por ejemplo, en 1988, el
informático británico Rollo Carpenter creó Cleverbot (cuya primera versión fue
conocida como Jabberwacky), un chatbot que elige cómo responder de manera
difusa y contextual comparando la conversación actual con los millones de
conversaciones que ya ha tenido anteriormente [18]. Y, en 2005, Steve Worswick
creó a Mitsuku con la tecnología de Pandorabots AIML, un chatbot con la
personalidad de una chica de Leeds de 18 años. Hoy día, Mitsuku (también
conocida como Kuki) es accesible a través de Facebook, Telegram, Twitch o Kik
Messenger [19] y tiene el récor Guinness del mundo de mayor número de
premios Loebner obtenidos con un total de 5 (en 2013, 2016, 2017, 2018 y
2019) [20].

Figura 7. Imagen de Mitsuku (Kuki), chatbot desarrollado por Steve Worswick

A partir de la aparición de estos primeros chatbots, la variedad de tecnologías

empleadas para su desarrollo y la diversificación en sus posibles aplicaciones

10
fue creciendo; uno de los avances que más afectaría al desarrollo de estas
herramientas fue su uso como asistentes en dispositivos móviles u ordenadores.
Uno de los primeros chatbots que comenzó a emplearse como un asistente de
usuarios de móvil fue Siri, considerado el primer asistente inteligente personal.
Siri fue creado por Adam Cheyer, Dog Kittlaus y Tom Gruber en 2008 en Siri
Inc., una empresa derivada de SRI International. Este chatbot no se hizo
popular hasta que, en 2010, Apple adquirió Siri Inc. e incorporó a Siri como una
aplicación en su iPhone 4S [21]. Una de las mayores novedades de este chatbot
fue la posibilidad de hablar con él a través de voz, no de texto escrito;
actualmente, basta con decir en voz alta el comando “Oye Siri” para comenzar
a hablar con él. Con el paso de los años, Siri ha llegado a estar integrado en
todos los dispositivos de la marca Apple y aprende constantemente gracias al
aprendizaje automático. Además, se puede configurar en un total de 21 idiomas
y puede aprender palabras poco comunes si se le deletrea. Con todo ello, Siri
permite hacer llamadas, hacer cálculos, poner una alarma, leer mensajes o en
general, hablar con cualquier aplicación con una gran naturalidad a través del
lenguaje natural hablado [22].

Figura 8. Capturas de pantalla de la página de información de Siri en la web

oficial de Apple

Un año después de que Apple adquiriera Siri, en 2011, ocurrió un nuevo hito
en la historia de los chatbots, y en general de la Inteligencia Artificial. Este año,
Watson, el sistema cognitivo de IBM logró ganar en el concurso de televisión
Jeopardy! a sus dos contrincantes humanos. Este desafío requería incorporar
una gran variedad de técnicas para lidiar con situaciones de pregunta-
respuesta como: análisis sintáctico, clasificación de preguntas, descomposición
de preguntas, adquisición y evaluación automática, detección de entidades y
relaciones, generación lógica y representación y razonamiento del conocimiento
[23]. Watson era capaz de descomponer el lenguaje humano para identificar
inferencias con una precisión similar a la humana y a velocidades y escalas
mucho más rápidas, lo que le permitía alcanzar un nivel de precisión muy alto
cuando se trata de entender cuál era la respuesta correcta a una pregunta. A
11
diferencia de un humano, Watson no era capaz de entender palabras
individuales, sino que entendía las características del lenguaje, lo que le
permitía saber si de una pregunta se podía inferir una determinada respuesta.
En concreto, el procesamiento que realiza Watson desde que recibe una
pregunta hasta alcanzar una respuesta es el que se muestra en la siguiente
figura (ver Figura 9).

Figura 9. Cómo Watson logra una respuesta a una pregunta en The Era of
Cognitive Systems: An Inside Look at IBM Watson and How it Works.

Como se observa en la Figura 9, cuando Watson recibe una pregunta la

descompone para extraer sus principales características. Es entonces cuando
genera varias hipótesis acerca de potenciales respuestas y compara cada una
de estas posibles respuestas con la pregunta empleando diversos algoritmos de
razonamiento. Estos algoritmos producen una o varias puntuaciones que
reflejan cómo de posible es inferir la respuesta a partir de la pregunta, y una
vez se obtienen, el siguiente paso consiste en ponderar estas puntuaciones de
acuerdo con un modelo estadístico. Para cada potencial respuesta se realizan
estos cálculos, y finalmente se hace un ranking con los resultados de precisión
para las respuestas, de manera que Watson responde con aquella que tenga
una mejor puntuación [24].
Unos años más tarde, un nuevo chatbot que recordaba al ya mencionado Siri,
fue creado Microsoft. En 2014, la compañía hizo pública la llegada de Cortana,
el nuevo asistente digital integrado en Windows Phone 8.1. Microsoft anunció
que este chatbot no solo ejecutaba comandos por voz sino que aprendía de los
usuarios gracias a técnicas de aprendizaje automático. De acuerdo con los
responsables del desarrollo de Cortana, los investigadores de la empresa habían
centrado sus esfuerzos en estudiar las tecnologías básicas de los asistentes
personales o chatbots, siendo estas el reconocimiento de voz, el procesamiento
semántico del lenguaje, el modelado de diálogo y la generación o síntesis de voz
[25].
Este mismo año, Amazon anunció también su propio asistente Alexa junto a su
nuevo producto Echo. Sus creadores se habían inspirado en el sistema de
conversación del Starship Enterprise de Star Treck y permitía realizar distintas
acciones a partir de peticiones en lenguaje natural como reproducir música,
crear listas o dar información entre otras. Aunque en inicio solo estaba
disponible a través de los altavoces inteligentes Echo, Amazon puso a Alexa a

12
disposición del mercado, de modo que hoy en día se trata de uno de los chatbots
más populares mundialmente ya permite controlar una gran variedad de
dispositivos inteligentes compatibles con este sistema [26]. Dos años más tarde,
en mayo del 2016, Google siguió el ejemplo de estas empresas tecnológicas con
su propio asistente: Google Assistant. En este caso, como en los últimos
ejemplos, el chatbot se podía emplear desde teléfonos, relojes, televisores, así
como otros dispositivos inteligentes, y permitía realizar acciones a través de
peticiones por voz [27].

2.1.3 Aplicaciones de los Chatbots

La evolución de los chatbots ha hecho posible que el número de usos y

potenciales aplicaciones de estas herramientas aumente en los últimos años.
Como se vio en el apartado anterior (Historia de los chatbots), uno de los usos
más populares es de asistente personal o asistente de productividad, pero esta
tecnología ha demostrado ser de gran utilidad también en otras áreas como
medicina, educación, atención al cliente, banca, información o entretenimiento.

2.1.3.1 Medicina

Una de las aplicaciones más beneficiosas de los chatbots para la sociedad es la

medicina. De acuerdo con el artículo Health Care Chatbots Are Here to Help,
publicado en la revista IEEE Pulse, los chatbots tienen un futuro por delante
en esta área ya que pueden ayudar tanto a los médicos profesionales como a los
pacientes que necesiten información o atención médica. Por un lado, esta
tecnología facilita la interacción de los médicos con registros médicos de gran
tamaño y les permite también obtener información acerca de los medicamentos
rápidamente. Por otro lado, los chatbots permiten a los pacientes fijar citas con
sus médicos y pueden ser un primer punto de contacto de atención primaria, al
ser capaces de identificar síntomas y recomendar siguientes pasos. No obstante,
cabe destacar el hecho de que los chatbots no están diseñados para diagnosticar
a los pacientes, sino que su labor consiste en guiar a las personas e identificar
si una persona está realmente enferma y debería ver a un médico. Entre las
principales ventajas del uso de chatbots en medicina destaca su gran
accesibilidad, ya que los pacientes podrían acceder a estos servicios a través de
su propio móvil, y su bajo coste [28].
Un ejemplo de chatbot de uso médico es Babylon, de la empresa Babylon Health
fundada en 2013 en Londres. Babylon entiende e interpreta los síntomas que
los pacientes introducen y les ofrece información relevante sobre su salud
identificando los factores de riesgo relacionados. La red neuronal de este
chatbot fue creada a partir de millones de datos recopilados por científicos y
doctores, por lo que tras hablar con un paciente, Babylon puede comparar la
información recibida con condiciones conocidas y enfermedades que
potencialmente encajarían con esta información. Además, la empresa Babylon
Health también ha lanzado recientemente el Asistente de Atención COVID-19
(COVID-19 Care Assistant) que ofrece información de los Servicios de Salud
Nacional de Inglaterra (National Health Service in England, o NHS) con el fin de
proporcionar información verídica sobre el coronavirus a sus usuarios, hacer
una primera comprobación de los síntomas y ofrecer ayuda para pasar el
confinamiento [29].

13
 Figura 10. Ejemplo de conversación con Babylon, de Babylon Health

2.1.3.2 Educación

La educación se basa en gran medida en la comunicación e interacción, por lo

que los chatbots tienen también un gran potencial en este campo, al ser capaces
de comunicarse mediante lenguaje natural como lo haría una persona.
Un chatbot no sustituye a las figuras docentes, pero puede ofrecer ayuda a los
estudiantes de distintas formas. En ocasiones los chatbots prestan asistencia
personal al alumno gestionando su calendario, correo o recordándole las tareas
y entregas de evaluación. También son capaces de resolver preguntas frecuentes
tanto de administración como de conceptos y contenidos de aprendizaje.
Acompañan al estudiante durante el aprendizaje y a menudo contribuyen a la
motivación personal, dándole refuerzo positivo. Permiten practicar diálogos en
distintos idiomas por nivel de conocimiento del alumno y simulando distintos
contextos y roles. Y, además, pueden evaluar el aprendizaje de los estudiantes
ofreciéndoles retroalimentación en tiempo real [30].
Un ejemplo de chatbot empleado en educación es Andy, un chatbot que permite
aprender inglés simulando conversaciones reales. Andy ayuda a sus usuarios a
aprender de forma amigable a través de lecciones de gramática o incluso a través
del diálogo [31].

14
 Figura 11. Ejemplo de conversación con Andy

2.1.3.3 Atención al cliente

Un uso muy frecuente de los chatbots es el de dar soporte o atención al cliente.

El objetivo puede ser muy distinto según los casos, el chatbot puede atender
clientes en una página web para resolver dudas sobre la web, sobre un servicio
o comercio, puede ayudar a un cliente a resolver o notificar una incidencia,
puede mantener activos a los clientes de una marca informándoles sobre nuevos
productos con el objetivo de generar ventas, puede encargarse de gestionar
reservas o pedidos negocios como restaurantes, o incluso puede encargarse de
tramitar las ventas de una tienda.
De acuerdo con un estudio realizado a nivel global por LivePerson en 2017, un
89% de los consumidores encuestados tenía una percepción de los chatbots de
atención al cliente positiva o neutra, siendo un únicamente un 11% de los
encuestados los que tenían una opinión negativa. Además, según este mismo
informe, una gran parte de los encuestados crían que los chatbots son una
forma de proporcionarles un servicio de calidad y más rápido, no una simple
herramienta empleada por las empresas para ahorrarse dinero [32].
Un ejemplo de chatbot de atención al cliente popular es Helper Bot de Just Eat
Reino Unido. Este chatbot fue creado para ayudar a los clientes de la conocida
empresa de reparto de comida a domicilio con sus pedidos y permite realizar
diversas acciones como: confirmar el estado del pedido y tiempo de entrega,
ayudar al usuario si su pedido ha sido rechazado, ayudar al usuario si falta
algún producto de su pedido, o dejar reseñas de un pedido [33].

15
 Figura 12. Ejemplo de conversación con Helper Bot de Just Eat Reino Unido

2.1.3.4 Información

En relación con la aplicación de chatbots para la atención a clientes, otro de los

usos más populares de los chatbots es proporcionar información. En estos casos,
los chatbots serían como un portal de consultas, pero con una interfaz en
lenguaje natural y con integración en un gran número de plataformas de
mensajería instantánea como Whatsapp, Telegram, o Facebook Messenger entre
otros.
Un ejemplo muy reciente e interesante es el del chatbot de Alerta de Salud de
la Organización Mundial de la Salud (WHO Health Alert), un chatbot creado por
la Orgnización Mundial de la Salud para que las personas se mantengan
informadas y seguras y puedan consultar información fiable sobre el
coronavirus de forma rápida [34].

Figura 13. WHO Health Alert en Whatsapp

16
2.1.3.5 Entretenimiento

A pesar de que esta aplicación de los chatbots se ha visto eclipsada por algunas
de las anteriores (medicina, educación, atención al cliente, o información), no
se puede olvidar uno de los primeros usos de esta tecnología: el entretenimiento.
Algunos de los ejemplos presentados en el capítulo Historia de los chatbots,
como Cleverbot o Mitsuku, además de tener un gran valor por su aporte en la
investigación y desarrollo de los chatbots, aportaban un gran entretenimiento a
los usuarios que se atrevían a probarlos a través de sus respectivas páginas
web. Hoy en día, es posible hablar con chatbots como Mitsuku (ver Figura 14)
no solo a través de sus sitios web sino también a través de sus integraciones en
plataformas de mensajería instantánea y pasar un buen rato simplemente
charlando [35].

Figura 14. Ejemplo de conversación con Mitsuku (Kuki)

2.1.4 Ventajas e Inconvenientes de los Chatbots

Tras haber estudiado la historia y aplicaciones de los chatbots es posible

identificar algunas de las ventajas y desventajas de utilizar chatbots en distintos
contextos.

2.1.4.1 Ventajas del uso de chatbots

x Disponibilidad ilimitada e inmediata: en general los chatbots suelen estar

operativos constantemente lo que permite a los usuarios comunicarse
con ellos en cualquier momento y desde cualquier lugar.
x Accesibilidad: los chatbots con interfaz de voz pueden ser empleados
fácilmente por personas que no sepan leer o que tengan algún tipo de

17
 discapacidad que les impida introducir o leer texto en un dispositivo de
forma manual.
x Reducción de dependencia humana: se evita la intervención de una
persona (asistente o trabajador en general) en casos sencillos que puedan
ser automatizados, pero sin perder el trato natural y directo con el
usuario o cliente.
x Reducción de costes: ya que estas herramientas permiten prescindir de
un exceso de personal y permite dar un servicio de 24 horas sin costes
adicionales, las empresas que ofrecen asistentes de este tipo pueden
ahorrar dinero sin sacrificar calidad en su servicio.
x Rapidez: los chatbots son capaces de ofrecer respuestas de manera
mucho más rápida que un humano.
x Mantienen la imagen de las marcas: a diferencia de un humano, un
chatbot proporciona una experiencia homogénea a todos sus usuarios y
no se ve afectado por cambios de humor, de modo que estos factores no
podrán afectar negativamente a las empresas que usen este tipo de
asistentes para el trato con clientes.

2.1.4.2 Desventajas del uso de chatbots

x Necesidad de entrenamiento: para que un chatbot funcione

correctamente tendrá que ser entrenado con datos útiles que representen
las posibles conversaciones a las que se enfrentará.
x Mantenimiento: para que un chatbot siga mejorando en su capacidad de
entender y responder adecuadamente a sus usuarios será necesario
recopilar información de las conversaciones que ya ha tenido o mejorar
su sistema de aprendizaje para así reentrenar periódicamente al sistema.
x Personalización limitada: la mayoría de los chatbots hablan a todos sus
interlocutores por igual o presentan poca variabilidad en sus
conversaciones con distintos usuarios, a diferencia de las personas, que
ajustan su diálogo en función de con quién estén hablando.
x Inversión de recursos (tiempo y/o dinero): tanto si se desarrolla desde
cero como si se utilizan herramientas específicas para el diseño de
chatbots, será necesario invertir al menos tiempo en definir cuál será el
propósito del chatbot y qué tipo de conversaciones tendrá. Si se opta por
contratar el desarrollo o la herramienta de creación de chatbots, además
de esto se necesitará pagar por el desarrollo o por la cuota de uso del
servicio.
x Posibles malentendidos: puede que haya situaciones en las que el
chatbot no entienda lo que el usuario intenta decir y esto podría producir
un bloqueo del flujo de conversación. Uno de los motivos que podría
ocasionar estos fallos podría ser que el chatbot no haya sido entrenado
con el tipo de información que el usuario necesita, lo que podría generar
frustración en el usuario.

2.1.5 Tecnologías para el Desarrollo de Chatbots

En la actualidad existen distintos tipos de tecnologías que permiten la creación

de chatbots, en concreto, es frecuente optar por frameworks o plataformas y
librerías que facilitan su creación. En los siguientes apartados se recogen por

18
un lado los frameworks y plataformas que incluyen un conjunto de
herramientas para crear chatbots, así como algunas de las librerías que
permiten realizar determinadas funciones relacionadas con el procesamiento
del lenguaje natural para la creación de chatbots.

2.1.5.1 Frameworks o plataformas actuales para la creación de chatbots

Un framework es un marco de trabajo con una serie de conceptos

estandarizados y unos criterios y prácticas asociados a la resolución del tipo de
problemática con la que esté relacionado dicho marco. Para el caso concreto de
la creación de chatbots existen una gran cantidad de frameworks, sin embargo,
son pocos los que destacan por su uso extendido. A continuación se recogen
algunos de los más populares en la actualidad.

2.1.5.1.1 Microsoft Bot Framework

Microsoft Bot Framework es la solución que ofrece Microsoft para crear chatbots
de manera sencilla y rápida. Este marco hace uso de los servicios cognitivos de
Azure (Azure Cognitive Services), por lo que los chatbots tienen la habilidad de
hablar, escuchar y comprender. Dentro de estos servicios cognitivos se
encuentra LUIS (Language Understanding Intelligent Service), el sistema de
procesamiento natural de Microsoft.
El marco hace posible la creación de chatbots mediante el diseñador visual Bot
Framework Composer así como a través de código (NodeJS y C#), gracias a su
SDK Bot Framework, y ofrece así una gran versatilidad. Además, permite la
integración de los chatbot en una gran variedad de canales como Skpe, Slack,
Facebook Messenger o Microsoft Teams entre otros [36].

Figura 15. Componentes de Bot Framework de Microsoft

19
No obstante, este sistema es de pago. En la actualidad, es necesario pagar los
recursos consumidos por este framework, incluyendo así los costes de Azure
Bot Service, LUIS, QnA Maker API y el servicio de voz.

2.1.5.1.2 Amazon Lex

Amazon Lex es el servicio de Amazon para la creación de conversaciones por voz

y texto. Este servicio ofrece funcionalidades de aprendizaje profundo para el
reconocimiento automático de voz y transcripción de voz a texto, así como
también la tecnología de comprensión del lenguaje, de modo que permite crear
conversaciones realistas. El funcionamiento de esta herramienta es sencillo, ya
que basta con establecer algunas frases de ejemplo y Amazon Lex se encarga de
la creación del modelo de lenguaje natural completo.

Figura 16. Funcionamiento de Amazon Lex de Amazon

Como todos los servicios de Amazon Web Service (AWS) este servicio escala
automáticamente bajo demanda, por lo que no es necesario preocuparse por el
hardware ni la administración de la infraestructura. Además, Amazon Lex
puede aprovechar la capacidad de Amazon Web Service para sacar partido
también a otras de sus funciones de seguridad, almacenamiento, o
monitorización, entre otras.
Respecto a la integración, Amazon Lex permite una integración sencilla de los
chatbots en distintos canales como por ejemplo Facebook Messenger, Slack y
Twilio SMS.
Sin embargo, aunque actualmente Amazon ofrece 10.000 solicitudes de texto y
50.000 solicitudes de voz gratuitas por mes durante 12 meses con la capa
gratuita de Amazon Web Service, este servicio es también de pago. Los cobros
se realizan en función de las solicitudes de texto o voz, por lo que se aplican
precios por uso, sin cargos anticipados ni mínimos de consumo [37].

20
2.1.5.1.3 Google Dialogflow

Dialogflow es la solución para la creación de chatbots de Google. Se trata de

una plataforma de desarrollo completa para crear chatbots de voz y texto y que
hace uso de la tecnología de Inteligencia Artificial de Google. Una de sus
características principales es su compilador visual de flujos que permite la
visualización y edición de los flujos de diálogo. Dialogflow ofrece también los
últimos modelos comprensión de lenguaje natural basados en BERT
(Bidirectional Encoder Representations from Transformers), un algoritmo que
hace uso de redes neuronales de Google para mejorar el procesamiento del
lenguaje natural. Además, los modelos creados pueden basarse en el estado, de
modo que los usuarios pueden desviarse del tema principal y luego volver a
retomar el tema sin producir errores.
Dialogflow se trata de una herramienta para la gestión integral de chatbots, de
manera que todas las necesidades de gestión de los agentes (analíticas,
experimentos o evaluación), y no se necesita emplear herramientas adicionales.
Además, como en los ejemplos anteriores, permite la integración de los chatbots
en distintos canales como Facebook Messenger, Hangouts, LINE, Slack,
Telegram o su integración en plataformas socias de Google como AudioCodes,
Avaya, Genesys o SignalWire [38].
Esta herramienta es también de pago, de modo que el precio se calcula cada
mes en función de la edición y el número de solicitudes realizadas en ese período
de tiempo.

2.1.5.1.4 IBM Watson Assistant

IBM Watson Assistant se trata de una de las soluciones más populares para la
creación de chatbots, creada por IBM. El sistema está pensado para ser usado
por personas que no saben programar, ya que ofrece una interfaz intuitiva y
una biblioteca de contenido que facilita su uso. Este servicio utiliza técnicas
avanzadas de Inteligencia Artificial para identificar y crear recomendaciones de
intención, detectar tendencias y problemas en el momento o aprender de las
elecciones hechas por los usuarios. Además, es capaz de resolver situaciones
de desambiguación e incluye modelos pre-entrenados para la comprensión del
lenguaje natural. También permite la personalización de voz y se puede ajustar
a los distintos dialectos o acentos de los usuarios. Este sistema gestiona
fácilmente varios temas durante las conversaciones y ayuda a los usuarios
cuando no saben cómo seguir la conversación.
IBM Watson ofrece, como en los ejemplos anteriores, una integración
multicanal: en web, en aplicaciones de telefonía (para llamadas de voz) y
plataformas de mensajería instantánea.
No obstante, se trata también de un servicio de pago, ya que aunque ofrece una
versión Lite, la mayoría de las funcionalidades solo están disponibles en las
versiones de pago, disponibles a partir de 140 USD al mes [39].

2.1.5.1.5 Rasa

Rasa es el framework gratuito de código abierto líder en la actualidad. Esta

tecnología permite gracias a uno de sus principales componentes, Rasa NLU
21
(Natural Language Understanding), entender los mensajes, clasificar las
intenciones y capturar el contexto, y además da soporte a múltiples idiomas.
Una de las principales ventajas de esta solución frente a las propuestas de
grandes empresas como Microsoft, IBM o Google es que está basada por
completo en código abierto, de modo que el proceso de desarrollo y test es
transparente, y permite añadir código propio (Python o YML). Este framework
permite personalizar la infraestructura del sistema sin limitar, como otras
tecnologías, las opciones a las del ecosistema de la compañía que provee la
herramienta. Además facilita la creación arquitecturas muy modulares y
extensibles y la integración en numerosos canales, gracias a sus integraciones
prediseñadas y sus módulos de integración personalizables.
Puesto que puede desplegarse en una infraestructura propia, respeta la
privacidad al máximo y cede al equipo de desarrollo la responsabilidad de
hacerse cargo de sus propios datos y modelos. Además, resulta sencillo
reaprovechar el trabajo realizado en nuevos proyectos.
Como ya se ha mencionado, también ofrece facilidad para la integración de los
chatbots en canales como páginas web, Facebook Messenger, Slack, Telegram,
Twilio, Google Hangouts, Microsoft Bot Framework, Cisco Webex Teams,
RocketChat, Mattermost y canales personalizados, gracias a la existencia de
conectores personalizables.
En este caso, Rasa Open Source es totalmente gratuito, por lo que se puede
hacer uso del framework sin tener que pagar por su uso o por llamadas al
servicio, al estar este alojado en máquinas propias. Esto hace que los chatbots
que se creen no vayan asociados a ninguna cuenta, los desarrolladores podrán
modificar el chatbot sin depender de terceros y sin necesidad de cuentas
especiales de otras compañías [40].

2.1.5.1.6 Wit.ai

Wit.ai es un framework de código abierto para la creación de chatbots que fue

adquirido en 2015 por Facebook. Este framework permite la creación de
chatbots a través de su plataforma web de manera sencilla, pero también cuenta
con varios Software Development Kits (SDK) para implementar los chatbots a
través de código (Node.js, Python, Ruby o Go).
Para crear chatbots a través de la web es necesario acceder con una cuenta de
usuario de Facebook y crear una nueva aplicación. Una vez hecho esto, es
posible entrenar al chatbot proporcionando ejemplos de frases que el usuario
dirá al chatbot cuando quiera llevar a cabo una acción, de este modo, cuantos
más ejemplos se proporcione al chatbot, mejor aprenderá a reconocer las
intenciones de la persona. Una vez el haya aprendido las intenciones típicas a
las que se enfrentará es posible hacer peticiones a la API de Wit.ai desde otras
aplicaciones para comenzar a hablar [41].
A pesar de tratarse de un framework de código abierto, y sin costes, es necesario
disponer de una cuenta de Facebook para crear chatbots, y además es necesario
aceptar los términos y condiciones de uso de Facebook, lo que puede limitar la
versatilidad de la herramienta.

22
2.1.5.1.7 Botpress

Botpress es también un framework de código abierto para la creación de

chatbots. Este marco ofrece una interfaz visual para diseñar los flujos de
conversación (Conversational Studio), mecanismos de comprensión del lenguaje
natural (NLU) para identificar intenciones, un panel para analizar el
funcionamiento del chatbot, un Software Developer Kit (SDK) para ampliar la
flexibilidad de sus funcionalidades, y un emulador y debugger para probar el
chatbot sin dejar el Conversational Studio. Además, como en otros frameworks,
es posible integrar los chatbots que se creen con otras aplicaciones como
Microsoft Teams o Slack.

Figura 17. Interfaz de la aplicación de Botpress

Botpress es un framework gratuito, por lo que es posible hacer uso de todas sus
funcionalidades sin pagar, aunque ofrece soporte adicional (si se quiere)
pagando una cuota mensual [42].

2.1.5.2 Librerías para la creación de chatbots

Una librería se trata de un conjunto de implementaciones de funciones con una

interfaz claramente definida que han sido codificadas en un lenguaje de
programación concreto. Existen diversas librerías que se emplean para
desarrollar chatbots o algunas partes de ellos, a continuación se recogen
algunas de las más usadas en la actualidad.

2.1.5.2.1 Chatterbot

ChatterBot es una librería de Python que permite generar respuestas

automáticas dada la entrada de un usuario gracias a los algoritmos de Machine
Learning que utiliza. Esta librería tiene un diseño independiente del idioma, por
lo que se puede entrenar a un chatbot para hablar en cualquier lengua. Puesto
que una instancia sin entrenar de ChatterBot no dispone de ningún tipo de
conocimiento para comunicarse, se pueden introducir frases y respuestas para
que el chatbot aprenda qué debe responder en cada ocasión. Además, cada vez

23
que un usuario habla, ChatterBot almacena la frase y la respuesta de manera
que su precisión aumenta con el número de conversaciones que haya tenido
[43].

2.1.5.2.2 ChatbotAI

ChatbotAI es una librería de Python que facilita la creación de chatbots. Hace

uso de técnicas de Inteligencia Artificial para la creación de chatbots y además
ofrece un controlador de conversaciones. Algunas de las funcionalidades que
proporciona son el aprendizaje, la gestión de memoria, el cambio condicional y
el manejo de conversaciones basadas en distintos temas.
Además, ChatbotAI facilita también la integración de los chatbots gracias al uso
de llamadas REST [44].

2.1.5.2.3 Natural Language Tool Kit (NLTK)

Natural Language Tool Kit, más conocida como NLTK, es una de las librerías
más destacadas de Python para el procesamiento de lenguaje natural. De
acuerdo con la documentación oficial de la librería, ofrece interfaces para más
de cincuenta corpus y recursos léxicos, así como un conjunto de bibliotecas de
procesamiento de texto para clasificación, tokenización, derivación, etiquetado
o análisis y razonamiento semántico [45].

2.1.5.2.4 PyNLPl

PyNLPl es una librería de Python de Procesamiento de Lenguaje Natural que

contiene diversos módulos para la realización de distintas tareas como la
extracción de n-gramas y listas de frecuencias, la construcción de modelos
simples. También permite la realización de tareas más complejas e incluye
clientes para varios servidores de Procesamiento de Lenguaje Natural. En
especial, PyNLPl dispone de una librería muy extensa para trabajar con el
formato de anotación lingüística FoLiA XML [46].

2.1.5.2.5 spaCy

spaCy es otra de las librerías de código abierto en Python para crear aplicaciones
de Procesamiento del Lenguaje Natural. Esta librería ofrece algunas funciones
como la tokeninzación o segmentación del texto en palabras o símbolos, el
etiquetado de palabras, la detección de frases, la detección de palabras similares,
la clasificación de texto para asignar categorías o etiquetas a documentos o la
detección de coincidencias basada en reglas. Además de esto, spaCy ofrece
vectores pre-entrenados en distintos idiomas que facilitan la creación de
modelos cuando se dispone de un conjunto de datos de entrenamiento reducido
[47].

24
2.1.5.2.6 TextBlob

TextBlob es otra librería de Python para procesamiento de texto. Algunas de las

funciones que ofrece son extracción de frases, etiquetado de palabras, análisis
de sentimientos, clasificación de texto, tokenización, cálculo de frecuencias,
segmentación de texto, extracción de n-gramas, derivación de palabras, y
corrección gramatical [48].

2.2 Reconocimiento y Síntesis de Voz

Chatbots como Siri, Cortana, Google Assistant o Alexa ofrecen hoy en día una
interfaz por voz que hace que los usuarios puedan comunicarse a través del
habla, sin necesidad de un teclado para introducir texto escrito o una pantalla
para leer las respuestas. Esto es posible gracias a los sistemas de
reconocimiento y síntesis de voz que permiten respectivamente identificar las
palabras y frases que un usuario dice mediante lenguaje natural hablado y
responder por voz a aquello que el usuario ha dicho.
En este subcapítulo se explica qué es un sistema de reconocimiento de voz y un
sistema de síntesis de voz y qué tecnologías existen actualmente para reconocer
y sintetizar la voz humana.

2.2.1 Reconocimiento de voz

2.2.1.1 ¿Qué es el reconocimiento de voz?

El reconocimiento de voz, o reconocimiento del habla (en inglés speech

recognition) es el área de la Inteligencia Artificial en la que se estudia la
capacidad de las máquinas para identificar y entender una sentencia o comando
del habla humana y reaccionar consecuentemente.
De acuerdo con la publicación del IEEE Overview of the Speech Recognition
Technology [49], el reconocimiento del habla se basa en el estudio de la voz, y
permite que se identifique y entienda el lenguaje humano hablado gracias al
procesamiento de la señal del habla y el reconocimiento de patrones. Es por
tanto un área multidisciplinar que incluye entre otras la acústica, la fonética,
la lingüística a teoría de la información, la teoría de reconocimiento de patrones
o la neurobiología.
En general, este tipo de sistemas son fundamentalmente de sistemas de
reconocimiento de patrones e incluyen pasos como la extracción de
características, la coincidencia de patrones y componentes como las bibliotecas
para la creación de modelos. Normalmente, primero la voz se transforma en una
señal eléctrica y se pre-procesa para que el sistema pueda analizarla y extraiga
las características del sonido. Hecho esto, se establece una plantilla de
reconocimiento y, de este modo, el sistema determina un modelo de acuerdo
con las características detectadas. Así pues, finalmente, se produce la búsqueda
de coincidencias de la entrada con la plantilla para el reconocimiento de
palabras o frases concretas.

25
 Señal de voz
Preprocesado

Identificación
Extracción de Extracción de
características características
Resultados

Entrenamiento
Modelo

Figura 18. Principios básicos de un sistema de reconocimiento del habla

(traducido de Overview of the Speech Recognition Technology)

2.2.1.2 Historia del reconocimiento de voz

Se considera que el primer ejemplo de sistema de reconocimiento de voz

moderno fue creado en 1952 en los Laboratorios Bell. Este sistema, conocido
con el nombre de Audrey, fue creado por K. H. Davis, R. Biddulph y S. Balashek,
y permitía reconocer dígitos en lenguaje natural hablado. El funcionamiento de
Audrey se describe en detalle en su publicación Automatic Recognition of Spoken
Digits, donde sus creadores explican cómo se emplearon los datos cuantitativos
estadísticos extraídos de las señales de voz para crear este sistema [50].
Casi diez años más tarde, en 1960, William C. Dersch de IBM desarrolló
Shoebox, un sistema que era capaz de reconocer y responder a un total de 16
palabras habladas en inglés, incluyendo de nuevo los dígitos del 0 al 9, o
comandos como “plus”, “minus” o “total”, de modo que permitía realizar
operaciones a través de comandos de voz. Shoebox recuperaba el sonido
recibido a través de un micrófono que convertía los sonidos en señales eléctricas,
y posteriormente, su circuito clasificaba estas señales de acuerdo con el tipo de
sonido [51].
Durante estos años, alrededor del mundo se trabajó en sistemas hardware
capaces de reconocer sonidos y habla humana y a finales de la década de 1960
estos sistemas conseguían reconocer palabras de hasta cuatro vocales y nueve
consonantes [52].
El siguiente gran hito en el reconocimiento de habla no ocurrió hasta la década
de 1970, gracias al Departamento de Defensa de los Estados Unidos (DARPA).
En esta década se llevó a cabo el programa de Investigación de Comprensión del
Habla (Speech Understanding Research o SUR), en el que desarrollaron el
sistema de reconocimiento del habla Harpy, capaz de entender hasta 1.000
palabras. Harpy se basó en dos sistemas anteriores desarrollados en la
Universidad Carnegie-Mellon: Hearsay-I, en el que el conocimiento se
representaba como procedimientos, y Dragon, que representaba el conocimiento

26
como redes de Markov con transición de probabilidad a priori entre los estados.
Tras el análisis sistémico de rendimiento de ambos sistemas se creó Harpy, un
sistema en el que el conocimiento se representaba como una red de transición
de estados finita sin transición de probabilidades a priori. Las mejoras que
proponía este sistema eran principalmente la búsqueda paralela de los mejores
caminos sintácticos y acústicos para determinar el camino óptimo y también el
uso de la segmentación para reducir la longitud de las frases y así reducir
también el número posibles estados [53].
Tras este gran avance en los resultados de un sistema de reconocimiento de
habla, se comenzó a emplear un nuevo modelo que se había estado
desarrollando durante los últimos años y que sería de gran utilidad en este tipo
de tecnologías: el Modelo Oculto de Markov (HMM o Hidden Markov Model). Este
se trata de un modelo estadístico en el que se asume que el sistema a modelar
es un proceso de Markov con parámetros desconocidos. Partiendo de esta idea,
el objetivo consistía en descubrir cuales son estos parámetros desconocidos a
través de parámetros observables. Al aplicarlo en el contexto del reconocedor
del habla, en lugar de utilizar palabras y buscar patrones de sonidos
únicamente, el Modelo Oculto de Markov permitía calcular también la
probabilidad de sonidos desconocidos como palabras [54].
Tras la incorporación del Modelo Oculto de Markov en la década de 1980, los
sistemas comenzaron a mejorar significativamente. La década siguiente (1990)
fue un momento ideal para la expansión de este tipo de tecnologías y la
comercialización de estos sistemas, de tal modo que incluso en 1997 se lanzó
VAL, el primer portal de voz de BellSouth. VAL se trataba de un sistema
interactivo que podía responder preguntas realizadas por teléfono, y su
tecnología se sigue usando en la actualidad cuando se llama a bancos, u otras
empresas por teléfono [55].
En los años 2000, la precisión en el reconocimiento ya rondaba el 80% pero no
se produjeron muchos avances hasta la llegada de Google Voice Search, la
aplicación de Google para hacer búsquedas a través de voz. Con este sistema,
Google fue capaz de recoger alrededor de 230 billones de palabras de los
usuarios para mejorar la predicción [52]. Años más tarde (2011) apareció
también en el mercado Siri, un sistema similar a Google Voice Search. A partir
de este momento comenzaron a destacar los sistemas de grandes compañías
como Google, Apple, IBM, Microsoft o Amazon, que tal y como se mencionó en
el apartado Chatbots, desarrollaron módulos completos de reconocimiento de
voz como parte de sus propios asistentes virtuales para permitir la interacción
a través del habla.

2.2.1.3 Tecnologías actuales para el reconocimiento de voz

En la actualidad existen distintas herramientas para reconocer el habla y que

pueden ser integradas en aplicaciones o sistemas más complejos. A
continuación se recogen algunas de las herramientas más populares hoy día en
este ámbito.
2.2.1.3.1 Speech-to-Text de Google Cloud

Speech-to-Text es una API basada en las tecnologías de Inteligencia Artificial de

Google para transcribir voz tanto en tiempo real como a partir de ficheros ya
almacenados [56]. Entre sus características destaca su capacidad de

27
adaptación a dominios específicos y palabras poco frecuentes, o la posibilidad
de modificar los niveles de precisión en la transcripción. También cuenta con
modelos ya entrenados para recibir comandos de voz o transcribir vídeos y
llamadas, y permite reconocer voz en tiempo real. Respecto a la infraestructura,
se trata de una solución cloud a la que se accede a través de una API, pero
también ofrece una versión on-premise con Speech-to-Text On-Prem, que se
establece en la infraestructura del cliente otorgándole control total sobre la
infraestructura de la aplicación y sobre los datos de las conversaciones.
Algunas de las ventajas frente a otras tecnologías de este tipo es que aplica los
algoritmos de redes neuronales de aprendizaje profundo más avanzados de
Google, ofrece cobertura mundial ya que permite reconocer más de 125 idiomas
y variedades lingüísticas, y además se puede desplegar fácilmente, en función
de las necesidades del cliente, tanto en la nube como en local.
Actualmente, el precio por usar este sistema viene determinado por la cantidad
de audio procesado correctamente cada mes y se mide en incrementos rodeados
a los siguientes 15 segundos. Para modelos estándar con la opción
predeterminada, el precio de 60 minutos a 1 millón de minutos es de 0,006 USD
por cada 15 segundos, mientras que los modelos mejorados con opción estándar
para esta misma cantidad de audio sería de 0,009 USD cada 15 segundos.

2.2.1.3.2 Speech to Text de Cognitive Services de Microsoft

Uno de los servicios que ofrece Microsoft dentro de sus Cognitive Services es
Speech to Text, capaz de convertir el habla en texto de manera precisa [57]. Este
sistema ofrece transcripciones precisas con formato y puntuación a partir de
audio proveniente directamente de micrófonos, de archivos de audio o de
almacenamientos Blob. Permite personalizar y crear nuevos modelos de voz
adaptados a necesidades concretas con dominios y terminología específica, así
como a situaciones con ruido, acentos o vocabulario único. Y además resulta
fácil de implementar en infraestructuras cloud o locales.
En este caso, el sistema es compatible con más de 85 idiomas y variantes,
algunos menos que la solución de Google.
Respecto al precio, en su versión estándar existen distintas tarifas en función
de las características deseadas. Con características estándar se pagan alrededor
de 0,844€ por hora de audio, con características personalizadas 1,181€ por
hora de audio más 0,0454€ de hospedaje por modelo a la hora y, finalmente,
con características de audio multicanal de transcripción de conversaciones se
pagarían 1,78€ la hora.

2.2.1.3.3 Watson Speech to Text

Watson Speech to Text es el servicio de IBM que combina información sobre la

estructura del lenguaje con la composición de la señal de audio para ofrecer
una API con funcionalidades de transcripción de voz a aplicaciones [58]. Este
servicio puede transcribir automáticamente audio en 7 idiomas distintos en
tiempo real, y también a partir de archivos en distintos formatos de audio. Se
trata de un motor de voz muy preciso que permite personalizar los modelos para
ajustarlo a los casos de uso o necesidades de la aplicación, por ejemplo
incorporando términos o vocabulario de un dominio específico.

28
Los precios de Watson Speech to Text varían en función del centro de datos que
suministre este servicio. Las tarifas para Europa son de 0.02$ de 1 a 100
minutos consumidos y de 0.01$ por más de 100 minutos consumidos del
servicio.

2.2.1.3.4 Amazon Transcribe

Amazon Transcribe es el servicio de Amazon que permite a desarrolladores

incorporar funcionalidades de Voz-a-Texto a sus aplicaciones empleando un
proceso de aprendizaje profundo conocido como Reconocimiento de Voz
Automática (ASR o Automatic Speech Recognition) que permite convertir audios
a texto de manera rápida y precisa [59].
Este servicio agrega automáticamente diarización del hablante, signos de
puntuación y formato dando como resultado una transcripción de calidad
similar a las manuales. Además se puede aplicar sobre voz en tiempo real o
sobre ficheros de audio. Como en los ejemplos anteriores, Amazon Transcribe
permite añadir listas de vocabulario y modelos de idiomas personalizados para
generar transcripciones más precisas en dominios específicos. Como diferencias
remarcables este servicio permite filtrar palabras inapropiadas y enmascarar o
eliminar dichas palabras, y además es capaz de identificar automáticamente el
idioma predominante en el fichero de audio.
El uso de la API de Amazon Transcribe para streaming y transcripción de lotes
cuesta en la actualidad 0,0004 USD por segundo, y se factura por incrementos
de segundo con cargo mínimo de 15 segundos por solicitud. Como en otros
servicios, en este precio se incluyen características como el uso de vocabularios
personalizados, filtrado de vocabulario pero se aplican cargos adicionales por
otras características como la redacción automática de contenido y los modelos
de lenguaje personalizado.

2.2.1.3.5 Web Speech API SpeechRecognition

Una alternativa gratuita y popular a los sistemas anteriores es la Web Speech

API, en concreto su funcionalidad de Reconocimiento de Voz [60]. Esta API es
un recurso gratuito mantenido y documentado por MDN Web Docs,
anteriormente Mozilla Developer Network, y ofrece tanto la función de
reconocimiento como la de síntesis de voz para aplicaciones web. Su interfaz
SpeechRecognition tiene varios controladores de eventos que permiten
identificar el habla que se recibe como entrada desde el micrófono del dispositivo,
y una vez detectadas las palabras, la transcripción es automática.
Web Speech API se trata de una solución muy cómoda y sencilla para introducir
mecanismos de reconocimiento de voz en las aplicaciones web, no obstante,
presenta una gran limitación en cuanto a compatibilidad. Para la interfaz de
reconocimiento de voz, la API solo es compatible con el navegador Chrome para
escritorio y Android, por lo que este componente solo funcionará si se accede a
la aplicación web desde Chrome (no funcionará en Mozilla, Safari, Opera o
cualquier otro navegador). Además de esto, puesto que la API utiliza los idiomas
del propio navegador, dará soporte a los idiomas que incluya Chrome,
actualmente 32.

29
2.2.2 Síntesis de voz

2.2.2.1 ¿Qué es la síntesis de voz?

El campo de estudio de la síntesis de voz aborda el problema de la generación

de voz por ordenador para que estos sistemas puedan leer en voz alta como lo
haría un humano. Esta área incluye tanto la síntesis del habla (speech
synthesis en inglés) que se trata de la generación sintética o por ordenador del
habla, como el proceso conocido como texto-a-voz (text-to-speech o TTS en
inglés) para convertir el texto escrito en habla [61].
Los sistemas de síntesis de voz han avanzado considerablemente en los últimos
años, lo que ha hecho posible que las principales tecnologías en esta área no
produzcan voces excesivamente mecánicas o robóticas, sino voces más
naturales o similares a una voz humana.
La estructura típica y tradicional de un sistema de procesado texto-a-voz incluye
al menos tres bloques o etapas: la segmentación de texto, la conversión a
fonemas y la conversión de los fonemas a formas de onda. El primer paso a
veces recibe el nombre de tokenización o preprocesado y consiste en identificar
las distintas palabras del texto de entrada. El segundo paso tiene como objetivo
obtener los fonemas correspondientes de las palabras detectadas; para que esto
sea posible es necesario aplicar al menos dos componentes adicionales: las
reglas de transcripción fonética y los atributos de prosodia. Tras este paso se
cuenta ya con la información fonética necesaria para que el sintetizador pueda
procesar y pronunciar los fonemas recibidos. Finalmente, en el tercer paso, que
puede ser considerado en sí como la fase de síntesis, se convierte la información
simbólica lingüística en una representación en ondas de sonido [62].

Reglas de
transcripción
fonética

Texto Segmentación Conversión

ió letra Conversión de Habla
del texto a fonema fonemas a
formas de onda

Atributos de
prosodia

Figura 19. Sistema típico de texto a voz

No obstante, algunos de los sistemas más recientes han dejado de lado esta
estructura al emplear redes de neuronas que automatizan mucho más el
proceso de síntesis y son capaces de producir resultados mucho más naturales
o “humanos”. En los siguientes apartados se detallará más cómo funcionan
algunas de las mejores tecnologías de síntesis del habla en la actualidad.

30
2.2.2.2 Historia de la síntesis de voz

Se considera que uno de los primeros intentos por sintetizar el habla se remonta
a hace más de doscientos años, concretamente a 1779. Este año, el profesor
ruso Christian Kratzenstein explicó cuáles eran las diferencias fisiológicas entre
las vocales largas /a/, /e/, /i/, /o/ y /u/ y consiguió producirlas
artificialmente gracias a los resonadores acústicos que construyó imitando el
tracto vocal humano. Estos resonadores (ver Figura 20) eran como instrumentos
musicales con lengüetas vibrantes para producir el sonido deseado.

Figura 20. Resonadores de Kratzenstein

Tal y como se recoge en la tesis Review of Speech Synthesis Technology [64],

Kratzenstein no había sido el primero en estudiar la producción del habla ya
que Wolfgang von Kempelen había comenzado años antes su investigación. Sin
embargo, no fue hasta 1791 en Viena que Kempelen presentó su máquina de
habla acústico-mecánica, capaz de producir tanto sonidos individuales así como
combinaciones de sonido. Su máquina estaba compuesta por una cámara de
presión, una lengüeta vibrante como en los resonadores de Kratzenstein, y un
tubo de cuero que permitía producir diferentes sonidos vocales al manipularlo.
Años más tarde, a mediados de 1800, Charles Wheatstone hizo su propia
versión de la máquina de habla acústico-mecánica de Kempelen, esta vez capaz
de producir vocales, la mayoría de los sonidos consonantes, combinaciones de
sonidos e incluso palabras completas. Esta máquina llegó incluso a inspirar a
Alexander Graham Bell a fabricar este mismo tipo de máquina capaz de hablar.
Este tipo de experimentos, clasificados como sintetizadores mecánicos o semi-
eléctricos del habla se estuvieron realizando hasta 1960, pero no produjeron
éxitos notables en el área. No obstante, el desarrollo de otro tipo de sistemas,
los sintetizadores eléctricos, fue mucho más próspero.
El primer dispositivo considerado el primer sintetizador de habla eléctrico fue
VODER (Voice Operating Demonstrator), creado por Homer Dudley en 1939.
Este sistema estaba inspirado en VOCODER, el dispositivo de los Laboratorios
Bell que analizaba y descomponía el habla en parámetros acústicos que podían
ser recompuestos en una aproximación de la señal original por el sintetizador.
VODER demostró un gran potencial para producir habla artificial y promovió el
interés en la síntesis de voz, sin embargo requería de gran habilidad producir
una frase entendible en este dispositivo [65]. Más tarde, en 1951, Franklin
Cooper desarrolló en los Laboratorios Haskins otro sistema que era capaz de
reconvertir patrones de un espectrograma en sonidos, tanto en su forma original
como modificada [64].

31
El siguiente hito para la síntesis de voz fue en 1953, año en que Walter Lawrence
creó su sintetizador PAT (Parametric Artificial Talker), el primer sintetizador de
formantes. Casi al mismo tiempo, Gunnar Fant introdujo el primer sintetizador
de formantes en cascada, sistema conocido como OVE. Y unos años más tarde
John Holmes creó el sintetizador de formantes paralelo. En este tipo de sistemas
(sintetizadores de formantes) la novedad era que el sonido resultante se
generaba a partir de un modelo acústico físico, empleando distintos parámetros
como la frecuencia fundamental o la amplitud [66].
Tras la aparición de la síntesis de formantes, el siguiente tipo de síntesis en
aparecer fue la síntesis articulatoria. Uno de los primeros sistemas que hacía
uso de este tipo de técnicas fue DAVO (Dynamic Analog of the Vocal tract) creado
en 1958 en el Instituto de Tecnología de Massachusets (MIT). En los siguientes
años, este tipo de técnicas se fueron asentando y se comenzaron a comercializar
algunos de estos sistemas de texto-a-voz.
Llegada la década de 1970, un nuevo modelo se comenzó a aplicar en esta área
como ocurrió en el reconocimiento del habla: el Modelo Oculto de Markov. En
este modelo existía una serie de estados entre los cuales existe una transición
con dos probabilidades, la probabilidad de transición y la función de densidad
de probabilidad que representaba la probabilidad condicional de emitir un
símbolo de un determinado alfabeto una vez se asume la transición.
Aunque los resultados producidos por los sistemas eran cada vez mejores, el
gran cambio en el panorama vino de la mano de las redes de neuronas, que han
hecho que en la actualidad existan herramientas de síntesis del habla capaces
de simular de manera muy remarcable la voz humana.

2.2.2.3 Tecnologías para la síntesis de voz

Como en el caso de las tecnologías para el reconocimiento de voz, empresas

como Google, Microsoft, IBM o Amazon, lideran con sus herramientas la síntesis
del habla en la actualidad. A continuación se muestran algunas de estas
herramientas y también algunos de los algoritmos más importantes para la
creación de sistemas de síntesis de voz hoy en día.

2.2.2.3.1 Text-to-Speech de Google Cloud

Text-to-Speech es la API basada en las últimas tecnologías de Inteligencia

Artificial que ofrece Google para convertir el texto en voz [67]. Entre sus
características más destacables se encuentra la posibilidad de personalizar las
voces, el uso de voces de WaveNet (voces muy naturales), las opciones de ajustes
de tono, velocidad o volumen, la compatibilidad con textos y lenguaje SSML, su
facilidad de integración gracias al uso de API REST, la flexibilidad de formatos
de audio generados (MP3, LINEAR16 u Ogg Opus, entre otros), y la optimización
para distintos perfiles de audio.
Esta API ofrece voces de alta fidelidad, con una entonación muy parecida a la
humana, ya que ha sido desarrollada aplicando los conocimientos sobre síntesis
de voz de DeepMind, la prestigiosa empresa de Inteligencia Artificial inglesa.
Cuenta con una gran variedad de voces: más de 220 voces para más de 40
idiomas y sus distintas variaciones lingüísticas. Y además, permite crear voces
únicas que identifiquen al sistema en el que se utilice.

32
No obstante, como ocurría con los servicios de reconocimiento de voz Google, es
necesario pagar por su uso. En este caso, el precio de la API se establece en
función de la cantidad de caracteres que se envían al mes y en función de las
voces que se utilicen. Para las voces estándar (no WaveNet), que resultan menos
naturales para el oyente, el precio es de 4 USD por millón de caracteres,
mientras que para las voces WaveNet, mucho más naturales, el precio se eleva
a 16 USD por millón de caracteres.

2.2.2.3.2 Text to Speech de Microsoft Azure

Text to Speech de Microsoft es otra herramienta que permite sintetizar voces a

partir de texto [68]. Sus características son similares a las del sistema de Google
ya que también ofrece voces naturales con entonación similar a la de las voces
humanas, permite personalizar nuevas voces y también cuenta con controles
de audio para ajustar la velocidad, el tono, la pronunciación o las pausas.
Además, en este caso Microsoft también permite ejecutar Text to Speech tanto
en la nube como en contenedores.
Este sistema cuenta con 215 voces en más de 60 idiomas y variantes y también
permite crear voces personalizadas. Y ofrece una seguridad completa ya que
los datos de texto no se almacenan mientras se procesan o se convierten en
audio, y permite eliminar los datos de voz personalizaos en cualquier momento.
En este caso el precio por uso depende del tipo de instancia y de las
características del servicio. Por ejemplo, para instancias y voces estándar el
precio es de 3,374€ por millón de caracteres y para instancias estándar y voces
que emplean redes neuronales el precio es de 13,493€ por millón de caracteres.

2.2.2.3.3 Watson Text to Speech

Watson Text to Speech es la API que ofrece IBM para convertir el texto escrito
en voz tanto en aplicaciones propias como dentro de su sistema Watson
Assistant. Sus características son similares a los sistemas ya presentados. La
API ofrece distintas voces suaves y naturales creadas con de redes de neuronas,
también permite diseñar nuevas voces personalizadas a partir de grabaciones
de una hora de grabaciones, permite modificar atributos de la voz como el
volumen, el tono o la velocidad; cuenta con opciones de personalización de la
pronunciación, permite modificar la expresividad del habla, o incluso ofrece la
posibilidad de transformar la voz personalizando el ritmo, timbre o incluso la
respiración.
Esta API ofrece voces en 16 idiomas y sus respectivos dialectos, además de
contar con voces femeninas y masculinas para cada caso.
Respecto a su precio, se calcula en función del plan escogido. El plan Lite, que
incluye 10.000 caracteres máximos por mes, 35 voces y 16 idiomas es gratuito,
mientras que el plan Estándar, con caracteres ilimitados al mes, 35 voces y 16
idiomas tiene un precio de 0,02 USD por mil caracteres.

33
2.2.2.3.4 Amazon Polly

Amazon Polly es el servicio en la nube de Amazon para convertir el texto en

habla realista. De entre sus características, Amazon destaca de Polly la alta
calidad de las voces y la precisión de la pronunciación incluso en abreviaturas
o expansión de acrónimos. Polly ofrece una baja latencia, garantizando tiempos
de respuesta rápidos que favorecen su uso en sistemas de diálogo en tiempo
real. Además, cuenta con distintas voces masculinas y femeninas en distintas
variedades del inglés.
El precio de este sistema también está condicionado por el uso que se haga del
mismo, además de por el tipo de voz empleada. El coste un millón de caracteres
con voces estándar sería de 4 USD mientras que con voces producidas con redes
neuronales sería de 16 USD.

2.2.2.3.5 Web Speech API SpeechSynthesis

Web Speech API ofrece una alternativa web gratuita para sintetizar voces con
un resultado de calidad gracias a su interfaz SpeechSynthesis [60]. Esta API
incluye, además de la interfaz principal controladora de la síntesis de voz, otras
interfaces estrechamente relacionadas con SpeechSynthesis para escoger la voz
que se va a emplear o modificar el tono y la velocidad, por lo que es posible
modificar la voz sintetizada.
Las voces disponibles para la síntesis son las propias del navegador, de modo
que los resultados podrán variar en función del navegador desde el que se
acceda a la aplicación. En este caso, la API funciona con Firefox además de con
Chrome, en concreto funcionará con Firefox para escritorio y dispositivos
móviles a partir de OS 2.5+.

2.3 Aplicaciones web

2.3.1 ¿Qué son las aplicaciones web?

Una aplicación web o web app es un programa informático al cual se accede a

través de un navegador web como pueda ser Google Chrome, Mozilla Firefox,
Safari u Opera. Se tratan de programas de tipo cliente-servidor en los que el
cliente sería el equipo de la persona que accede a la web y el servidor sería la
máquina o máquinas que envían la información que el cliente va a visualizar
[71].
A menudo se emplea el término página o sitio web para referirse a este tipo de
software, sin embargo existen matices que diferencian a las aplicaciones web de
las páginas web convencionales [72]. Las páginas web tradicionales son páginas
accesibles a través de navegadores que muestran contenido útil como texto,
imágenes, vídeo y audio, sin embargo, este contenido no se actualiza de manera
dinámica. Además, este tipo de páginas suelen ser un canal unidireccional en
el que los usuarios no pueden interactuar con el componente interno de la web.
Las tecnologías básicas para este tipo de software son HTML, CSS y, a menudo,
JavaScript.
34
Las aplicaciones web por su parte, son mucho más personalizables y ofrecen
una mayor cantidad de funciones. En este caso el acceso también se realiza a
través de navegadores web, pero el contenido que se muestra en ellas es
dinámico, además ofrecen una experiencia mucho más interactiva. Estos
programas están generalmente conectados a una base de datos o a una API, de
modo que es posible acceder a información actualizada constantemente
almacenar nuevos datos, o incluso modificar datos existentes (dependiendo de
la aplicación). En general se tratan de programas más complejos que las páginas
web estáticas tradicionales, por lo que además de necesitar tecnologías como
HTML, CSS o JavaScrit, se suelen emplear frameworks o pilas de trabajo que
facilitan el desarrollo.
En ambos casos, un factor común que predomina en los últimos años es el
diseño de interfaces responsive. Este tipo de diseños se visualizan
correctamente en dispositivos de distintos tamaños o resoluciones, como
ordenadores, tabletas o smartphones, de este modo cuando se reduce el tamaño
de la página o aplicación web, los componentes que se muestran en pantalla se
redimensionan u ocultan automáticamente para ofrecer una visión clara de la
información [73].

Figura 21. Ejemplo de diseño responsive

Dadas las características de las aplicaciones web, a menudo se emplean como

una alternativa a aplicaciones nativas, es decir, aplicaciones desarrolladas para
un sistema operativo concreto. Las aplicaciones web ofrecen numerosas
ventajas en este sentido [74]:
x Uso de tecnologías conocidas y lenguajes más simples (HTML, CSS y
JavaScript) que los empleados por aplicaciones nativas.
x Desarrollo único, ya que no es necesario crear distintas aplicaciones en
distintos lenguajes para lanzar una misma aplicación para diferentes
dispositivos.
x Permiten imitar de manera precisa los comportamientos de las
aplicaciones nativas fácilmente.
x Posibilidad de elección del entorno de desarrollo por parte del
desarrollador ya que no se impone el uso de tecnologías específicas
ligadas al sistema operativo del dispositivo.
x Compatibilidad multi-plataforma ya que se puede acceder a la aplicación
a través de distintos dispositivos con navegador web,
independientemente del dispositivo o de su sistema operativo.
35
 x Facilidad de acceso, ya que al tratarse de aplicaciones multi-plataforma,
un usuario puede acceder al sistema desde cualquier dispositivo con
navegador web y generalmente conexión con Internet.
x Ventaja competitiva frente a aplicaciones con un ecosistema cerrado.
x Bajo coste para el usuario y la empresa, ya que no se requiere lanzar la
aplicación en una plataforma o tienda de aplicaciones.
x Actualización y mantenimiento rápido y barato, ya que se las
actualizaciones se realizan de forma centralizada. Una vez se hacen
cambios en el servidor todos los usuarios podrán acceder a la última
versión sin necesidad de realizar descargas en su dispositivo.
x Ahorro de espacio en el dispositivo ya que no es necesario realizar
descargas o instalaciones.
No obstante, las aplicaciones web también presentan limitaciones frente a las
aplicaciones nativas, como por ejemplo:
x Menor rendimiento, debido a la capa que introduce el navegador.
x Menor alcance de mercado al no encontrarse en tiendas de aplicaciones
como Play Store de Android o App Store de Apple.
x Limitaciones de HTML y CSS en distintos navegadores.
x Dependencia (por lo general) de una conexión inalámbrica.

2.3.2 Historia de la web

En 1989, el informático británico Tim Berners-Lee inventó lo que se conocería

como World Wide Web (WWW). Tras haberse graduado en la Universidad de
Oxford, Berners-Lee había comenzado a trabajar en el prestigioso Centro
Europeo para la Investigación Nuclear o Laboratorio Europeo de Física de
Partículas Elementales, también conocido como CERN. Muchos científicos de
todo el mundo empleaban los aceleradores de partículas de estos laboratorios
ubicados en Ginebra, Suiza, sin embargo, tenían notables dificultades para
compartir su información.
Ante esta problemática, Berners-Lee se dio cuenta de que podrían aprovechar
la tecnología del hipertexto para compartir información, de modo que hizo una
propuesta formal en el documento Information Management: A Proposal para
abordar el problema y una posible solución. Su propuesta fue rechazada
inicialmente, pero Tim continuó trabajando en este proyecto, de manera que en
1990 ya había descrito las tres tecnologías fundamentales de lo que sería la
web: el Lenguaje de Marcado de Hipertexto o HyperText Markup Language
(HTML), el Identificador Uniforme de Recursos o Uniform Resource Identifier
(URI) y el Protocolo de Transferencia de Hipertexto o Hypertext Transfer Protocol
(HHTP). Con esto avances, a finales de 1990 se lanzó la primera página web en
internet y en 1991 la gente ajena al CERN fue invitada a esta comunidad web.
La comunidad iba creciendo y Tim junto a otros colaboradores abogaron por
garantizar que el CERN aceptara hacer disponible para siempre el código
subyacente, decisión que se hizo pública finalmente en 1993.
Tras esto, en 1994, Tim Berners-Lee fundó el Consorcio de la World Wide Web
(W3C) en el Instituto de Tecnología de Massachussets. Esta comunidad
internacional se dedicaba, y aún se dedica hoy en día, a desarrollar estándares
web abiertos, además fue la encargada de promover algunos de los principios

36
que rigen hoy la web: la descentralización, la no discriminación, el diseño de
abajo hacia arriba (bottom-up), la universalidad y el consenso [75].
Tras establecer estas primeras bases para la web, la aparición de nuevas
tecnologías ha sido constante (ver Figura 22). En marzo de 1993 se había
lanzado el primer navegador web, MOSAIC, y su ejemplo fue rápidamente
seguido por NetScape en 1994 y Opera e Internet Explorer en 1995. A estos
navegadores más antiguos, se les sumarian además Safari en 2003, Firefox en
2005 y Chrome en 2008. Las versiones de HTML y CSS también fueron
avanzando con el paso de los años hasta alcanzar actualmente la quinta versión
de HTML y la tercera de CSS. Y además, numerosos lenguajes y formatos (entre
otros) fueron incrementando la variedad y riqueza de la web a niveles como el
de las comunicaciones, la seguridad o de aparición de nuevas funcionalidades
[76].

Figura 22. Línea temporal de La Evolución de la Web [76]

Para poder reflejar esta enorme evolución producida en la web en las últimas
décadas, a menudo se utilizan términos como Web 1.0, Web 2.0, Web 3.0 o Web
4.0. Esta forma de denominar a la web sirve para representar los cambios que
ha sufrido la misma especialmente en cuestión de uso y asentamiento de
tecnologías [77].
La Web 1.0 data de la década de 1990, y hace referencia a una web muy básica
en la que solo existían navegadores de texto y los usuarios solo podían consumir
de forma pasiva la información alojada en los servidores. Era una web estática,
centralizada, secuencial, de solo lectura y no interactiva.
La llegada de la Web 2.0 se produjo cuando la interacción comenzó a formar
parte de la web, alrededor del año 2000. En concreto, el término fue acuñado
por O’Reilly en 2004 con el objetivo de referirse a una nueva generación de
tecnología web, esta vez basada en comunidades de usuarios con servicios como
blogs, wikis, chats o foros que fomentaban la colaboración e intercambio de
información entre las personas. Con esta generación, la web era dinámica, de
lectura y escritura, y sobre todo interactiva.
El siguiente cambio de generación se produjo en 2010 con la llegada de la Web
3.0 o web semántica. Esta web hacía un uso mucho más eficiente de los datos,
de hecho, incluye metadatos semánticos u ontológicos que dan valor a la
información y mejoran la capacidad de búsqueda. Esto supone un gran cambio
que rompe con las posibles barreras de formato y estructura para que todos los
usuarios de la web puedan acceder a la información que desean.

37
Tras esto, en 2016 se considera que se llega a generación más reciente de la
web: la Web 4.0. La novedad de esta web es que se centra en su comportamiento
inteligente y predictivo, de manera que se puedan anticipar a las solicitudes de
los usuarios o incluso predecir sus comportamientos futuros. Además, se
comienza también a hacer un uso generalizado de las interacciones por voz con
dispositivos inteligentes. En definitiva, se alcanza una web dominada por las
tecnologías de Inteligencia Artificial que permiten adelantarse a las necesidades
del usuario y darle lo que necesita en cada momento.

2.3.3 Tecnologías actuales para el diseño y desarrollo de

aplicaciones web

Aunque en los últimos años han aparecido numerosos frameworks o librerías

para el desarrollo front-end o desarrollo web, en la actualidad no son muchos
los que se han impuesto en el mundo del desarrollo. De acuerdo con el informe
de 2020 The State of JavaScript, frameworks como Prereact, Svelte, Ember,
LitElement, Alpine.js o Stimulus han ido aparecido en los últimos cinco años,
sin embargo menos de un 20% de los programadores web han usado estas
tecnologías.
Las tecnologías que predominan en uso son React, empleado por un 80% de
programadores front-end, seguido de Angular con un 56% y Vue.js con un 49%.

Figura 23. Ranking de tecnologías Front-end por uso

Ya que estas tres tecnologías destacan claramente sobre el resto, este apartado
se centrará en ellas.

2.3.3.1 React

React es una biblioteca de JavaScript de código abierto para el desarrollo de

interfaces de usuario creada por Jordan Walke, un ingeniero de Facebook, y
lanzada en mayo de 2013.

38
Esta biblioteca surgió con la intención de lidiar con proyectos a gran escala y
basados fundamentalmente en el uso de datos (data-driven), por lo que pretende
ser sencilla al uso y declarativa. React permite diseñar vistas simples para cada
estado de la aplicación y se encarga de actualizar y renderizar de forma eficiente
los componentes necesarios. Además, al contar con vistas declarativas, el código
es más predecible para el programador y hace que sea más fácil de depurar.
Es una biblioteca basada en componentes que pueden manejar su propio estado,
por lo que se puede organizar el código cómodamente y reutilizar en otras partes
de la aplicación. Estos componentes estás escritos en JavaScript y no en
plantillas, de modo que se puede mantener el estado fuera del DOM (Document
Object Model) virtual que ofrece React, y de esta forma se puede mantener un
rendimiento más uniforme sin interrupciones.
Además de esto, React puede renderizar desde el servidor empleando Node, y
puede potenciar aplicaciones móviles con React Native, algo que resulta de gran
utilidad si se desea sustituir o evitar el uso de aplicaciones nativas manteniendo
un buen rendimiento.
La biblioteca está mantenida por Facebook. Se encuentra en constante
desarrollo e incorpora novedades regularmente, algo positivo ya que cuenta con
herramientas avanzadas y útiles para adaptarse a las necesidades de los
desarrolladores, sin embargo, los constantes cambios hacen que la curva de
aprendizaje de esta tecnología sea mayor para gente poco familiarizada con el
framework [79].

2.3.3.2 Angular

Angular es otro de los frameworks de código abierto más importantes para

desarrollo de aplicaciones web. Este marco fue creado por Google (quien hoy en
día se encarga de su mantenimiento) y su lanzamiento tuvo lugar en 2016.
Este marco surge con el objetivo de aumentar el número de aplicaciones para
navegadores con Modelo Vista Controlador (MVC), de tal modo que se
simplifique tanto el desarrollo como las pruebas de las aplicaciones. Para ello,
ofrece numerosas ventajas o características a nivel de velocidad, rendimiento y
productividad.
Por un lado, permite crear aplicaciones multiplataforma con alto rendimiento,
sin necesidad de conexión a internet y sin instalación. También permite crear
aplicaciones nativas con tecnologías como Cordova o Ionic. Además, permite
crear aplicaciones de escritorio instaladas para Mac, Windows o Linux con la
misma sintaxis que se emplearía para crear una aplicación web convencional.
Por otro lado, Angular hace posible generar código rápidamente y con resultados
de rendimiento muy buenos. Este marco permite crear vistas con sintaxis de
plantilla de manera muy rápida y simple y, una vez creadas, Angular se encarga
de optimizar el código para máquinas virtuales de JavaScript. También, permite
separar el código en distintos componentes que carga el Component Router
cuando es necesario, de este modo no se tienen que cargar componentes
innecesarios en la vista que se va a renderizar. Y una vez desarrollada una
aplicación, se genera código HTML y CSS que se puede servir fácilmente desde
servidores como Node.js o PHP.
Y por último, este framework permite una alta productividad. Se trata de un
marco al que dan soporte muchos IDEs, como Visual Studio, por lo que se puede

39
acceder a ayudas como autocompletado de código, detección de errores o
retroalimentación sobre el código. Además también cuenta con un CLI
(Command Line Interface) propio que permite crear componentes rápidamente,
compilar el código o desplegar la aplicación.
Además de estas características, Angular destaca entre otros frameworks en su
sincronización en tiempo real entre modelo y vista, lo que hace posible que
cualquier cambio producido en el modelo se refleje instantáneamente en la vista
[80].

2.3.3.3 Vue.js

Vue.js es el tercero de los frameworks de código abierto más usados actualmente

para la creación de aplicaciones web, y fue creado en 2014 por Evan You con la
intención de desarrollar un marco con las características que más le habían
gustado al utilizar Angular, pero más ligero y fácil de usar.
El objetivo de este framework es reducir las complejidades que normalmente se
asocian al desarrollo web, es decir el tiempo, el esfuerzo y la inversión. Como
los ejemplos anteriores, esta herramienta también se basa en una
representación declarativa y el uso de componentes, sin embargo Vue.js
únicamente se centra en vista del MVC para abordar la problemática de manera
sencilla.
Las características principales de este marco son su accesibilidad, versatilidad
y eficiencia. Por un lado, se trata de una herramienta accesible ya que hace uso
de lenguajes ampliamente conocidos como HTML, CSS y JavaScript, empleados
desde los inicios del desarrollo web. Además da soporte también a lenguajes
más nuevos como TypeScript, permite escalar a través del uso de APIs y ofrece
herramientas como Vue DevTools o su Vue CLI (con interfez gráfica) para
facilitar su uso a los desarrolladores. Por otro lado, es también versátil ya que
permite crear aplicaciones desde cero utilizando herramientas modernas como
Webpack, o mejorar aplicaciones antiguas empleando Vue como librería de
mejora progresiva. Es también eficiente, ya que en ejecución solo es necesario
cargar o renderizar los componentes que se van actualizando gracias a su
capacidad reactiva. Esta capacidad, permite que los cambios que se producen
en los componentes se reflejan rápidamente debido a que Vue transforma los
cambios de estado en actualizaciones del DOM.
Además de todo esto, una de las ventajas principales de Vue es que se trata de
una biblioteca de unos 20 kilobytes, es decir, un tamaño mínimo y mucho
menor que el del resto de frameworks. Y, en caso de ser necesario, se pueden
emplear bloques específicos sin necesidad de utilizar la biblioteca entera [81].

40
3 Desarrollo
Como se comenta en el apartado de Introducción, el objetivo global del proyecto
es desarrollar un chatbot para el público infantil que esté integrado en una
aplicación web con la que se pueda interactuar a través del lenguaje natural
hablado, y que permita de esta manera participar a niños que no
necesariamente sepan leer ni escribir en un proyecto de ciencia ciudadana para
la clasificación de meteoros a través de sus sonidos. En este capítulo se abordan
los pasos y tareas realizadas para cumplir con este objetivo, incluyendo así
información relativa a la elección de tecnologías, elección de arquitectura,
diseño e implementación del chatbot y la aplicación web, así como la integración
de los módulos de reconocimiento y síntesis de voz.

3.1 Elección de Tecnologías

Para poder comenzar con el diseño y desarrollo de los diferentes componentes

que conforman el proyecto es necesario escoger qué tecnologías se emplearán
en cada uno de estos componentes. Para ello, en este subcapítulo se analizan y
comparan distintas tecnologías para la creación de chatbots, reconocimiento y
síntesis de voz, así como desarrollo web. En cada apartado se hablará de cuáles
son las necesidades específicas del proyecto y en qué medida se ajustan a ellas
las tecnologías presentadas.
Algunas de las preferencias que se plantearán de forma común en las tres
secciones será:
x Hacer uso de herramientas de código abierto
x Emplear tecnologías gratuitas si es posible
x Reducir la dependencia con sistemas o infraestructuras de terceros
(cuentas, usuarios, entornos de desarrollo cerrados, etc.)
A continuación se analizan las potenciales opciones de tecnología para cada
bloque y se razona la elección de las tecnologías que finalmente se emplearán
en el desarrollo del proyecto.

3.1.1 Tecnología para Chatbot

En este apartado se pretende elegir razonadamente la tecnología que se

empleará para el diseño y creación del chatbot que procesará la conversación
con el usuario en el experimento de clasificación de meteoros.
Para poder tomar una decisión acertada, se tendrán en cuenta algunos factores
relacionados con el proyecto:
x La tecnología escogida deberá ser fácil de usar ya que el sistema se
deberá mantener durante la vida del experimento, lo que implica que
personas no familiarizadas con este ámbito deberían poder aprender a
utilizar el entorno rápidamente.
x El código debe estar accesible al resto de colaboradores del proyecto.
x El sistema debe dar servicio a múltiples usuarios concurrentes.
x Deberá existir documentación sobre la tecnología de modo que se pueda
tener asistencia o soporte en caso de necesidad.
41
Como ya se vio en el apartado de Tecnologías actuales para el desarrollo de
chatbots, existen distintos tipos de herramientas que permiten hoy día crear
chatbots capaces de mantener una conversación inteligente, entre ellos se
pueden destacar frameworks, las plataformas o las bibliotecas. Para comenzar
a acotar las posibilidades, en primer lugar, se compararán los tipos de
tecnología planteados y así se determinará qué estrategia puede resultar más
adecuada para el proyecto.
Tras haber estudiado las características principales de las herramientas que
constituyen el estado del arte en esta área, una de las principales ventajas
detectadas sobre el uso de frameworks o plataformas frente a bibliotecas es que
en general están pensados para gente que no necesariamente sabe programar.
En este sentido, algunos de los frameworks presentados, como Microsoft Bot
Framework, Dialogflow, Watson, Wit.ai o Botpress, ofrecen una interfaz gráfica
desde la que se pueden diseñar los chatbots incluyendo los ejemplos de frases
de entrada o de respuesta en campos específicos. O por ejemplo, en el caso de
Rasa, aunque no se ofrece esta interfaz, se manejan ficheros con formatos como
YML o Markdown, en los que se introducen los datos de manera muy intuitiva
sin necesidad de aprender palabras reservadas o tecnicismos más propios de la
programación. En el caso de las bibliotecas, sin embargo, es necesario conocer
el lenguaje de programación de la propia biblioteca y familiarizarse con sus
clases y métodos, es decir, es necesario tener nociones básicas de programación
y del lenguaje de programación.
Otra de las ventajas de los frameworks o plataformas es que incluyen en general
todas las funcionalidades necesarias para crear desde cero un chatbot, para
probarlo o incluso para integrarlo. En el caso de las bibliotecas es probable que
haya que programar distintas funciones por cuenta propia para poder ejecutar
el chatbot o integrarlo.
La integración es una de las grandes ventajas de estos sistemas frente a las
bibliotecas. En general, estos marcos ofrecen soporte multicanal con
plataformas de mensajería como Slack, Facebook Messenger, Telegram, Skype,
etc. y en ocasiones incluso ofrecen una API para conectar los chatbots con la
aplicación que se desee. Sin embargo, en el caso de las bibliotecas es necesario
implementar estos canales o endpoints para poder utilizar el chatbot con otras
aplicaciones.
A pesar de estas ventajas, la existencia de un marco de trabajo definido puede
limitar las posibilidades de diseño, sobre todo si el marco no dispone de un SDK
que permita modificar el código del chatbot, o que permita realizar llamadas a
APIs u otros servicios externos. En este sentido, las librerías no restringen
apenas el diseño de la arquitectura y estructura del proyecto ni tampoco limitan
las funcionalidades.
Otra limitación de los frameworks se trata de su coste, en la mayoría de los
casos. Herramientas como Microsoft Bot Framework, Amazon Lex, Dialogflow o
IBM Watson son de pago, lo que significa que mensualmente se pagará un
precio que dependerá de las funcionalidades que estemos usando, del número
de interacciones con el chatbot o ambas. A pesar de ello no es una limitación
que se de en todos los frameworks, ya que por ejemplo Rasa, Wit.ai o Botpress
son totalmente gratuitos, como lo son las bibliotecas.

42
 Frameworks Bibliotecas
No es necesario saber programar Es necesario saber programar
Incluye todas las funcionalidades No incluye todas las funcionalidades
para desarrollar por completo un para desarrollar por completo un
chatbot chatbot
Fácil integración con diversos No incluyen mecanismos de
canales integración
Limitan el diseño de la arquitectura No limitan el diseño de la
y estructura del proyecto arquitectura y estructura del
proyecto
Generalmente de pago (aunque no Generalmente gratuitas
todos)
Tabla 2. Comparativa entre frameworks y bibliotecas de creación de chatbot

Dadas las numerosas ventajas que ofrecen los frameworks frente a las
bibliotecas, se descarta el uso independiente de bibliotecas para el proyecto, por
lo que a continuación se realiza una comparativa entre los principales marcos
de trabajo para la creación de chatbots.
Los frameworks que forman parte del estado del arte en la creación de chatbots
son, como se mencionó en apartados anteriores: Microsoft Bot Framework,
Amazon Lex, Google Dialogflow, IBM Watson Assistant, Rasa, Wit.ai y Botpress.
Las soluciones de Microsoft, Amazon, Google y Amazon son de pago, por lo que
se evitará su uso en el proyecto, dando prioridad a los marcos de código abierto
Rasa, Wit.ai y Botpress.
Otro de los factores eliminatorios en esta elección es la necesidad de cuentas en
sistemas de terceros, como es el caso de Wit.ai de Facebook. En este caso Wit.ai
requiere disponer de una cuenta de Facebook y aceptar los términos y
condiciones de uso de esta misma compañía, algo que crea una gran
dependencia con terceros e incluso podría llegar a limitar el uso de la aplicación.
Por este motivo, se descarta el uso de Wit.ai en el proyecto.
Por lo que respecta a Rasa y Botpress, sus características son muy similares ya
que no requieren cuenta, son gratuitos, permiten desarrollo en código y se
pueden integrar en el mismo número de canales. No obstante, existen algunas
diferencias como el lenguaje de programación, la interfaz gráfica, o la existencia
de documentación y foros de consulta.
Rasa emplea Python, un lenguaje de programación muy sencillo de usar y
aprender además de muy típico en la programación de agentes inteligentes,
mientras que Botpress hace uso de JavaScript, un lenguaje también muy
popular pero más complejo y con una línea de aprendizaje mayor.
En su versión de código abierto, Rasa no dispone de interfaz gráfica mientras
que Botpress sí. Esto puede ser visto como algo positivo o negativo, ya que una
interfaz puede ayudar a usuarios inexpertos a diseñar su agente, sin embargo,
también puede limitar el diseño. En este sentido, aunque Rasa no ofrece una
interfaz gráfica, permite crear un chatbot base desde su sitio web y descargar
el proyecto con la estructura del proyecto ya creada con todos los ficheros
necesarios. Esto resulta de gran utilidad ya que no es necesario mezclar código

43
e interfaz gráfica, sino que desde el principio permite al usuario familiarizarse
con los ficheros y compartir el proyecto en un repositorio fácilmente.
Y por último, Rasa cuenta con abundante documentación en su sitio web así
como foros de consultas propios oficiales o externos. Esto resulta de gran ayuda
ya que se puede encontrar soporte en distintos lugares ante cualquier fallo,
duda, o problema. En el caso de Botpress no se encuentra tanto material de
consulta a pesar de que también dispone de una extensa documentación en su
página oficial.

Tecnología Lenguaje Gratis Cuenta Canales

Microsoft Node.js, C# No Si Slack, Skype, Facebook
Bot Messenger, Microsoft
Framework Teams, Web
Amazon Lex Android, No Si Facebook Messenger, Kik,
JavaScript, Slack, Twilio SMS,
iOS, Aplicaciones móvil
Java, .NET,
Node.js, PHP,
Ruby, Python
Google Node.js No Si Skype, Slack, Facebook
Dialogflow Messenger, Alexa, Google
Assistant, Web, Telegram,
Twilio, Viber
IBM Watson Java, C++ Sí Si Facebook Messenger,
Assistant Slack, WordPress
Rasa Python Sí No Facebook Messenger,
Telegram, Canales
personalizados (API)
Wit.ai Python, Ruby Sí Si Slack, Facebook
Messenger, Dispositivos
inteligentes, Aplicaciones,
Web
Botpress JavaScript Sí No Telegram, Facebook
Messenger, Web, Canales
personalizados (API)

Tabla 3. Resumen de características de los frameworks para la creación de

chatbots

Tras este análisis, se decide optar por Rasa Open Source como tecnología para
desarrollar el chatbot de la aplicación, ya que se trata de la solución de código
abierto líder en el área, es gratuita, incluye todas las herramientas necesarias
para crear un chatbot desde cero, es posible compartir el código del proyecto
entero de manera fácil y rápida, emplea una estructura de ficheros intuitiva y
hace uso del lenguaje Python para desarrollar la lógica de las funciones
personalizadas, no está ligada a sistemas de terceros, dispone de una amplia

44
documentación, y además permite integrar los agentes en todo tipo de canales
gracias a su API, lo que además facilita el manejo de múltiples usuarios.

3.1.2 Tecnología para Reconocimiento y Síntesis de Voz

A continuación se plantea el análisis de las distintas tecnologías para el

reconocimiento y síntesis de voz. En este caso los únicos requisitos, además de
los ya mencionados como comunes para todas las tecnologías del proyecto, son:
x Se deberán de reconocer frases comunes en un diálogo en español
x La síntesis de voz deberá ser en español y lo más realista posible, de
manera que sea fácil de entender al chatbot cuando hable.
Como vimos en los respectivos apartados de tecnologías para el reconocimiento
y síntesis de voz, las opciones más populares eran las de empresas como
Microsoft, Google, IBM o Amazon, sin embargo, estas opciones son de pago.
Como alternativa a estas tecnologías de pago, se presentó la Web Speech API,
que ofrece tanto una interfaz para el reconocimiento como una interfaz para la
síntesis, y permite reconocer el habla en español así como sintetizarla a través
de aplicaciones web. Esta opción no dispone de tantas opciones de
personalización como las herramientas de pago, no obstante su integración en
aplicaciones resulta muy sencilla y los resultados de reconocimiento y síntesis
son aceptables.
Ya que esta API tiene una compatibilidad limitada, al funcionar solo en
navegadores Chrome, la aplicación no podrá utilizarse desde todos los
navegadores. Esta elección condicionará por tanto la disponibilidad del sistema.

3.1.3 Tecnología para Desarrollo Web

Por último se aborda elección de tecnología para el desarrollo de la aplicación

web donde se tendrá que integrar el chatbot así como la API de reconocimiento
y síntesis de voz.
Como se planteó en el estado del arte de las tecnologías de desarrollo web, las
herramientas a valorar serán React, Angular y Vue.js. Además, se tendrán en
cuenta distintas preferencias para la elección:
x Se deberá escoger una tecnología que permita un sencillo mantenimiento
x Se priorizan tecnologías que se hayan usado anteriormente (en este caso
Angular 8)
x Se prefieren tecnologías con amplia documentación de apoyo para el
desarrollo, mantenimiento o despliegue
De acuerdo con la comparativa de 2021 de frameworks para desarrollo web de
Simform [82], se pueden detectar distintas ventajas y desventajas de cada uno
de los entornos escogidos.
React tiene como principales ventajas el uso de componentes reutilizables, el
rendimiento uniforme gracias a su DOM virtual, y el uso de herramientas muy
avanzadas. Sin embargo, presenta algunas desventajas como la gran cantidad
de actualizaciones del marco, que complican su mantenimiento y la
actualización de documentación, el uso de JSX, una extensión de la sintaxis de
JavaScript, o el hecho de que solo brinda soluciones de frontend. El uso de esta

45
biblioteca se recomienda cuando se pretende desarrollar aplicaciones de una
sola página, o interfaces en muy poco tiempo, y se desaconseja cuando no se
tiene experiencia en el uso de JavaScript o JSX.
Por su parte, Angular ofrece ventajas como el uso también de componentes que
establece como elementos externos sin dependencias y se pueden reutilizar en
toda la aplicación, tiene capacidad de actualizar en tiempo real los cambios
realizados en el modelo en la vista y viceversa (enlace bidireccional), reduce la
cantidad de código gracias a uso de plantillas y cuenta con una gran comunidad
de aprendizaje y apoyo. Sus desventajas se centran sobre todo en su gran
tamaño que en ocasiones puede dificultar el funcionamiento de aplicaciones
dinámicas. Este framework se recomienda especialmente en proyectos que
tienen que actualizar dinámicamente el contenido pero no se recomienda en
proyectos pequeños o simples si se desconoce el marco de trabajo debido a su
complejidad.
Por último, Vue.js tiene como ventajas su extensa documentación, su
simplicidad de sintaxis, la flexibilidad para diseñar la estructura de la aplicación
y también el enlace bidireccional Modelo-Vista. No obstante tiene numerosas
desventajas ya que sus componentes no son tan estables como los de los marcos
anteriores, tiene una comunidad más pequeña, requiere el uso de otras
tecnologías o complementos para un desarrollo más completo e impone una
gran barrera de idioma con sus complementos ya que muchos están escritos en
chino. Esta biblioteca se recomienda cuando se tiene una estructura de
proyecto muy flexible, pero no se recomienda si se espera encontrar una gran
comunidad o componentes estables.

Ventajas Inconvenientes
React Uso de componentes Difícil mantenimiento
Rendimiento uniforme Uso de JSX (extensión de JS)
Herramientas avanzadas Solo front-end
Angular Uso de componentes Gran tamaño del framework
Enlace bidireccional Modelo-
Vista
Reducción de código
Amplia documentación y
comunidad
Vue.js Uso de componentes Comunidad reducida
Enlace bidireccional Modelo- Componentes poco estables
Vista
Complementos en otros idiomas
Sintaxis simple
Amplia documentación

Tabla 4. Comparativa entre las principales tecnologías de desarrollo frontend

Dado este análisis se prefiere el uso de Angular, ya que parece la tecnología

más robusta y asentada en esta área, con menos inconvenientes, y se trata de
46
un marco ya conocido. En este caso Angular podría resultar de utilidad ya que
se requiere actualizar rápidamente la interfaz puesto que se pretende incorporar
elementos de gamificación diversos, además permitiría organizar el proyecto de
tal manera que se pueda mantener fácilmente durante la vida del experimento.
Adicionalmente, su extensa documentación y comunidad además podría
suponer un soporte importante a la hora de desarrollar, mantener y desplegar
el proyecto, por lo que podría suponer un beneficio a largo plazo.

3.2 Arquitectura

Este trabajo forma parte de una infraestructura compleja formada por diversos
proyectos y distribuida en varias máquinas tal y como se muestra en la figura
a continuación (ver Figura 24).

Figura 24. Arquitectura general del proyecto Sonidos del Cielo

Como se puede ver en la Figura 24, en el ordenador de la estación de

Fuenlabrada se encuentra instalado el programa Echoes Watcher, un programa
que genera ficheros de detecciones de acuerdo con la configuración establecida
en Echoes, que determinará los parámetros para considerar que se ha
producido una nueva detección.
Estos datos de detecciones se envían en un formato .dat simplificado a la
máquina localizada en el Centro de Supercomputación y Visualización de
Madrid, más conocida como Cesvima, donde se encuentra el bróker MQTT. De
este bróker recupera los datos el Stream Generator del Instituto de Astrofísica
de Canarias (IAC) que crea una lista de reproducción a partir de los sonidos
generados con los datos de las detecciones.
Los datos en bruto (no simplificados) de las detecciones también se envían desde
la estación de Fuenlabrada al servidor situado en la Escuela Técnica Superior
de Ingeniería y Diseño Industrial. En esta máquina se guarda una copia de los
datos en bruto que a su vez se envían a la máquina de Venus, además se ejecuta
el programa para generar sonidos mejorados de meteoros a partir de los datos
recibidos desde Fuenlabrada, y la API que proporcionará los sonidos, gráficos y
en definitiva toda la información y datos necesarios para el experimento de

47
Sonidos del Cielo. En esta máquina además se alojará tanto el chatbot como la
web de este Trabajo Fin de Grado (indicados en azul en la Figura 24).
Este trabajo en concreto necesitará por tanto añadir dos bloques nuevos a la
arquitectura general: el correspondiente a la aplicación web y el correspondiente
al chatbot desarrollado con Rasa.

Figura 25. Arquitectura de la aplicación para niños

Por un lado, se deberá crear una aplicación web con Angular 8, que será a la
que accedan los usuarios a través de sus navegadores. Esta aplicación
contendrá varios servicios que harán uso de la Web Speech API para procesar
las detecciones de habla y transformarlas en texto (SpeechRecognition), y
sintetizar las respuestas que genere el chatbot (SpeechSynthesis). La aplicación
tendrá también que estar conectada al bloque del chatbot Rasa, al que se
accederá a través de su API con llamadas POST. Respecto al despliegue, este
primer bloque (aplicación web) se desplegará en un contenedor Docker con un
servidor Node.js.
Por otro lado, el bloque de chatbot Rasa estará formado por dos componentes,
el servidor general de Rasa que contiene el modelo del chatbot y el servidor de
acciones, que contendrá las acciones personalidadas creadas gracias al SDK en
Python. Las llamadas POST llegarán al servidor principal que se encargará de
identificar las intenciones (intents) de los mensajes gracias al procesado de NLU,
y, a partir de este momento, determinará que acción se debe ejecutar gracias al
Core de Rasa. Si se identifica una acción personalizada, este primer bloque
accederá al servidor de acciones de Rasa para ejecutar el código necesario. Si
esa acción implica la obtención de un nuevo sonido o el almacenamiento de una
nueva clasificación, este servidor de acciones hará una llamada a la API
Meteoros para obtener el sonido o guardar la clasificiación en la base de datos
del proyecto. Una vez hecho esto, el servidor de acciones responderá a la
petición y el Core devuelvolverá la respuesta a la aplicación que ha realizado la
llamada. Si no se hizo uso de acciones personalizadas, el Core será el encargado
de ejecutar directamente las acciones por defecto programadas en ese modelo.
Este bloque se desplegará como dos contenedores Docker diferentes, uno para
el servidor de Rasa (API) y otro para el servidor de acciones (SDK).

48
3.3 Chatbot

3.3.1 Creación del Entorno y Proyecto en Rasa

Antes de comenzar con el diseño del chatbot, se creará el entorno virtual para
instalar todas las dependencias de Rasa y también el proyecto de Rasa que
servirá de base para implementar el chatbot tal y como se indica en los
siguientes apartados. Para crear tanto el entorno como el proyecto base se
seguirán las instrucciones que se recogen en la propia web oficial de Rasa en la
sección de Instalación.
En este caso en particular se ha decidido desarrollar el chatbot en una máquina
virtual con sistema operativo Ubuntu 20.04.1 LTS, que trae por defecto
instalada la versión 3.8 de Python. Esta versión de Python puede ocasionar
diversos problemas a la hora de instalar todas las dependencias de Rasa,
especialmente las de librerías como Tensorflow, por lo que se instalará una
versión alternativa de Python en la máquina con una versión 3.7.0. Los pasos
que seguir para realizar la instalación son los que se recogen a continuación.
x Actualizar la lista de paquetes e instalar los paquetes necesarios para
instalar Python a partir de su código fuente:

sudo apt update

sudo apt install build-essential zlib1g-dev libncurses5-dev
libgdbm-dev libnss3-dev libssl-dev libsqlite3-dev libreadline-dev
libffi-dev wget libbz2-dev

x Descargar el código fuente de Python 3.7.0:

wget https://www.python.org/ftp/python/3.7.0/Python-3.7.0.tgz

x Extraer el código del archivo comprimido:

tar -xf Python-3.7.0.tgz

x Comprobar que todas las dependencias necesarias están instaladas:

cd Python-3.7.0
./configure --enable-optimizations

x Instalar como versión alternativa Python 3.7.0 (no sobrescribe otras

versiones ya instaladas de Python):

sudo make altinstall

Una vez se dispone de una versión compatible con las dependencias de Rasa, el
siguiente paso es crear el entorno virtual donde se instalará Rasa. Para ello se
hará uso del comando venv especificando la versión de Python que utilizará el
entorno, y una vez creado se activará para poder instalar en este entorno todo
lo necesario para emplear Rasa.

49
 x Crear el entorno virtual (en este caso el nombre del entorno será venvrasa,
pero se podría emplear cualquier otro nombre):

python3.7 -m venv ./venvrasa

x Activar el entorno virtual:

source venvrasa/bin/activate

Una vez creado y activado el entorno, se instala Rasa y todas sus dependencias,
para ello se siguen los pasos siguientes.
x Actualizar la versión de pip:

pip3 install -U pip

x Instalar Rasa Open Source:

pip3 install rasa

x Instalar todas las dependencias de Rasa:

pip3 install rasa[full]

x Instalar las dependencias de spaCy para utilizar modelos pre entrenados

en el entrenamiento:
pip install rasa[spacy]
python -m spacy download es_core_news_md
python -m spacy link es_core_news_md es

Una vez instalado todo lo necesario para utilizar Rasa, se accede a la sección
Rasa Playground en la web oficial de Rasa, donde se puede crear un prototipo
sencillo de chatbot y descargar el proyecto.
En Rasa Playground se encuentra una interfaz muy intuitiva con cinco pasos a
seguir. Cada paso viene con una explicación del fichero que se va a modificar y
un editor de texto para modificarlo de modo que esta zona sirve para
familiarizarse con el framework además de servir de ayuda para generar la
estructura del proyecto.
En este caso simplemente se descargará el proyecto base que viene prediseñado
(fichero project.zip) y se explorarán los ficheros para explicar tanto la estructura
del proyecto como el contenido y uso de cada fichero en esta estructura.
Comenzando por la estructura o esqueleto del proyecto, encontramos la
distribución de ficheros que se puede ver en la Figura 26. En la carpeta principal
del proyecto encontramos los directorios actions, data y models junto con los
ficheros YALM config.yml, credentials.yml, domain.yml, endpoints.yml,
forms.yml y responses.yml.

50
 Figura 26. Estructura del proyecto en Rasa

Siguiendo el orden presentado en la figura anterior, el primer fichero que

encontramos es el directorio actions, donde se encuentra un archivo __init__.py
sin código) y el fichero actions.py, que tal y como se muestra en la siguiente
figura contiene código Python comentado con un ejemplo de acción
ActionHelloWorld que devuelve un mensaje de texto “Hello World!”. En este
fichero se crearán las acciones personalizadas necesarias para el correcto
funcionamiento del chatbot, por ejemplo, se tendrá que crear una acción que
haga la petición de un nuevo sonido a la API Meteoros. Por cada una de estas
acciones personalizadas se creará, por tanto, una clase cuyo nombre tendrá que
comenzar con la palabra Action y tendrá al menos dos funciones en su interior:
la función name que retornará el nombre de la acción personalizada que se
empleará para invocarla, y la función run, que ejecutará el código propio de
dicha acción.

Figura 27. Ejemplo de fichero actions.py

51
El siguiente fichero es el directorio data, que contiene la información básica de
entrenamiento para el chatbot. El primer archivo de esta carpeta es nlu.yml que
contiene los distintos intents o intenciones que manejará el chatbot. Estas
intenciones hacen referencia a lo que el usuario quiere hacer, por ejemplo, un
posible intent sería saludar. Siguiendo el formato YALM, dentro de estos intents
encontramos distintos ejemplos de frases que servirían para identificar la
intención del usuario, por ejemplo en el caso de saludar podríamos encontrar
“hola”. Los ejemplos son utilizados para entrenar al chatbot de modo que pueda
aprender a identificar la intención del usuario a partir de frases en lenguaje
natural y contestar en consecuencia. La estructura de este fichero es la que se
muestra en la Figura 28, y es importante mantener este formato ya que en caso
contrario el entrenamiento provocaría un error y no se podría generar
correctamente el modelo.

Figura 28. Ejemplo de fichero nlu.yml

El siguiente fichero que se incluye en el directorio data es rules.yml. Este fichero

incluye pequeñas partes de conversaciones que deben siempre seguir un mismo
orden. En muchos casos puede no ser necesario establecer reglas estrictas en
las conversaciones y es suficiente con los flujos de diálogo diseñados en las
historias (stories.yml) que se verán a continuación. Sin embargo, este fichero es
necesario para añadir, por ejemplo, la sección de conversación encargada de
gestionar situaciones en las que el chatbot no está seguro de qué está diciendo
el usuario. La estructura que presenta este documento es la que se ve en la
Figura 29. Dentro de la sección rules se listan todas las reglas necesarias con
su respectivo nombre y dentro de cada una se listan también los pasos que se
deberán seguir. Las frases del usuario serán las que se listan como intent,
mientras que las respuestas del chatbot serán las que aparecen como action o
como otras acciones prediseñadas de Rasa. Además de esto, una regla se puede
ejecutar condicionalmente si se añade una condición, tal y como se ve en el
ejemplo del prototipo en la Figura 29.

52
 Figura 29. Ejemplo de fichero rules.yml

El siguiente fichero de data es stories.yml, un archivo muy similar al de reglas

pero mucho menos restrictivo. El fichero stories contiene las historias o flujos
de conversación que se deberán seguir en las interacciones con usuarios. El
chatbot utilizará estos esquemas de conversaciones para saber qué debe
contestar cuando detecte un determinado intent. Como en el caso de las reglas,
en la sección stories se listarán las distintas historias con sus respectivos pasos
a seguir, de modo que los intents representarán lo que dice el usuario y las
acciones lo que hace o dice el chatbot. Una aclaración importante es que no
necesariamente se tendrá que intercalar una interacción de usuario con una de
chatbot, es decir, se podrán incluir varias acciones consecutivas del chatbot sin
esperar a que el usuario hable o realice alguna acción.

Figura 30. Ejemplo de fichero stories.yml

Seguidamente, encontramos el directorio models, en el que se irán
almacenando los modelos generados con cada entrenamiento. Cada vez que se
ejecute el comando train que se verá más adelante, aparecerá un nuevo fichero
con extensión tar.gz que contendrá la información del modelo entrenado que se
empleará para arrancar el servidor de Rasa. Estos ficheros se nombran de
acuerdo con la fecha en la que fueron generados y, por defecto, se empleará el
fichero más reciente como modelo para la ejecución.

53
Además de estas carpetas, también encontramos en el directorio raíz del
proyecto varios ficheros de configuración, el primero de ellos config.yml. En este
archivo se encuentra el pipeline que se ejecutará para procesar el texto de
entrada, así como las políticas para realizar las predicciones de siguientes
acciones. En este caso, habría que modificar por ejemplo la sección de idioma
(language) que va a emplear el chatbot, añadir la política de fallback por si el
chatbot no entendiese al usuario poder pedirle que reformule su frase, y
aumentar el número máximo de historias que tendrá que aprender el chatbot.
Esto se hará en apartados posteriores siguiendo con la estructura que se
presenta en la Figura 31.

Figura 31. Ejemplo de fichero config.yml

El siguiente documento que se encuentra en la carpeta raíz es credentials.yml,

y contiene las credenciales necesarias para conectarse a distintos canales como
Facebook Messenger, Slack, Mattermost o crear conexiones por sockets o API.
No será necesario modificar este fichero ya que en este proyecto se utilizarán
conexiones por API, que son las correspondientes a rest en la Figura 32, y no
requieren credenciales específicas.

Figura 32. Ejemplo de fichero config.yml

54
El fichero siguiente es domain.yml, el fichero donde se define el universo en el
que operará el chatbot. Aquí se encuentra en definitiva toda la información que
manejará el chatbot, desde los intents, los slots (variables del chatbot), las
respuestas que dará el chatbot, las acciones y los formularios, además de
algunos parámetros de configuración como el tiempo de expiración de una
sesión o la persistencia de datos entre sesiones. Las secciones de respuestas o
formularios, además, pueden no incluirse en este fichero con el fin de organizar
los datos ya que se dispone también de los ficheros forms.yml y responses.yml
(en esta misma carpeta) donde se pueden incluir esta información.

Figura 33. Ejemplo de fichero domain.yml

Y por último, encontramos el archivo endpoints.yml (ver Figura 34), que contiene
la información y configuración para conectar con otros servicios. En este fichero,
por ejemplo, se fija la dirección de acceso al servidor de acciones de Rasa que
se empleará para hacer uso de acciones personalizadas desarrolladas con el
SDK en Python. En posteriores secciones se explicará qué líneas es necesario
descomentar para establecer las conexiones que empleará el chatbot.

Figura 34. Ejemplo de fichero endpoints.yml

55
Una vez analizada la estructura y ficheros del proyecto, será necesario aplicar
los cambios oportunos para crear el chatbot que se plantea en este trabajo. Para
ello se modificará el nombre del proyecto y se irán aplicando los cambios
necesarios de manera justificada en los siguientes apartados.

3.3.2 Diseño del Flujo de Diálogo del Chatbot

El primer paso para la creación del chatbot para público infantil es diseñar el
flujo de las posibles conversaciones que vaya a tener el chatbot.
Puesto que se pretende crear una aplicación equivalente al experimento ya
publicado en Zooniverse (Clasificación por sonidos), se deberán incorporar las
preguntas de clasificación de dicho experimento en una conversación guiada
por lenguaje natural y además hacerlo de forma en que los niños que utilicen la
aplicación puedan entenderlas.
En este experimento encontrábamos tres preguntas con varias opciones de
respuesta para cada una tal y como se recoge a continuación.
Pregunta 1: ¿Cuánto dura el sonido?
x Menos de 1 segundo
x Entre 1 y 5 segundos
x Más de 9 segundos
Pregunta 2: ¿Se escucha al principio un sonido corto y luego un silencio o un
sonido menos intenso?
x Sí
x No
Pregunta 3: ¿Hay un sonido inicial con un tono diferente al resto?
x Sí
x No
Para adaptar estas preguntas así como el resto de la conversación a un público
infantil, en esta primera fase se cuenta con la supervisión de los miembros del
Aula de Astronomía de Fuenlabrada, que tienen una amplia experiencia en el
trato con niños y la realización de talleres divulgativos con estudiantes de todas
las edades. De acuerdo con este grupo, lo primero a tener en cuenta es que los
niños no tienen una noción del tiempo clara a nivel de segundos, por lo que la
primera pregunta no debería aludir a medidas tan precisas de tiempo, sino más
bien dar opciones de longitud como corto, mediano o largo. Además también
sugieren que se debería evitar la referencia a la intensidad del sonido en la
pregunta 2 o a los tonos en la tercera pregunta, ya que los niños podrían no
estar familiarizados con estos conceptos. El caso de la pregunta 3 se podría
expresar como: ¿Suena igual al principio y al final?
En definitiva, las preguntas deben ser muy simples y claras, sin hacer alusiones
a términos o conceptos complejos relacionados con temas físicos. Las preguntas
de la clasificación, por tanto, quedarían como se muestra a continuación.
Pregunta 1: ¿Cómo es el sonido? ¿Es corto, mediano, o largo?
x Corto
x Mediano
x Largo

56
Pregunta 2: ¿Se escucha al principio un sonido corto y luego un silencio?
x Sí
x No
Pregunta 3: ¿Suena igual al principio y al final?
x Sí
x No
Además de esto, el Aula de Fuenlabrada desaconseja utilizar gráficas como las
del experimento de Clasificación por imágenes de Zooniverse para acompañar
los sonidos, ya que sugieren que los alumnos de Primaria no entenderían las
gráficas e incluso podrían confundirles. Lo que sí recomienda es utilizar un
vídeo, no muy largo, como la explicación del experimento, para que los niños no
pierdan la atención al escuchar al chatbot. Además también recomiendan
utilizar un botón que permita acceder esta explicación cualquier momento, de
modo que no sea accesible solo por voz.
Partiendo de estas pautas generales, se diseña una conversación básica que
permitiría a los niños clasificar los sonidos de meteoros.

NIÑO/A: ¡Hola!
CHATBOT: ¡Hola! Bienvenido a Sonidos del Cielo, el proyecto de Ciencia
Ciudadana para la clasificación de meteoros a través de sus sonidos.
CHATBOT: ¿Necesitas que te explique en qué consiste el juego o quieres
empezar a jugar?
NIÑO/A: ¡Explícame el juego!
CHATBOT: ¡Vamos con la explicación! Cuando termine el vídeo puedes decir ¡A
jugar! Para empezar a clasificar meteoros.
CHATBOT: [Reproduce vídeo]
NIÑO/A: ¡A jugar!
CHATBOT: ¡Genial! Pasemos a la clasificación de meteoros.
CHATBOT: A continuación escucharás un sonido y te haré unas preguntas.
Pon atención y recuerda que puedes reproducir el sonido tantas veces como
necesites.
CHATBOT: [Reproduce sonido]
CHATBOT: ¿Cómo es el sonido? ¿Es corto, mediano o largo?
NIÑO/A: Es corto / Es mediano / Es largo
CHATBOT: Has respondido corto / Has respondido mediano / Has respondido
largo
CHATBOT: ¿Se escucha al principio un sonido corto y luego un silencio?
NIÑO/A: Sí / No
CHATBOT: Has respondido corto / Has respondido mediano / Has respondido
largo. Vamos con la última pregunta…
CHATBOT: ¿Suena igual al principio y al final?
NIÑO/A: Sí / No

57
CHATBOT: Has respondido corto / Has respondido mediano / Has respondido
largo. ¡Has clasificado este meteoro!
CHATBOT: ¿Quieres clasificar el siguiente sonido?
NIÑO/A: Sí / No
CHATBOT: (Sí) [Inicia nueva clasificación] / (No) ¡Gracias por ayudarnos a
clasificar meteoros! Si quieres volver a jugar o quieres conocer información
sobre el proyecto no dudes en pedírmelo.
NIÑO/A: ¡Adiós!
CHATBOT: ¡Hasta la próxima! Espero que lo hayas pasado bien.

Puesto que la conversación con el chatbot no es muy extensa y podría resultar

poco natural, aun incluyendo distintas frases de respuesta, se decide también
incluir tres ejemplos de conversación corta para que los niños puedan preguntar
sobre el proyecto, sobre qué hay que hacer o sobre qué es un meteoro.

NIÑO/A: ¿Qué es Sonidos del Cielo?

CHATBOT: Sonidos del Cielo es un proyecto de Ciencia Ciudadana para que
cualquier persona pueda ayudar a los expertos a clasificar meteoros. ¡Puedes
encontrar más información sobre el proyecto en la página web del proyecto!

NIÑO/A: ¿Qué hay que hacer?

CHATBOT: Cuando digas ¡A jugar! Empezará el juego. Se reproducirá un sonido
y te haré tres preguntas. ¡Cuantas más clasificaciones completes más puntos
obtendrás!

NIÑO/A: ¿Qué es un meteoro?

CHATBOT: Se llama meteoroide a los cuerpos menores o rocas que viajan por
el espacio, cuando entran en la atmósfera se les llama meteoros y cuando
alcanzan la superficie de la Tierra se les llama meteoritos. Popularmente los
meteoros son conocidos como estrellas fugaces y están formados por una roca
y una estela.

Además de esto se tendrá que contemplar la posibilidad de que el chatbot no

reconozca una frase a la primera, por lo que deberá pedir al niño que reformule
la frase para que pueda entenderlo. En estos casos el chatbot responderá con
la siguiente frase o alguna otra equivalente.

CHATBOT: Vaya, no he entendido eso, ¿podrías repetirlo de otra manera para

que pueda entenderte?

58
3.3.3 Diseño del Conjunto de Datos para el Chatbot

A partir del flujo de diálogo diseñado previamente, es necesario aumentar los

ejemplos de frases que manejará el chatbot, tanto los de frases que puede recibir,
como los de frases de respuesta con los que contestará.
En primer lugar se generarán los ejemplos de frases que los niños pueden decir
en una conversación con un determinado objetivo. Estas frases de ejemplo
servirán para que Rasa NLU identifique las intenciones de los usuarios, y estas
intenciones servirán a su vez para saber cómo responder en cada caso. En un
proyecto Rasa, esta información se encuentra en la carpeta data, concretamente
en el fichero nlu.yml (/data/nlu.yml).
El fichero nlu.yml tiene la estructura que se muestra en la Figura 35. En él se
encuentran una serie de instancias de intents (o intenciones) a los que se asigna
un nombre que permita identificar la intención misma. Estos intents contienen
diversos ejemplos que sirven para entrenar al modelo de forma que cada vez que
un usuario diga una de las frases listadas o similar se podrá identificar el intent
al que pertenece y se podrá contestar correctamente. Por ejemplo, si un usuario
dice la frase “Hola” se debería identificar una intención saludar y se debería
contestar algo como “Hola, bienvenido”.

Figura 35. Fichero nlu.yml del proyecto

Es importante que el fichero se escriba con la estructura correcta, ya que en

caso contrario el entrenamiento del chatbot dará error y no se podrá generar el
modelo correctamente.
A continuación se incluye el conjunto de datos que empleará el NLU de Rasa
para identificar las intenciones, es decir, los ejemplos que se empleará para
entrenar el chatbot y que le permitirán entender a los usuarios.

59
saludar:
x hola
x holi
x hey
x qué hay
x qué pasa
x buenas
x buenos días
x buenas tardes
x buenas noches
x saludos

despedirse:
x adiós
x chao
x hasta luego
x hasta luego
x hasta la vista
x hasta pronto
x me voy
x nos vemos

negar:
x en absoluto
x nada
x negativo
x negación
x nanai
x no
x no quiero
x nop

afirmar:
x afirmativo
x claro
x chachi
x definitivamente
x guay
x por supuesto
x seguro
x sep
x sip
x si
x yep
x yes
x vale
x siguiente

clasificar:
x quiero jugar
x jugar

60
 x me gustaría jugar
x quiero clasificar
x clasificar
x me gustaría clasificar

tutorial:
x explica
x explícame
x explica el juego
x explícame el juego
x quiero que me expliques
x quiero una explicación
x de que va el juego
x cómo se juega

corto:
x el sonido es corto
x es corto
x es un sonido corto

mediano:
x el sonido es mediano
x es mediano
x es normal
x es regular
x es un sonido mediano
x mediano
x medio
x normal
x regular

largo:
x el sonido es largo
x es largo
x es un sonido largo
x largo

preguntar_proyecto:
x ¿qué es sonidos del cielo?
x ¿para qué sirve sonidos del cielo?
x ¿qué hace sonidos del cielo?
x ¿qué significa sonidos del cielo?
x no sé qué es sonidos del cielo
x que es sonidos del cielo
x de qué va sonidos del cielo
x para que sirve sonidos del cielo
x información sobre sonidos del cielo
x información del proyecto
x información sobre el proyecto
x información de sonidos del cielo

61
preguntar_aclarar:
x ¿qué hay que hacer?
x ¿qué hay que hacer ahora?
x ¿qué tengo que hacer ahora?
x no sé qué hay que hacer
x no me he enterado
x qué tengo que hacer
x que ahoga ahora

preguntar_meteoro:
x ¿qué es un meteoro?
x ¿qué es un meteoroide?
x no sé qué es un meteoro
x no sé qué es un meteoroide

Tras haber generado las frases de ejemplo para cada intención, se crearán
también frases de respuesta, que serán las que contestará el chatbot cuando
sea necesario de acuerdo con la lógica que se establezca más adelante. En un
proyecto Rasa, estos datos se almacena en el fichero domain.yml, donde se
encuentra toda la información que define el funcionamiento del chatbot, en
concreto en el apartado responses, tal y como se ve en la Figura 36. En este
apartado se incluyen acciones utter (decir), que son acciones predefinidas para
que el chatbot conteste. Estas acciones deben comenzar necesariamente por
utter_ y a continuación se les da un nombre significativo que denote lo que se
va a decir con esa respuesta, por ejemplo utter_hola o utter_saludo para la
respuesta “Hola”.

Figura 36. Fichero domain.yml (respuestas)

62
Como se puede ver en la Figura 36, dentro de una respuesta determinada como
utter_adios se pueden incluir distintos mensajes. Estos mensajes se asociarán
con la acción en la que estén incluidos, de modo que cuando la lógica del chatbot
determine que se debe responder con una acción tipo utter_adios el chatbot
responderá con una de las frases que tenga asociadas. La elección de la
respuesta será aleatoria dentro de cada acción, de modo que el contenido de
cada frase no debe ser distinto en esencia. El propósito de añadir más frases es
simplemente aportar naturalidad a la conversación para que el chatbot no
conteste siempre de la misma forma y la interacción no resulte monótona para
el usuario, pero las frases de una misma acción utter siempre deberían expresar
lo mismo.
A continuación se recogen las frases de respuesta creadas para que el chatbot
conteste a los intents presentados anteriormente. Para mejorar su legibilidad no
se presentan en el formato de YML, sin embargo, como en el caso del fichero
nlu.yml, es importante que en el proyecto se respete su estructura, puesto que
si no es así no se podrá generar el modelo.

utter_adios:
x ¡Adiós! Gracias por tu tiempo.
x Espero que te hayas divertido, ¡vuelve pronto!
x Gracias por tu tiempo, ¡vuelve cuando quieras!
x Gracias por jugar a Sonidos del Cielo, ¡espero verte pronto!
x Gracias por jugar conmigo, ¡espero que te hayas divertido!
x ¡Hasta pronto! Vuelve cuando quieras.
x ¡Hasta la próxima! Espero que lo hayas pasado bien.
x Me lo he pasado genial contigo, ¡espero volver a verte pronto!
x Vuelve siempre que quieras, ¡nos vemos en el espacio de Sonidos del Cielo!
x Vuelve siempre que quieras, ¡te esperamos en Sonidos del Cielo!

utter_hola:
x ¡Bienvenido! Me alegra verte, esto es Sonidos del Cielo, el proyecto de
Ciencia Ciudadana para la clasificación de meteoros a partir de sus
sonidos.
x Bienvenido a Sonidos del Cielo, aquí podrás escuchar meteoros y ayudar
a los expertos en su clasificación.
x ¡Hola! Bienvenido a Sonidos del Cielo, el proyecto de Ciencia Ciudadana
para la clasificación de meteoros a través de sus sonidos.
x ¡Hola! Esto es Sonidos del Cielo, el proyecto de Ciencia Ciudadana para
la clasificación de meteoros a partir de sus sonidos.
x ¡Hola! Qué bien verte por el espacio, esto es Sonidos del Cielo, el proyecto
de Ciencia Ciudadana para la clasificación de meteoros a través de sus
sonidos.
x ¡Me alegra verte! Esto es Sonidos del Cielo, el proyecto de Ciencia
Ciudadana para la clasificación de meteoros a partir de sus sonidos.
x ¡Parece que tenemos visita! ¡Hola! Esto es Sonidos del Cielo, el proyecto
de Ciencia Ciudadana para la clasificación de meteoros a partir de sus
sonidos.
x ¿Qué tal? Bienvenido a Sonidos del Cielo, el proyecto de Ciencia
Ciudadana para la clasificación de meteoros a través de sus sonidos.

63
utter_menu:
x ¿Quieres que te explique el juego o prefieres empezar a jugar?
x ¿Necesitas que te explique en qué consiste el juego o quieres empezar a
jugar?
x ¿Qué te gustaría hacer, escuchar la explicación del juego o empezar a
jugar?

utter_tutorial:
x ¡Vamos con la explicación! Cuando termine el vídeo puede decir ¡A jugar!
para empezar a clasificar meteoros.

utter_clasificar:
x ¡Bien!¡Preparados para jugar!
x ¡Empezamos con la clasificación de meteoros!
x ¡Entonces estamos listos para clasificar meteoros!
x ¡Estupendo!¡Vamos a clasificar meteoros!
x ¡Genial! Pasemos a la clasificación de meteoros.
x ¡Genial!¡Vamos a jugar!
x Listos para la clasificación de meteoros.
x ¡Listos para jugar!
x ¡Muy bien! Empecemos con la clasificación de meteoros.
x Vamos con la clasificación de meteoros.
x Comencemos con la clasificación de meteoros.

utter_clasificar_instrucciones:
x Espero que estés preparado para clasificar meteoros. A continuación
oirás un sonido te haré unas preguntas. Puedes reproducir el sonido el
meteoro tantas veces como necesites.
x A continuación escucharás un sonido y te haré unas preguntas. Pon
atención, y recuerda que puedes reproducir el sonido tantas veces como
necesites.

utter_pregunta1:
x ¿Cómo es el sonido? ¿Es corto, mediano o largo?
x ¿El sonido que has escuchado es corto, mediano, o largo?
x ¿El sonido es corto, mediano, o largo?

utter_feedback_respuesta1:
x Has contestado {duracion}
x Tu respuesta ha sido sonido {duracion}

utter_pregunta2:
x ¿Se escucha al principio un sonido corto y luego un silencio?

utter_feedback_respuesta2:
x Has respondido {respuesta2}. Vamos con la última pregunta...
x Has respondido {respuesta2}. Solo nos queda una pregunta.
x Has respondido {respuesta2}. Seguimos con la última pregunta.

utter_pregunta3:
x ¿Suena igual al principio y al final?

64
 x ¿El sonido es igual al principio y al final?

utter_feedback_respuesta3:
x Has respondido {respuesta3}. ¡Has completado esta clasificación!
x Has respondido {respuesta3}. ¡Has clasificado este sonido!
x Has respondido {respuesta3}. ¡Has clasificado este meteoro!
x Tu respuesta ha sido {respuesta3}. ¡Has clasificado un sonido!
x Tu respuesta ha sido {respuesta3}. ¡Hemos terminado con este sonido!
x Tu respuesta ha sido {respuesta3}. ¡Vamos a enviar tu clasificación!
x Has contestado {respuesta3}. ¡Gracias por clasificar este sonido conmigo!
x Has contestado {respuesta3}. ¡Hemos completado una clasificación!
x Has contestado {respuesta3}. ¡Has clasificado un sonido!

utter_seguir_clasificando:
x ¿Quieres clasificar el siguiente sonido?
x ¿Quieres clasificar el siguiente meteoro?
x ¿Quieres seguir con la clasificación?
x ¿Quieres seguir clasificando?
x ¿Quieres que pasemos al siguiente sonido?

utter_siguiente_clasificacion:
x Vamos con el siguiente sonido
x Vamos con el siguiente meteoro
x Atento al siguiente sonido
x Presta atención al siguiente sonido
x Escucha el siguiente sonido

utter_parar_clasificacion:
x ¡Gracias por ayudarnos a clasificar meteoros!, si quieres volver a jugar o
conocer información sobre el proyecto no dudes en pedírmelo
x ¡Gracias por jugar conmigo!, si quieres volver a jugar o conocer
información sobre el proyecto puedes pedírmelo
x Espero que te hayas divertido, si quieres volver a jugar o conocer
información sobre el proyecto no dudes en pedírmelo
x Gracias por tu tiempo, si quieres volver a jugar o conocer información
sobre el proyecto no dudes en pedírmelo

utter_definicion_meteoro:
x Se llama meteoroide a los cuerpos menores o rocas que viaja por el
espacio, cuando entran en la atmósfera se les llama meteoros y cuando
alcanzan la superficie de la Tierra se les llama meteoritos. Popularmente
los meteoros son conocidos como estrellas fugaces y están formados por
una roca y una estela.

utter_sobre_proyecto:
x Sonidos del Cielo es un proyecto de ciencia ciudadana para que cualquier
persona pueda ayudar a los expertos a clasificar meteoros. ¡Puedes
encontrar más información sobre el proyecto en la página web del
proyecto!

utter_que_hacer:

65
 x Si dices "a jugar" podremos empezar con la clasificación. Se reproducirá
un sonido y te haré tres preguntas. ¡Cuantas más clasificaciones hagas
más puntos obtendrás!
x Cuando digas "a jugar" empezará el juego. Se reproducirá un sonido y te
haré tres preguntas. ¡Cuantas más clasificaciones completes más puntos
obtendrás!

utter_reformular:
x Perdona, no te he entendido... ¿podrías repetirlo de otra manera para que
pueda entenderte?
x Creo que no te he entendido, ¿podrías repetirlo de otra forma?
x Vaya, no he entendido eso, ¿podrías repetirlo de otra manera para que
pueda entenderte?
x No te he entendido, por favor ¿podrías repetirlo de otra forma?

Estos serían los datos textuales necesarios para que el chatbot fuese capaz de
tener una conversación (entender las intenciones y responder). En alguno de
estos ejemplos se usa la expresión {nombre de variable} de YML para indicar que
en ese lugar iría el valor de la variable del chatbot, lo que significa que además
de estas frases será necesario recoger algunos valores en variables. Se hablará
de estas variables y del resto de acciones empleadas por el chatbot en el
siguiente apartado.

3.3.4 Implementación de la Lógica del Chatbot

Una vez se dispone de los ejemplos para los intents con los que trabajará el NLU
(Natural Language Understanding) de Rasa, y las respuestas que empleará el
chatbot para contestar, el siguiente paso es definir los pasos que se deberán
seguir en las conversaciones. Para poder crear esta lógica de las conversaciones,
se crearán historias (stories), reglas (rules), acciones personalizadas (actions) y
variables (slots).
Comenzando por los componentes más pequeños, primero será necesario definir
qué variables o slots va a emplear internamente el chatbot para almacenar
información. La declaración de variables se realiza en el fichero domain.yml
dentro del apartado slots, tal y como se ve en la Figura 37. En él se incluye el
nombre de la variable y su tipo (type), que en este caso siempre será texto, y
además se puede establecer si la variable en cuestión afectará al flujo de la
conversación (influence_conversation).

66
 Figura 37. Fichero domain.yml (slots)

A continuación se incluye una explicación de cada variable para justificar su

uso:
x id: almacena el identificador de la detección que se recibe. Se almacenará
en el chatbot cuando se haga una petición GET a la API Meteoros para
saber qué sonido se está clasificando. Se enviará a la aplicación web
junto con la URL del sonido que se va a clasificar y finalmente se
empleará para hacer la llamada POST con las respuestas de la
clasificación de dicho sonido. Se trata de una variable texto que
almacenará valores como "fuenlabrada_2020-05-02-15453015".
x audio: almacena la dirección del sonido que se va a clasificar. Se
almacenará en el chatbot cuando se haga una petición GET a la API
Meteoros, igual que la variable id. Esta variable se enviará a la aplicación
web para que allí se almacene y reproduzca. Se trata de una variable de
tipo texto ya que almacenará la dirección URL de un sonido, como por
ejemplo
http://138.100.100.143/fuenlabrada/opendata/sounds_test/mayo/fu
enlabrada_2020-05-02-15453015.wav.
x duracion: almacena uno de los posibles valores de duración del meteoro:
corto, mediano o largo. Se emplea para poder ofrecer retroalimentación
al usuario una vez responda a la primera pregunta de la clasificación.
x respuesta1: almacena la respuesta a la pregunta 1, que podrá ser:
Menos de 1 segundo, Entre 1 y 5 segundos o Más de 9 segundos. Es
necesaria ya que se debe mantener el mismo nombrado de respuestas
que en el experimento en Zooniverse, por lo que el nombrado para público
infantil simplemente se utilizará a nivel de interfaz. Esta será una de las
respuestas que se envíe en la llamada POST a la API de Meteoros para
crear una nueva clasificación.
x respuesta2: almacena la respuesta a la pregunta 2, que podrá ser: Sí o
No. Esta será otra de las respuestas que se envíe en la llamada POST a
la API de Meteoros para crear una nueva clasificación.
x respuesta3: almacena la respuesta a la pregunta 2, que podrá ser: Sí o
No. Esta será otra de las respuestas que se envíe en la llamada POST a
la API de Meteoros para crear una nueva clasificación.
67
Una vez declaradas las variables en el fichero domain.yml, el siguiente paso será
declarar e implementar las acciones personalizadas que se necesitarán para
hacer llamadas a la API de Meteoros, almacenar valores en las variables ya
vistas, así como para enviar mensajes personalizados a la aplicación web, por
ejemplo para reproducir el vídeo explicativo. De acuerdo con estas necesidades,
en el fichero domain.yml se declararán las siguientes acciones, cuya
implementación se encontrará en el fichero actions.py (/actions/actions.py):
x action_get_sample: esta acción hace una llamada GET a la API de
Meteoros para obtener un identificador de detección y la dirección URL
de su correspondiente sonido. Una vez obtiene la respuesta de la llamada,
almacena estos valores en sus correspondientes variables o slots y
finalmente crea y envía como respuesta al usuario un mensaje JSON con
un objeto sample. Este objeto sample que se envía en el mensaje contiene
el atributo y valor de las variables id y audio.
x action_send_classification: esta acción es la encargada de hacer la
llamada POST a la API de Meteoros para crear una nueva clasificación en
el sistema. Primero crea un objeto con los valores de las variables
necesarios (id, respuesta1, respuesta2 y respuesta3) y tras esto devuelve
a None el valor de todas estas variables. A continuación, manda al
usuario un mensaje personalizado clasification con el atributo new y su
valor true, que servirá para incrementar el contador de detecciones desde
la aplicación web.
x action_play_video: esta acción crea y envía un mensaje personalizado
con un objeto video que contiene un atributo tutorial con valor true. Esta
acción servirá para activar la reproducción del vídeo de explicación del
proyecto en la interfaz web.
x action_set_r1_corto: esta acción guarda en el slot duración el valor
“corto” y en el slot respuesta1 el valor “Menos de 1 segundo”.
x action_set_r1_mediano: esta acción guarda en el slot duración el valor
“mediano” y en el slot respuesta1 el valor “Entre 1 y 5 segundos”.
x action_set_r1_largo: esta acción guarda en el slot duración el valor
“largo” y en el slot respuesta1 el valor “Más de 9 segundos”.
x action_set_r2_si: esta acción guarda en el slot respuesta2 el valor “Sí”.
x action_set_r2_no: esta acción guarda en el slot respuesta2 el valor “No”.
x action_set_r3_si: esta acción guarda en el slot respuesta3 el valor “Sí”.
x action_set_r3_no: esta acción guarda en el slot respuesta3 el valor “No”.

68
 Figura 38. Fichero actions.py (función action_send_classification)

Una vez implementadas estas acciones, el siguiente paso es crear las historias
(stories). Las historias deberán ser lo más modulares posibles, por ejemplo, se
puede crear una historia saludo en la que el usuario saluda y el chatbot
responde con un saludo y las opciones que puede escoger el usuario para
comenzar a clasificar meteoros. Para favorecer esta modularidad al máximo, en
las historias se utilizarán checkpoints que servirán como puntos de bifurcación
en el flujo de diálogo para evitar repetir fragmentos enteros de conversación. A
efectos de ejecución, cuando una historia acaba con un checkpoint y otra
empieza con ese mismo checkpoint, el comportamiento es igual que si se tratase
de una única historia. A continuación se recogen las historias necesarias para
que el chatbot funcione tal y como se diseñó en apartados anteriores.

69
x saludo: de acuerdo con esta historia, si el usuario saluda, el chatbot
responderá con un saludo y seguidamente le dirá que opciones tiene para
empezar a usar la aplicación (escuchar la explicación o clasificar sonidos
directamente).

story: saludo

intent: saludar

action: utter_hola

action: utter_menu

Figura 39. Historia saludo

x explicacion: si el usuario pide que el chatbot le explique en qué consiste

el experimento de clasificación de meteoros, el chatbot le responderá que
va a reproducir un vídeo explicativo y cuando acabe puede pedirle que
empiece el juego. A continuación, enviará un mensaje que activará la
reproducción del vídeo en la interfaz.

story: explicación

intent: tutorial

action: utter_tutorial

action: action_play_video

Figura 40. Historia explicacion

x clasificacion: esta historia incluye a su vez distintas historias en función

de las respuestas que dé el usuario a las tres preguntas que servirán
para clasificar un meteoro. Esta historia comienza cuando el usuario pide

70
empezar a jugar o clasificar, entonces el chatbot deberá introducir la
clasificación, explicar las instrucciones, pedir un sonido de detección y
hacer las preguntas. Por cada pregunta se esperará una respuesta, y una
vez responda el usuario, el chatbot guardará el valor de la respuesta en
las variables o slots correspondientes. Una vez guardada la respuesta a
la pregunta, el chatbot dará retroalimentación al usuario sobre su
respuesta y le formulará la siguiente pregunta. Esto ocurrirá así en las
tres preguntas, pero tras contestar la tercera pregunta una vez se dé
retroalimentación sobre la respuesta, además se enviarán las respuestas
a la API y se preguntará si se desea seguir clasificando meteoros.

story: clasificacion

intent: clasificar

action: utter_clasificar

action: utter_clasificar_instrucciones
ifi

action: action_get_sample

action: utter_pregunta1

checkpoint: check_pregunta1
h k

intent: corto iintent: mediano

di iintent: llargo

action:
ctio action:
ction action:
tion
action_set_r1_corto action_set_r1_mediano action_set_r1_largo

slot_was_set:
was slot_was_set:
was slot_was_set:
was
- duracion: “corto” - duracion: “mediano” - duracion: “largo”

action:
tion action:
ction action:
tion
utter_feedback_respuesta1 utter_feedback_respuesta2 utter_feedback_respuesta3

71
 action: action: action:
utter_pregunta2 utter_pregunta2 utter_pregunta2

checkpoint: check_pregunta2
h k 2

intent: afirmar
f iintent: negar

action:
ction action:
tion
action_set_r2_si action_set_r2_no

slot_was_set:
was slot_was_set:
was
- respuesta2: “Sí” - respuesta2: “No”

action:
ction action:
tion
utter_feedback_respuesta2 utter_feedback_respuesta2

action:
ction action:
tion
utter_pregunta3 utter_pregunta3

checkpoint:
eckpoint: che
c
check_pregunta3
eck pregunta

intent: afirmar
fi iintent: negar

action:
ction action:
ction
action_set_r3_si action_set_r3_no

slot_was_set:
was slot_was_set:
was
- respuesta3: “Sí” - respuesta3: “No”

action:
ction action:
ction
utter_feedback_respuesta3 utter_feedback_respuesta3

action:
ction action:
ction
action_send_classification action_send_classification

action:
ction action:
ction
utter_seguir_clasificando utter_seguir_clasificando

checkpoint: check_siguiente

72
 intent: afirmar intent: negar

action:
ction action:
ction
utter_siguiente_clasificacion utter_parar_clasificacion

action:
ction
action_get_sample

action:
ction
utter_pregunta1

Figura 41. Historia clasificación

x sobre el proyecto: si el usuario pide información sobre el proyecto

Sonidos del Cielo el chatbot contestará en qué consiste el proyecto y
dónde puede encontrar más información.

story: sobre el proyecto

intent: preguntar_proyecto

action: utter_sobre_proyecto

Figura 42. Historia sobre el proyecto

x que es un meteoro: si el usuario pregunta qué es un meteoro o un

meteoroide, el chatbot responderá con una explicación sobre los
meteoros y los nombres que recibe cuando atraviesan la atmósfera o
alcanzan la superficie de la Tierra.

story: que es un meteoro

intent: preguntar_meteoro

73
 action: utter_definicion_meteoro

Figura 43. Historia que es un meteoro

x que hay que hacer: si el usuario no sabe que hay que hacer en la
aplicación, puede preguntarle al chatbot y este explicará qué debe hacer
para comenzar la clasificación y en qué consiste esta clasificación.

story: que hay que hacer

intent: preguntar_aclarar

action: utter_que_hacer

Figura 44. Historia que hay que hacer

x despedida: si el usuario se despide, el chatbot le agradecerá haber

participado en el experimento y se despedirá también.

story: despedida

intent: despedirse

action: utter_adios

Figura 45. Historia despedida

Además de estas historias, se tendrá que contemplar la posibilidad de que el

chatbot no entienda a la primera lo que quiere decir el usuario, en estos casos,
el chatbot tendrá que pedir que se reformule la última frase. Para manejar este
tipo de situaciones, Rasa emplea un intent nlu_fallback. En el fichero config.yml
se añade el clasificador de fallbacks o acciones de respaldo (FallbackClassifier)
con un umbral a partir del cual se activará el intent nlu_fallback. Este umbral
establece la confianza o precisión límite a partir de la cual se considerará que

74
la predicción de acciones no es segura. Por ejemplo, si se predice una acción
utter_adios con un 0.4 de precisión pero el umbral está fijado en un 0.5, se
utilizará el nlu_fallback. En la siguiente figura se fija la configuración de este
clasificador.

Figura 46. Configuración del pipeline en config.yml del umbral para el intent
fallback (línea 16 y 17)

Una vez activado el intent nlu_fallback, el chatbot tendrá que responder con una
frase que indique al usuario que debe reformular su frase para poder entenderle
mejor, para ello, será necesario definir una respuesta (si no se ha hecho ya) en
la sección de respuestas del fichero domain.yml, o directamente en el fichero
responses.yml. Esta respuesta se añade dentro de la sección responses, como
el resto de las respuestas utter, por tanto también se podrán añadir varias
alternativas para que el chatbot responda con mayor naturalidad cuando sea
necesario que el usuario repita su última frase (ver Figura 47).

Figura 47. Respuesta al intent fallback

Por último, se debe añadir una regla que establezca estos pasos ya
mencionados: primero se detecta el intent nlu_fallback y seguidamente el
chatbot responde con su petición de reformular la última frase. En este caso, la
estructura es similar a la de las historias.
x Pedir que repita la ultima frase: si no se detecta una intención con la
suficiente precisión de acuerdo con el umbral, se activará el intent
nlu_fallback y el chatbot pedirá al usuario que reformule su última frase
para poder entenderla.

75
 rule: pedir que repita la ultima frase

intent: nlu_fallback

action: utter_reformular

Figura 48. Regla Pedir que repita ultima frase

Con todos estos componentes implementados, el siguiente paso sería configurar

y ejecutar el entrenamiento del chatbot tal y como se recoge en el siguiente
apartado.

3.3.5 Entrenamiento del Chatbot

El siguiente paso, una vez se dispone de los datos y la lógica de las

conversaciones, será entrenar al chatbot para obtener el modelo con el que se
ejecutará el servidor de Rasa. Antes de presentar los comandos necesarios para
el entrenamiento del modelo, será necesario aplicar algunos cambios en los
archivos de configuración que se emplearán en el entrenamiento o en la
ejecución del servidor que se realice una vez generado el modelo.
En primer lugar, en el fichero config.yml será necesario cambiar el idioma a
español (es) y también incrementar el número máximo de historias, en este caso
se aumenta a 20 aunque en total en el fichero stories.yml hay 16.

Figura 49. Configuración del fichero config.yml

76
Una vez hecho esto, en el fichero endpoints.yml se descomentarán las líneas
correspondientes al punto de acceso del servidor de acciones (action_endpint)
donde se especifica la dirección URL de dicho servidor.

Figura 50. Configuración del fichero endpoints.yml

Una vez configurado el chatbot, se podrá entrenar al agente. Para ello, una vez
esté activado el entorno virtual de Rasa, se ejecutará el comando train tal y como
se muestra en los siguientes pasos. Tras el entrenamiento, que llevará al menos
una hora, se generará un fichero tar.gz en la carpeta modelos, que será el que
se utilice en el siguiente apartado para la ejecución del servidor principal de
Rasa. Si durante la ejecución del comando train se produce un error, será
necesario revisar el mensaje de error y corregir el fichero incorrecto.
x Activar el entorno virtual de Rasa (desde el directorio del entorno):
source venvrasa/bin/actívate

x Entrenamiento del chatbot:

rasa train

3.3.6 Pruebas y Correcciones del Chatbot

Una vez generado el nuevo modelo del chatbot tras el entrenamiento, el

siguiente paso será los servidores de Rasa, tanto el servidor acciones del SDK
de Python como el servidor principal con el modelo entrenado en la sección
anterior.
Para poder arrancar el chatbot como una API a la que hacer llamadas POST se
deberán abrir dos terminales distintos en los que ejecutar los comandos que se
encuentran a continuación.
x Terminal 1: Arrancar el servidor de acciones del SDK de Rasa:
python -m rasa_sdk --actions actions

77
 Figura 51. Ejecución del comando para arrancar el servidor de acciones

x Terminal 2: Arrancar el servidor de Rasa con el modelo entrenado:

rasa run -m models --enable-api --cors “*” --debug --endpoints
endpoint.yml

Figura 52. Ejecución del comando para arrancar el servidor principal de Rasa

Una vez arrancados ambos servidores se pasa a realizar diversas pruebas para
comprobar que el flujo de conversación es correcto y que el chatbot responde
como se esperaba. Para hacer estas pruebas se utiliza la aplicación Postman,
que permite hacer llamadas a API introduciendo la dirección URL de la API y un
cuerpo de texto, tal y como se hará desde la aplicación web. Como se puede ver
en la siguiente figura, se realizarán llamadas POST a la URL
http://localhost:5005/webhooks/rest/webhook y en el cuerpo de la llamada se
añadirá un identificador de usuario (sender) junto con el mensaje de texto
(message), que será la entrada que reciba el chatbot. Si la llamada funciona
correctamente, se recibirá una respuesta 200 OK con un cuerpo de texto en el
que se encuentren los distintos mensajes que haya respondido el chatbot con

78
un identificador de usuario (recipient_id) y el texto de la respuesta (text). En el
Anexo se incluyen todas las llamadas de comprobación del flujo realizadas de
este modo. En la Figura 53 se muestra un ejemplo de mensaje enviado desde
Postman, en concreto se inicia la conversación con un mensaje “hola”, que
correspondería al intent saludar. El resto de las llamadas de comprobación del
flujo se pueden ver en el Anexo de esta memoria.

Figura 53. Llamada de prueba del sistema desde Postman

3.4 Aplicación web

3.4.1 Diseño de la Interfaz Web

El primer paso para la creación de la aplicación web consiste en crear un diseño

que se ajuste a las necesidades del proyecto. En este caso los requisitos
propuestos son:
x Crear una interfaz amigable y atractiva para público infantil (niños).
x Que la interfaz pueda ser utilizada sin ninguna restricción por niños que
no sepan leer ni escribir.
Puesto que en estos requisitos no se incluyen detalles específicos de diseño
relacionados con colores, botones, animaciones, o en definitiva ningún posible
componente gráfico, en este apartado se realiza el trabajo creativo necesario
para tratar de definir un posible diseño sencillo, usable y accesible.
En la figura que se muestra a continuación (ver Figura 54) se muestra el diseño
de bajo nivel propuesto para la interfaz de la aplicación.

79
 Figura 54. Diseño de bajo nivel de la interfaz web para ordenador

A continuación se razona el uso de cada componente de la interfaz:

x Logo: se encuentra en la esquina superior izquierda. Se trata de un
identificador visual del proyecto Sonidos del Cielo, también presente en
la página oficial del proyecto, así como en el experimento de Zooniverse.
Necesario como parte de la identidad visual del proyecto.
x Transcripción de voz: se encuentra en la parte superior de la pantalla,
en el centro. Se trata de una caja de texto en la que se transcribirá la
última frase completa detectada, de modo que sirve como
retroalimentación al usuario para saber qué ha escuchado la aplicación.
No es necesario que el usuario pueda leer esta caja de texto ya que
simplemente sirve como un refuerzo visual y textual extra de
retroalimentación.
x Contador de clasificaciones: se encuentra en la parte superior de la
pantalla, a la derecha de la caja de transcripción. Se trata de un contador
como el que se encuentra en juegos tradicionales, que en lugar de
contabilizar puntos, contabiliza clasificaciones realizadas. Cada vez que
se complete una clasificación (se contesten las tres preguntas), se
incrementará en uno el contador. El contador servirá como elemento de
gamificación que motive a los niños a seguir clasificando meteoros para
incrementar su valor.
x Indicador de estado del micrófono: se encuentra en la parte superior
derecha de la pantalla, junto al contador de clasificaciones. Se trata de
un indicador visual de la captura de audio a través del micrófono. Si el
indicador tiene un color blanco y una animación de pulso significará que
la aplicación está escuchando o capturando sonidos. Si por el contrario
tiene un color gris y ninguna animación, significará que la captura de
sonido está desactivada. Este indicador es de utilidad ya que aporta
información de forma visual acerca de si el sistema está escuchando o
no, de modo que se evita que el usuario hable cuando no se le va a
escuchar. También, si se produce algún parón o retardo en la aplicación
se puede visualizar rápidamente si el sistema espera que hablemos o si

80
 por el contrario está procesando alguna petición internamente. A nivel
lingüístico, este indicador serviría como una especie de “semáforo” para
indicar los turnos de la conversación (cuando se escucha y cuando se
habla).
x Botón para repetir el último sonido: este botón se encuentra en la parte
superior derecha de la pantalla, bajo el indicador de estado del micrófono.
Este botón permite volver a reproducir el sonido que se está clasificando,
ya que es posible que el usuario necesite escucharlo varias veces para
poder contestar a las preguntas de la clasificación. Este botón hace
posible que se reproduzca el sonido en cualquier momento y sin alterar
el flujo del diálogo.
x Botón para reproducir el vídeo explicativo: este botón se encuentra en
la parte superior derecha de la pantalla, bajo el botón para repetir el
último sonido. Este botón permite acceder al vídeo con la explicación del
experimento en cualquier momento. Este vídeo es el mismo que se
reproducirá cuando el usuario le pida al chatbot por voz que le explique
el proyecto, sin embargo, este botón ofrece un acceso más intuitivo en el
contexto de las aplicaciones web, en caso de que el usuario esté
realmente confundido.
x Avatar del chatbot: se encuentra en la parte central izquierda de la
interfaz. Se trata de un dibujo con animación que represente al chatbot
con el que hablará el usuario. El objetivo de este avatar es poder servir
de imagen o “rostro” para el chatbot, para que la interacción con el
usuario resulte más natural y similar a una conversación entre dos
personas.
x Pegatinas: se encuentran distribuidas por la interfaz. Se tratan de
imágenes o dibujos con animaciones que sirven para decorar la
aplicación. Estas pegatinas serán premios que conseguirán los usuarios
cada vez que realicen una cantidad determinada de clasificaciones, de
modo que cada vez la interfaz tendrá más imágenes o pegatinas
decorativas. Son elementos de gamificación que servirán como
recompensa y para motivar a los niños a seguir clasificando sonidos.
x Animaciones: se encuentran distribuidas por la interfaz. Se tratan de
imágenes o dibujos con animaciones que sirven para decorar la
aplicación. En este caso no es necesario que los usuarios realicen
clasificaciones para ganarlas, estas animaciones estarán siempre en la
interfaz para crear una interfaz dinámica y atractiva para los niños a
través de formas y colores que recuerden a elementos del espacio.

Como se ha recogido en los puntos anteriores, la mayoría de los elementos que

componen la interfaz tienen como objetivo aportar información o
retroalimentación de la interacción con el chatbot, mejorar la accesibilidad o
incrementar la motivación de los usuarios.
Puesto que la aplicación debe tener un diseño responsive, además de la versión
de la Figura 54 para ordenadores, también se plantean versiones para tabletas
(ver Figura 55) y teléfonos móviles (ver Figura 56). En el caso de la vista en
tabletas, lo único que cambiaría sería la distancia y tamaño de los elementos de
la interfaz, sin embargo, en la vista en móvil se eliminaría la caja de
transcripción y se reubicarían las pegatinas. El motivo por el que se eliminaría
la caja de transcripción es fundamentalmente que el texto no se podría
visualizar correctamente dado el limitado espacio. Si se mantuviese esta caja,
se solaparía con otros elementos y se recargaría excesivamente la pantalla, lo

81
que dificultaría la correcta visualización de los distintos componentes. La
redistribución de pegatinas, por otro lado, ayudaría a crear mayor orden en el
pequeño espacio del que se dispone y evitaría posibles solapes también entre
varias pegatinas. En general, el objetivo de los cambios es que la interfaz siga
siendo clara e intuitiva y no abrume al usuario.

Figura 55. Diseño de bajo nivel de la interfaz web para tablet

Figura 56. Diseño de bajo nivel de la interfaz web para móvil

82
3.4.2 Implementación de la primera versión de la interfaz web de la
aplicación

Partiendo del diseño a bajo nivel de la interfaz de la aplicación, a continuación

se crea el proyecto en Angular en el que se implementará. Para ello, primero es
necesario crear el entorno de trabajo en el que se trabajará, en este caso la
aplicación web se desarrollará en una máquina Windows siguiendo los pasos
que se muestran seguidamente.
x Instalar la interfaz de línea de comandos (CLI) de Angular:
npm install -g @angular/cli

x Crear el espacio de trabajo y la aplicación Angular:

ng new sdc-chatbot-ui

x Acceder a la carpeta de la aplicación:

cd sdc-chatbot-ui

x Arrancar la aplicación web:

ng serve --open

En este punto la aplicación se encuentra creada y arrancada, por lo que se

puede visualizar su contenido más reciente en la dirección localhost:4200. A
partir de este momento, se va modificando el código HTML y CSS para crear el
diseño descrito en la sección anterior. Para este paso sólo es necesario modificar
los ficheros app.component.html, en el que se encuentra el código HTML del
componente principal de la aplicación, app.component.css, en el que se
encuentra el código CSS del componente principal de la aplicación y
app.component.ts, en el que se incluye el código TypeScript del componente
principal de la aplicación. Además de esto, en la carpeta /assets/img se
incluyen los recursos gráficos que se emplearán como las animaciones y
pegatinas.

Figura 57. Código HTML y estructura inicial de la aplicación.

83
El resultado de esta implementación es el que se muestra en la Figura 58.

Figura 58. Interfaz de la aplicación (versión escritorio)

3.4.3 Creación de Servicios de Reconocimiento y Síntesis de Voz

para la web

Tras haber creado una primera versión de la página web, con sus principales
elementos gráficos, el siguiente paso consiste en la implementación de los
servicios que permitirán a los usuarios interactuar con la aplicación.
En este caso, se implementan primero los servicios de reconocimiento y síntesis
de voz para comprobar si se recupera correctamente la entrada por voz y si el
sistema es capaz de repetir esta entrada con la voz sintetizada.
Para ello, se crean dos servicios distintos dentro del directorio services con los
comandos específicos de Angular:
x Creación del servicio para el reconocimiento de voz:
ng generate service services/voice-recognition

x Creación del servicio para la síntesis de voz:

ng generate service services/speech-synthesis

Tras la ejecución de estos comandos, se generan dos ficheros para cada servicio,
uno con la extensión .service.spec.ts y otro con la extensión .service.ts. En este
caso se utilizarán sólo los ficheros .service.ts en los que se deberá incluir la
implementación de cada servicio.
En primer lugar se implementa el servicio de reconocimiento de voz, que
permitirá transcribir la entrada por voz que reciba la aplicación. Para ello, se
crea una instancia de webkitSpeechRecognition, de la Web Speech API, que
cuenta con varios atributos modificables como el idioma. Dentro de la
inicialización del servicio además de configurar estos atributos se crean también
varios listeners que se activarán al recibir eventos del tipo result y end,
respectivamente. El listener result permitirá actualizar la variable en la que se
84
almacenarán las detecciones de habla más recientes, mientras que el listener
end permitirá detener el servicio de reconocimiento para que no se solapen
varias detecciones y se puedan llevar a cabo turnos de palabra naturales.

Figura 59. Servicio de reconocimiento de voz (listeners)

También como parte de este servicio se crean las siguientes funciones:

x setIsStoppedSpeechRecognition(value): cambia el valor de la variable
isStoppedSpeechRecognition que indica si el servicio de reconocimiento
de voz está parado o no.
x start(): activa el servicio de reconocimiento y actualiza el valor de
isStoppedSpeechRecognition.
x stop(): detiene el servicio de reconocimiento y actualiza el valor de
isStoppedSpeechRecognition.
x getStatus(): devuelve el valor de la variable isStoppedSpeechRecognition
que indica si el servicio de reconocimiento de voz está parado o no.

85
 Figura 60. Servicio de reconocimiento de voz (funciones)

En segundo lugar se implementa el servicio de síntesis de voz, que permitirá

emitir las respuestas de la aplicación a través de una voz sintetizada (ver Figura
61). En este caso se crea una variable synth a partir del componente del
speechSynthesis del propio navegador, lo que nos permitirá utilizar las voces
que este tenga disponibles. Para utilizar estas voces, se crea una función speak
que contendrá la creación y uso de la instancia de SpeechSynthesisUtterance
que recibe el mensaje que se va a emitir. A partir de esta instancia se modifican
los atributos de la voz, pitch (tono de voz) y rate (velocidad), y se ejecuta su
función speak, que activará la síntesis. La función speak que encapsula este
código devuelve una promesa que se resuelve cuando se ha terminado de
sintetizar, es decir, en el onend de la instancia creada; de este modo, no se podrá
seguir con la conversación hasta que la aplicación ha terminado de hablar, y se
evitará solapes entre los turnos de palabra del usuario y el sistema.

Figura 61. Servicio de síntesis de voz

86
Por políticas de seguridad, para que este último servicio funcione correctamente,
es necesario que el usuario haya realizado con anterioridad un gesto en la
aplicación, por lo que se implementa también un componente seleccionable que
sea el que arranque la aplicación. Tal y como se muestra en la Figura 62 este
componente aparece sobre la interfaz ya mostrada, y es necesario que se haga
clic sobre él para que se inicien los servicios de reconocimiento y síntesis. Una
vez el usuario hace este gesto, el componente desaparece y la aplicación
comienza a funcionar normalmente, permitiendo que se reconozca la voz del
usuario y se sintetice la respuesta del chatbot.

Figura 62. Gesto de inicio de la aplicación (versión escritorio)

Estos servicios se manejarán desde el componente principal de la aplicación, en

el que se crearán las funciones necesarias para manejar todos los servicios y
elementos de la web. En esta fase de desarrollo, las pruebas realizadas
consistían en mostrar el texto reconocido en la caja de transcripción y
reproducir este mismo texto con un botón temporal que activaba la
reproducción.

3.4.4 Creación del Servicio de Procesamiento de Lenguaje para la

Web

A continuación se crea el servicio para el procesamiento de la conversación en

lenguaje natural que invoca a la API de Rasa. Para crear este servicio, como en
el apartado anterior, se utiliza el comando específico de Angular y
posteriormente se procede a la implementación.
x Creación del servicio de comunicación con el chatbot:
ng generate service services/nlp-agent
Este comando creará el fichero nlp-agent.service.ts que será modificado para
incorporar dos funciones:
x createUUID(): esta función crea un identificador único universal gracias
al paquete de Angular uuid. Este identificador se crea al iniciarse la

87
 aplicación y se almacena en el servicio de manera que se envía en cada
llamada POST, de este modo permite que la API de Rasa pueda manejar
múltiples usuarios de forma concurrente sin mezclar flujos de
conversación.
x sendToBot(msg): realiza una llamada POST a la API de Rasa. En el
cuerpo de la petición se incluye el identificador único universal como
atributo sender y el mensaje que se ha recibido como parámetro de
entrada como atributo message. Esta función devuelve la respuesta de
la llamada POST.

La implementación de estas funciones se puede ver en la Figura 63. Como en el

caso de los servicios de reconocimiento y síntesis de voz, este servicio se crea en
el componente principal de la aplicación, desde donde se invocará cada vez que
se detecte una nueva entrada por voz.

Figura 63. Servicio de conexión con el chatbot Rasa

Para poner a prueba este servicio, se crea la función que gestionará el flujo de
la conversación en la aplicación (ver Figura 64). Esta función se encuentra en
el fichero app.component.ts, y hace uso de todos los servicios creados y algunas
funciones auxiliares que se explican a continuación. Cada vez que se detecta
una nueva entrada de voz, se llama a esta función principal processInput y se
pasa como parámetro el texto con la transcripción de esta esta entrada. Esta
función utiliza el servicio que conecta con el chatbot para realizar una llamada
POST con este nuevo mensaje, y una vez obtiene una respuesta del servicio,
ejecuta distintas acciones en función del contenido del cuerpo de la respuesta.
Si esta respuesta solo incluye texto, se utiliza el servicio de síntesis de voz para
transmitir el mensaje; si incluye además el sonido de un meteoro (su URL),
también se reproduce el sonido; si incluye un activador de nueva clasificación,
se incrementa el contador de clasificaciones; y si incluye un activador de vídeo,
se reproduce el vídeo tutorial de la aplicación. Además de esto, una vez se
realizan las acciones pertinentes para producir la respuesta del chatbot, vuelve
a activar el servicio de reconocimiento de voz, que se desactiva automáticamente

88
cada vez que se detecta una entrada nueva para evitar solapes en el flujo de la
conversación.

Figura 64. Función processInput(recognition)

Las funciones que se incluyen en este mismo fichero, y que guardan una
estrecha relación con esta función principal son las siguientes:
x accessApp(): es la función a la que se llama al hacer clic en el
componente de inicio. En esta función se encuentra la suscripción a los
cambios del servicio de reconocimiento, de esta forma, cuando se detecta
una nueva entrada de voz, se llama a la función processInput.
x startVoiceRecognition(): función auxiliar que llama a la función start
del servicio de reconocimiento de voz para activarlo.
x stopVoiceRecognition(): función auxiliar que llama a la función stop del
servicio de reconocimiento de voz para desactivarlo.
x speak(message): esta función recibe como parámetro de entrada el
mensaje que se quiere emitir con voz sintetizada. La función llama a la
función speak del servicio de síntesis de voz pasándole el mensaje que se
quiere transmitir.
x playSound(url): esta función recibe como parámetro de entrada la URL
del sonido de meteoro que se quiere reproducir. La función devuelve una
promesa que se resuelve cuando se ha terminado de reproducir el sonido,
de esta manera se evita el solape del audio con la síntesis de voz o con la
escucha de un nuevo mensaje de usuario.
x playVideo(): esta función llama a la función auxiliar reproduceVideo, que
devuelve una promesa y se resuelve cuando el vídeo se ha terminado de
reproducir. Una vez se resuelve esta promesa, la función playVideo
desactiva u oculta el componente en el que se visualiza el vídeo.
x reproduceVideo(): esta función hace visible el componente en el que se
reproducirá el vídeo y una vez está visible reproduce dicho vídeo. Cuando
termina la reproducción se resuelve la promesa que devuelve esta función.
x stopVideo(): desactiva el componente en el que se reproduce el vídeo
tutorial. Esta función se ejecuta al pulsar la cruz que se encuentra en el
componente donde se reproduce el vídeo.

89
 x playLastMeteorSound(): permite reproducir el sonido que se está
clasificando pulsando uno de los botones de la interfaz. El sonido se
almacena cuando se recibe un nuevo sonido en la función processInput
de modo que esta función puede volver a reproducirlo en cualquier
momento.
Todas estas funciones, junto con los servicios creados, permiten manejar la
conversación con el chatbot desde la interfaz web, por lo que en esta fase de
desarrollo la aplicación ya sería funcional.
Cabe añadir también, que además de las funciones, tal y como se menciona en
los puntos anteriores, también fue necesario incorporar un nuevo componente
para reproducir el vídeo tutorial que se activa desde la propia conversación con
el chatbot de Rasa cuando el usuario pide una explicación (ver Figura 65). En
este vídeo se explica en qué consiste el proyecto y, en concreto, qué hay que
hacer en la aplicación.

Figura 65. Vídeo tutorial en la interfaz de usuario (versión escritorio)

El vídeo, de creación propia, fue generado a partir de una presentación en la

plataforma Canva y un audio de voz sintetizada que lee el siguiente guion:
“Bienvenido a Sonidos del Cielo. El objetivo de Sonidos del cielo es clasificar
los meteoros a partir de los datos recogidos por las distintas estaciones que
participan en el proyecto. Estos datos han sido transformados en sonidos,
¡por lo que podrás escuchar cómo suena un meteoro! Una vez escuches un
sonido, te haremos tres preguntas. En cualquier momento, para volver a
escuchar el sonido, puedes utilizar el segundo botón que hay a la derecha de
la aplicación. La primera pregunta de la clasificación pretende enseñarte a
diferenciar los distintos tipos de estelas. Cuando vayas a clasificar un evento
debes prestar mucha atención a su duración. Este sonido es corto
<reproducción del sonido corto de ejemplo>. Este sonido es mediano
<reproducción del sonido mediano de ejemplo>. Y este sonido es largo
<reproducción del sonido largo de ejemplo>.
Las preguntas que verás después de clasificar el tipo de eco de la estela van
dirigidas a encontrar ecos de meteoroide. En los ecos de meteoroide se
escucha un sonido corto al principio y después el volumen disminuye. A

90
 continuación, se escucha el sonido producido por el eco de la estela durante
unos segundos.
En la segunda pregunta tendrás que fijarte si al principio hay un sonido corto
y luego un silencio <reproducción del sonido con Doppler de ejemplo> ¿Lo
has notado?
Por último, en la tercera pregunta tendrás que fijarte en si suena igual al
principio y al final, ya que el eco del meteoroide tiene un tono más grave o
más agudo que el sonido de la estela <reproducción del sonido con Doppler
de ejemplo> ¿Te has fijado?
¡Ya estás listo para jugar a Sonidos del Cielo! Gracias por ayudarnos a
clasificar meteoros, esperamos que lo pases bien.”

3.4.5 Comprobación y Corrección de la Interfaz Web para el Diseño

Responsive

Una vez se dispone de una versión funcional de la aplicación, el siguiente paso

consiste en revisar el diseño de la aplicación para que sea posible utilizarla
desde todo tipo de dispositivos, independientemente del tamaño de su pantalla.
Puesto que uno de los puntos en la agenda del proyecto Sonidos del Cielo es la
realización de talleres divulgativos en el Aula de Astronomía con tabletas, se
presta especial atención al resultado en dispositivos de este tipo. A continuación
se muestra en la Figura 66 la vista de la interfaz en el Inspector de Google
Chrome para el dispositivo Google Nexus 10, una tableta de 10 pulgadas
(800x1280).

Figura 66. Gesto de inicio de la aplicación (versión tableta)

91
 Figura 67. Interfaz de la aplicación (versión tableta)

Figura 68. Vídeo tutorial en la interfaz de usuario (versión tableta)

En este caso no fue necesario aplicar cambios en el código HTML o en la hoja

de estilos, ya que el resultado era similar al de la visualización desde un
dispositivo de escritorio, no obstante, para la versión de móvil sí fue necesario
modificar la hoja de estilos SCSS.

92
En concreto, para la versión móvil fue necesario añadir una Media Query
especificando una anchura mínima de la pantalla de 768 píxeles. En este caso
se optó por hacer que los valores por defecto fuesen los correspondientes a
dispositivos móvil ya que es el dispositivo que más personas tienen disponible
a lo largo del día. Por tanto, dentro de la Media Query se incluyó únicamente la
modificación de tamaños o posiciones de diversos elementos para mejorar su
visualización en dispositivos grandes como tabletas o equipos de escritorio.
Además, dado el tamaño reducido de estos dispositivos, se decidió también no
mostrar el elemento de barra de transcripción, puesto que dificultaría la visión
del resto de componentes y no permitiría una correcta legibilidad. Para realizar
pruebas se utilizó de nuevo el Inspector de Google Chrome seleccionando esta
vez como dispositivo el móvil Pixel 2 de 5 pulgadas (411x731).

Figura 69. Gesto de inicio de la aplicación (versión móvil)

93
 Figura 70. Interfaz de la aplicación (versión móvil)

Figura 71. Vídeo tutorial en la interfaz de usuario (versión móvil)

94
3.4.6 Elementos de Gamificación en la Aplicación

Como se ha podido ver en los apartados anteriores, la interfaz contiene algunos

elementos que gamifican este experimento de Ciencia Ciudadana. Además de
presentar una interfaz interactiva por voz, y animaciones atractivas, la
aplicación incluye también un contador de clasificaciones y un sistema de
recompensas, de manera que cuando se completa un número concreto de
clasificaciones, se activa una pegatina nueva que decora la interfaz de la
aplicación.
El elemento principal para este sistema de recompensas es el contador, que se
encuentra ubicado en la parte superior derecha de la pantalla, siguiendo el
formato habitual de videojuegos tradicionales y modernos, que utilizan esta área
para mostrar indicadores de tiempo, puntos o vidas. Este contador indica el
número de clasificaciones que el usuario ha completado, valor que se almacena
en la variable classificationCount del componente principal de la aplicación, y
que se actualiza cada vez que se recibe un mensaje clasification del chatbot.
Cada vez que se inicia la aplicación, el contador tiene un valor de 0, y cada vez
que se completa una clasificación, su valor se incrementa en 1 desde la función
processInput.

Figura 72. Contador de clasificaciones

Cuando el contador alcanza el valor 1, 5, 10, 15 y 20, la aplicación recompensa

al usuario con el siguiente elemento de gamificación: las pegatinas. Si se logran
realizar estas clasificaciones, la aplicación informa al usuario de que ha recibido
una nueva pegatina, y esta aparece en la interfaz para decorar el espacio. Las
pegatinas son dibujos con animaciones que aparecen automáticamente en la
pantalla, tal y como se muestra en las Figuras 73, 74 y 75.

Figura 73. Interfaz con recompensas (versión escritorio)

95
Figura 74. Interfaz con recompensas (versión tableta)

Figura 75. Interfaz con recompensas (versión móvil)

96
Gracias a la capacidad de Angular para mostrar u ocultar elementos div de la
aplicación de manera condicional, estas pegatinas aparecen en la interfaz de
manera inmediata cuando el contador alcanza uno de los valores ya
mencionados. Las correspondencias entre valores del contador y pegatinas son
las que se recogen a continuación:
x 1 clasificación: Luna
x 5 clasificaciones: Marte
x 10 clasificaciones: Júpiter
x 15 clasificaciones: Neptuno
x 20 clasificaciones: estrella

3.4.7 Pruebas de funcionamiento básico de la aplicación y

correcciones

Tras añadir en la fase anterior los elementos y funcionalidades relacionadas con

la gamificación de la aplicación, se obtiene una primera versión estable y
completa del proyecto. Sin embargo, para asegurar que la aplicación está lista
para su despliegue, en este siguiente paso se revisa por completo la siguiente
lista de comprobaciones.

x Correcto funcionamiento del indicador de micrófono (on/off): cuando el

usuario tiene que hablar el indicador se muestra en blanco y con una
animación de pulso, y cuando el chatbot está hablando el indicador
cambia a gris y deja de tener la animación de pulso.
x Correcto funcionamiento del botón repetir sonido: se reproduce el último
sonido recibido para su clasificación en cualquier momento. Si aún no se
ha comenzado la clasificación, no ocurre nada.
x Correcto funcionamiento del botón para reproducir el vídeo tutorial: se
abre el componente de vídeo cuando se hace clic en el botón con símbolo
interrogante en cualquier momento de la conversación.
x Correcto funcionamiento del botón cerrar del vídeo tutorial: el
componente del vídeo deja de visualizarse en la interfaz.
x Correcto funcionamiento del contador al completar clasificaciones: se
incrementa su valor en 1 cada vez que se responde a la última pregunta
de clasificación de un sonido.
x Correcto funcionamiento de las pegatinas: aparecen cuando se completa
el número de clasificaciones que se había establecido para cada una de
ellas.
x Correcto funcionamiento de las historias implementadas en el chatbot:
comprobar que se recibe la respuesta esperada cuando se utilizan los
intents que deberían activar las distintas historias (saludo, explicación,
clasificación, sobre el proyecto, qué es un meteoro, qué hay que hacer o
despedida), o cuando se responde con distintos valores a las preguntas
de clasificación.

97
3.5 Despliegue

Como requisito para el despliegue de la aplicación se pedía emplear

contenedores Docker para ejecutarlos en el servidor localizado en la Escuela
Técnica Superior de Ingeniería y Diseño Industrial (ETSIDI), por lo que a
continuación se explica cómo se ha hecho uso de esta tecnología para llevar a
cabo el despliegue completo del proyecto.
Docker es un proyecto de código abierto muy popular hoy en día ya que permite
automatizar el despliegue de aplicaciones dentro de contenedores software. Esta
tecnología permite usar dichos contenedores como máquinas virtuales ligeras y
modulares, lo que hace que resulte fácil crearlos, copiarlos, y moverlos a
distintos entornos.
En este caso, la aplicación está compuesta por un chatbot Rasa (con su servidor
Core y su servidor SDK) y una aplicación Angular, por lo que se tendrán que
crear múltiples contenedores con sus respectivas configuraciones.
Para el despliegue del chatbot se utiliza Compose, la herramienta de Docker
para definir y ejecutar aplicaciones de Docker de varios contenedores, ya que
como se ha visto anteriormente será necesario crear un contenedor para el core
de Rasa y otro para su SDK. Compose utiliza un archivo YAML llamado docker-
compose.yml en el que se definen los servicios que componen la aplicación para
que puedan ejecutarse juntos en un entorno aislado, de modo que para
desplegar el chatbot se crea, en la raíz del proyecto Rasa, el fichero docker-
compose.yml que se muestra en la Figura 76. En este fichero se listan los dos
servicios (rasa y action-server) con sus puertos habituales, 5005 para el servicio
Rasa principal y 5055 para el servidor de acciones, el nombre de sus imágenes
y sus volúmenes. Además, en el caso del servicio principal se añaden también
los comandos que se encontraban en la orden manual para arrancar el servicio:
rasa run -m models –enable-api –cors “*”.

Figura 76. Fichero docker-compose.yml para el despliegue del chatbot Rasa

98
Tras crear este fichero docker-compose en la raíz del proyecto, se guardan los
cambios y se suben al sistema de control de versiones que se ha empleado
durante el desarrollo, en este caso Github. Ya que en el servidor se dispone de
este sistema de control de versiones, se accede directamente al servidor y se
clona el repositorio de Rasa recientemente actualizado. Una vez clonado el
repositorio en el servidor, simplemente se ejecuta el comando que se muestra a
continuación.
x Inicia y ejecuta toda la aplicación:
docker-compose up -d
Puesto que la aplicación web no requiere de múltiples contenedores, para su
despliegue no se utiliza Compose, y no es necesario por tanto crear un nuevo
fichero docker-compose.yml. En el caso de la aplicación Angular el despliegue se
realiza mediante el fichero Dockerfile, un archivo de texto simple que contiene
los comandos que un usuario utiliza para ensamblar una imagen.

Figura 77. Fichero Dockerfile para el despliegue de la aplicación web

En este caso también se guardan los cambios y se suben a Github para tener
en el repositorio la versión más reciente con el fichero Dockerfile, tras ello, se
clona el proyecto en el servidor. Una vez se haya clonado el proyecto en el
servidor se ejecutan varios comandos:
x Crea la imagen del contenedor:
docker build -t angular-app .

x Arranca la aplicación a partir de la imagen creada:

docker run -dp 4200:4200 angular-app

Tras realizar estos pasos, la aplicación completa se encuentra desplegada en el

servidor de la ETSIDI, tal y como se requería.

99
3.6 Diseño e implementación de mejoras

Una vez desplegada la aplicación en el servidor de la ETSIDI, se realizaron

distintas pruebas con usuarios en las que se detectaron algunas posibles
oportunidades de mejora.

En primer lugar, se detectó que resultaba poco intuitivo que, al comenzar el

juego, el usuario tuviese que ser el primero en hablar, por lo que se planteó que
fuese el chatbot el que diese la bienvenida al usuario cuando pulsase el botón
de inicio. En segundo lugar, debido a los retrasos aleatorios detectados en la
API de síntesis de voz, a veces los niños no sabían qué tenían que hacer o si la
aplicación estaba funcionando correctamente, por lo que se decidió incluir un
indicador muy visual de qué tiene que hacer el niño en cada caso (hablar o
escuchar).

Para poder aplicar las mejoras, se modifica en primer lugar el componente

principal de la aplicación web, concretamente la función accessApp que se
ejecuta cuando el usuario hace clic en el componente para empezar a usar la
aplicación. En esta función ahora se desactiva el servicio de reconocimiento de
voz y se envía un mensaje “hola” al chatbot simulando el saludo del usuario, de
forma que, una vez desaparece el componente de inicio, se reproduce la
respuesta del chatbot a este mensaje falseado, es decir, el saludo y bienvenida
a la aplicación. Con este cambio, el usuario puede intuir que para utilizar la
aplicación debe contestar por voz al chatbot con alguna de las opciones que este
le ha proporcionado (jugar o recibir explicación), por lo que se evita un comienzo
confuso.

El siguiente cambio consiste en incorporar un indicador visible y llamativo que

muestre al usuario qué debe hacer en cada momento, hablar o escuchar. Para
ello se opta por mostrar dos iconos distintos: una persona hablando y una oreja.
Dado que la interfaz ya cuenta con numerosos elementos gráficos, para que este
indicador sea visible, se coloca en la parte inferior de la interfaz (zona más
despejada) con una animación de pulso. Este indicador alterna los iconos de
hablar y escuchar de acuerdo con el estado de la variable
isStoppedSpeechRecognition de manera que cuando el servicio de
reconocimiento esté parado porque el chatbot está hablando se muestre el icono
de la oreja, y cuando no esté parado porque se espera la respuesta del usuario
se muestre el de la persona hablando. El resultado es el que se muestra en la
Figura 78, 79 y 80.

Figura 78. Interfaz de la aplicación con mejoras (versión escritorio)

100
Figura 79. Interfaz de la aplicación con mejoras (versión tableta)

Figura 80. Interfaz de la aplicación con mejoras (versión móvil)

101
4 Resultados y conclusiones

4.1 Resultados

El resultado de este Trabajo Fin de Grado es la primera versión completa y

funcional de la aplicación para la clasificación de meteoros a través de sonidos,
destinada al público infantil, del proyecto de Ciencia Ciudadana Sonidos del
Cielo. En concreto, esta aplicación incluye, como se ha ido explicando a lo largo
de esta memoria, dos proyectos o componentes bien distinguidos: el chatbot o
agente inteligente que gestionará el flujo de la conversación para clasificar
meteoros a través del lenguaje natural y la aplicación web desde donde se
accede al experimento.
El primero de los componentes que forman este trabajo es el chatbot,
desarrollado con el framework Rasa. Este agente es el encargado de manejar la
conversación en lenguaje natural para la clasificación de meteoros, ya que es
capaz de entender frases sencillas (propias de niños) relacionadas con el
experimento, además de contestar de manera muy clara a las peticiones o
comentarios de los jóvenes. En particular, este chatbot es capaz de explicar en
qué consiste el proyecto, de guiar la clasificación de meteoros, de responder
preguntas como “¿qué hay que hacer?”, “¿qué es Sonidos del Cielo?” o “¿qué es
un meteoro?” y también de saludar, despedirse o de pedir al usuario que
reformule una frase si no la ha entendido con certeza la primera vez.
En este proyecto, el chatbot se ha empleado como una API a la que se accede a
través de llamadas POST con un identificador de usuario y un mensaje desde
la aplicación web, sin embargo, es posible utilizar el chatbot de manera
totalmente independiente a la web de este proyecto, desde otras páginas web o
desde otras aplicaciones utilizando los canales preconfigurados que ofrece Rasa.
Esta versatilidad de integración hace que el componente sea totalmente
independiente y reutilizable desde distintos canales, por ejemplo, desde
plataformas de mensajería instantánea, en la web oficial del proyecto o en otras
páginas web.
El segundo de los componentes de este proyecto es la aplicación web desde la
que se accede al chatbot. Esta aplicación ha sido especialmente pensada para
un público infantil, y para gestionar el flujo de conversación del chatbot
previamente implementado. Incluye distintos elementos de gamificación
(contador y sistema de recompensas), animaciones, botones de apoyo que
mejoran la usabilidad, y servicios de reconocimiento y síntesis de voz que
permiten hablar con el chatbot a través de lenguaje natural oral. En definitiva,
esta web constituye la aplicación completa del Trabajo Fin de Grado, ya que en
ella se integran tanto el chatbot, como los sistemas necesarios para
comunicarse con el de forma oral, y permite a los usuarios participar en el
experimento de Ciencia Ciudadana propuesto en Sonidos del Cielo.
Para facilitar el uso de esta aplicación, además del código, la documentación de
los correspondientes repositorios, y de esta memoria, se ha creado una Guía de
Usuario donde se explican, de forma resumida y visual, las características de la
aplicación. Esta guía se presenta en un archivo PDF de dos páginas con toda la
información necesaria para utilizar la aplicación, tal y como se muestra más
abajo en la Figura 81.

102
 Figura 81. Guía de usuario de la aplicación para público infantil

Como se puede ver en la Figura 81, se incluyen siete apartados con la siguiente
información:
x Descripción general:
El chatbot para público infantil de Sonidos del Cielo pretende fomentar
la partición del público más joven en el experimento de ciencia ciudadana
para la clasificación de meteoros a través de sus sonidos.

Los sonidos que se presentan para la clasificación han sido generados

sintéticamente a partir de los datos obtenidos por las estaciones de
radiodetección empleadas en el proyecto.

El chatbot reproducirá un sonido cada vez y a continuación realizará tres

preguntas relacionadas con el sonido reproducido. De este modo, cada
vez que el niño conteste se guardará su respuesta para contribuir a la
clasificación de dicho meteoro.

x Compatibilidad:
Puesto que la aplicación hace uso de un servicio de Google a través del
navegador para poder reconocer y sintetizar la voz, se deberá acceder a
la aplicación desde los siguientes navegadores:

- Chrome escritorio (versión a partir de 33)

- Chrome Android (versión a partir de 33)

x Interfaz:

103
x Empezar a jugar:
Una vez se pulse el botón de Inicio ("Pulsa para comenzar") se puede
comenzar a hablar con el chatbot. El chatbot no responderá si no se ha
pulsado el botón anteriormente.

La forma lógica de empezar a jugar sería saludar (por ejemplo, decir

"¡Hola!") y el chatbot te dará la bienvenida al juego y te dará varias
opciones para continuar: escuchar la explicación o empezar a jugar.

El chatbot irá guiando la conversación, pero se pueden hacer preguntas

en cualquier momento y utilizar también los botones de la pantalla para
repetir un sonido o ver el vídeo explicativo.

x Qué se puede contestar:

Además de conocer el diálogo propio de la clasificación, el chatbot sabe
responder a algunas preguntas relacionadas con el proyecto. El niño
podrá hacer preguntas como:
- ¿Qué es Sonidos del Cielo?
- ¿Qué hay que hacer?
- ¿Qué es un meteoro?
- ¿Cómo se juega? / Explícame el juego
No es necesario que estas preguntas se formulen exactamente como en
estos ejemplos, el chatbot podrá entender también algunas variantes y

104
 expresiones similares. Si el chatbot no entiende alguna expresión, pedirá
que se reformule la última frase.

Además de esto, el niño podrá saludar o despedirse del chatbot en

cualquier momento y el chatbot le responderá.

x Clasificación:
Tras reproducir un sonido de meteoro, el chatbot realizará tres preguntas
para clasificar dicho meteoro. Las preguntas son las mismas para cada
sonido:
1. ¿Cómo es el sonido? ¿Es corto, medio o largo?
2. ¿Se escucha al principio un sonido corto y luego un silencio?
3. ¿Suena igual al principio y al final?

Se espera que las respuestas a estas preguntas sean del tipo:

1. Es corto / Es mediano / Es largo
2. Sí / No
3. Sí / No

El chatbot será capaz de entender también variaciones de estas

respuestas.

x Recompensas:
Cuando se completen 1, 5, 10, 15 y 20 clasificaciones, el chatbot añadirá
una nueva pegatina animada al espacio de Sonidos del Cielo como
recompensa.

Estas pegatinas decorarán la pantalla y se podrán ver durante la sesión

en la que se han conseguido.

x Entidades colaboradoras:

105
Puesto que todo el material presentado se ha preparado con suficiente
antelación, la aplicación se está utilizando desde abril en el Aula de Astronomía
de Fuenlabrada con grupos de niños, tal y como se había previsto en la
propuesta del proyecto. Con el fin de conocer las opiniones de los niños sobre
esta aplicación, el grupo de Sonidos del Cielo ha creado un formulario (Valora
nuestro chatbot) en el que se recoge información acerca del curso escolar en el
que se encuentran los niños, las impresiones sobre la dificultad del experimento,
cómo de divertida resulta la aplicación y también sobre la voluntad de los niños
de volver a utilizar la aplicación desde sus casas.

Figura 82. Fotografía del taller de Sonidos del Cielo en el Aula de Astronomía
de Fuenlabrada (clasificación)

Figura 83. Fotografía del taller de Sonidos del Cielo en el Aula de Astronomía
de Fuenlabrada (taller)

106
Hasta la fecha, los resultados del formulario muestran que la mayoría de los
usuarios que ya han participado en los talleres del Aula de Astronomía se
encuentran en tercero de primaria (47,4% de los niños encuestados), quinto de
primaria (38,6%) o en cuarto de primaria (14%).

Figura 84. Primera pregunta del formulario “Valora nuestro chatbot”

De acuerdo con la opinión de gran parte de estos niños, el experimento resulta

fácil (47,4%) o muy fácil (35,1%), solamente un 3,5% de los niños han
considerado que el experimento es difícil y un 14% que tiene una dificultad
normal.

Figura 85. Segunda pregunta del formulario “Valora nuestro chatbot”

Respecto a cómo de divertida les pareció la aplicación, se encuentra una mayor
variedad de respuestas, aunque casi la mitad de los niños (45,6%) consideraron
que era divertida. En concreto, un 1,8% de los niños pensó que era muy
aburrida, un 7% que era aburrida, un 17,5% consideró que era normal, el 45,6%
pensó que es divertida y un 28,1% que es muy divertida.

107
 Figura 86. Tercera pregunta del formulario “Valora nuestro chatbot”

Finalmente, un 75,4% de los niños respondieron que les gustaría seguir jugando
desde su casa con la aplicación, y solo un 24,6% respondió que no les gustaría
seguir jugando.

Figura 87. Cuarta pregunta del formulario “Valora nuestro chatbot”

Los resultados de este formulario muestran una opinión general positiva sobre
la aplicación desarrollada en este trabajo, por lo que se espera que los niños
puedan disfrutar del experimento de Sonidos del Cielo a través de ella.

4.2 Conclusiones

El Trabajo Fin de Grado Desarrollo de un Chatbot y Aplicación Web para

clasificar Sonidos del Cielo Enfocada a un Público Infantil ha supuesto una
excelente oportunidad para poner en práctica gran parte de los conocimientos
obtenidos a lo largo del grado de Ingeniería Informática, puesto que ha sido

108
necesario crear una aplicación totalmente funcional únicamente a partir de una
serie de especificaciones y objetivos.

De entre todas las materias estudiadas en este grado, este trabajo ha guardado
especial relación con Ingeniería del Software, Interacción Persona-Ordenador,
Inteligencia Artificial, Sistemas Orientados a Servicios, y Diseño de Aplicaciones
Web. Para llevar a cabo este proyecto fue necesario aplicar en gran medida
conocimientos de Ingeniería Software ya que se tuvo que recoger una serie de
requisitos o directrices en distintas reuniones con los colaboradores de Sonidos
del Cielo, establecer un plan de trabajo, realizar un seguimiento del proyecto, y
aplicar una metodología Agile con reuniones semanales, incorporación de
cambios y presentaciones continuas de los incrementos del trabajo. También se
tuvieron que aplicar conocimientos sobre Interacción Persona-Ordenador, ya
que uno de los puntos clave del proyecto es la accesibilidad orientada a sectores
de la población muy concretos y con necesidades particulares, como lo son los
niños o las personas con discapacidad visual. Además, para potenciar al
máximo la accesibilidad de la aplicación se diseñó, implementó e integró un
agente inteligente capaz de manejar la interacción a través en lenguaje natural,
por lo que fue necesario aplicar conocimientos sobre Inteligencia Artificial, en
especial sobre el procesamiento del lenguaje natural y la creación de agentes
inteligentes. Para la creación de este agente, fue también necesario poner en
práctica los conocimientos aprendidos en Sistemas Orientados a Servicios, dado
que en él se hace uso de la API de meteoros, que permite acceder a los datos de
las detecciones y guardar los de las clasificaciones realizadas, y dado que el
propio agente se utiliza como una API desde la web del proyecto. Finalmente,
fue necesario aplicar las nociones aprendidas en Diseño de Aplicaciones Web
para crear una aplicación web que diese soporte a todo el experimento e
integrase todos los servicios de procesamiento del lenguaje.

Desde un punto de vista técnico más general, el proyecto se ha centrado sobre

todo en tecnologías relacionadas con la Inteligencia Artificial y el Desarrollo de
Aplicaciones web, dos áreas de la informática con una gran relevancia hoy en
día, y que se incluyen dentro de lo que se conoce como desarrollo back-end y
desarrollo front-end respectivamente. En este sentido, el trabajo realizado ha
servido para ganar experiencia en un perfil full stack que cubre tanto el
desarrollo de la lógica y comunicación son servidores y bases de datos (en este
caso a través de API REST), como el desarrollo de aplicaciones o interfaces que
serán empleadas directamente por el usuario. Una de las principales ventajas
de este perfil, es que ofrece una visión mucho más general de los sistemas y
ayuda a entender mucho mejor las necesidades y soluciones de un problema
dado, por lo que ha resultado ser una experiencia especialmente enriquecedora
a nivel técnico.

Otro de los aspectos más destacables de este trabajo, además del tecnológico,
es su posible impacto y repercusión a nivel social. Sonidos del Cielo es un
proyecto de Ciencia Ciudadana que pretende hacer la Astronomía más accesible
a los niños y a personas con discapacidad visual, por lo que la motivación social
y divulgativa ha sido un pilar clave en el desarrollo. Personalmente, ha resultado
muy gratificante poder contribuir en un proyecto donde el factor humano ha
sido tan importante, ya el trabajo realizado podrá hacer posible que los más
pequeños se familiaricen con la astronomía y que se despierte en ellos la
curiosidad propia de un científico. Ha sido un privilegio poder trabajar con el
Citiezen Science Lab que promueve estos valores tan importantes de conciencia

109
social y trabaja para que personas de todo tipo puedan acceder a la ciencia y
puedan participar en experimentos junto con auténticos profesionales.

El hecho de haber trabajado con este grupo, con las entidades colaboradoras, y
con otros estudiantes, también ha sido una experiencia muy valiosa ya que el
intercambio de ideas y perspectivas multidisciplinales ha hecho que adquiera
nuevos conocimientos más allá de los que conciernen a la informática. También
ha hecho posible que me familiarice con grupos de trabajo más diversos, que
aprenda a coordinarme con otros compañeros, a ayudarles o a pedirles ayuda,
y que aprenda a trabajar con componentes de un sistema que no haya
desarrollado yo misma, por lo que me ha ayudado a crecer a nivel personal.

Además de todos los aspectos ya mencionados, lo que más me gustaría destacar

de este trabajo ha sido la libertad que se me ha concedido para crear la
aplicación y el gran alcance del trabajo. Esta libertad ha sido también la mayor
dificultad del proyecto, ya que los requisitos no eran muchos y no existían
especificaciones de diseño, lo que ha supuesto inventar desde cero una interfaz
que pudiese resultar atractiva y que a la vez fuese accesible. Además de esto, el
trabajo era considerablemente ambicioso, ya que no solo había que crear el
chatbot sino que además había que crear una aplicación web, e integrar todos
los servicios. Ya que otros alumnos que habían realizado el mismo Trabajo Fin
de Grado no habían logrado completar el desarrollo completo, y solamente
lograban implementar el chatbot o hacer una web muy básica donde integrarlo,
creo que el trabajo realizado ha sido un éxito. Sin embargo, ha requerido una
gran dedicación y esfuerzo.

Como resultado de este trabajo y del trabajo realizado por el resto del equipo de
Sonidos del Cielo, la aplicación para niños de Sonidos del Cielo se pudo lanzar
en abril, por lo que actualmente ya se ha podido utilizar en el Aula de
Astronomía de Fuenlabrada con grupos de niños, tal y como se había previsto.
Además, el 20 de mayo se pudo presentar en el Congreso Internacional de
Ciencia Ciudadana como uno de los nuevos proyectos de Ciencia Ciudadana
que promueven la inclusión, igualdad y accesibilidad.

Con vistas a futuro, puesto que el trabajo forma parte de un proyecto mayor
financiado públicamente, la versión que se ha descrito en esta memoria podrá
ser modificada si es necesario por parte del equipo de desarrollo que continúe
trabajando en Sonidos del Cielo. Además de las mejoras que este equipo
considere necesarias, algunas ideas de trabajo futuro podrían incluir la
traducción de la aplicación web y del chatbot a otros idiomas para poder hacer
accesible el experimento a más personas, o la integración del chatbot en canales
de mensajería instantánea como pudieran ser Facebook Messenger o Telegram,
de modo que el experimento estuviese disponible en distintas plataformas.

Personalmente, estoy muy satisfecha con el trabajo realizado, ya que no

solamente ha sido una buena oportunidad para poner en práctica algunos
conocimientos que he adquirido durante la carrera, sino que además me ha
permitido colaborar en un proyecto que pretende ayudar a los niños a
familiarizarse con la ciencia, y más concretamente con la astronomía. Espero
que este proyecto fomente la creación de nuevas aplicaciones que hagan
accesible la ciencia a la mayor parte de la población y que los usuarios disfruten
de su uso tanto como hemos disfrutado nosotros de su desarrollo.

110
5 Análisis de Impacto
Como ya se ha adelantado en capítulos anteriores, este Trabajo Fin de Grado
forma parte del proyecto Sonidos del Cielo, un proyecto de Ciencia Ciudadana
que pretende hacer accesible la astronomía a niños y personas con discapacidad
visual a través de un proyecto de clasificación de meteoros a partir de sus
sonidos. La intención básica de este proyecto es, por tanto, producir un impacto
positivo a nivel social y cultural, logrando acercar la ciencia a aquellos grupos
de la población que por determinadas limitaciones no cuentan con acceso a
información o a experimentos de esta área.

A pesar de que este es el principal impacto deseado, en este capítulo se realiza

un análisis más detallado del impacto potencial de los resultados de este trabajo
en distintos contextos que se detallan a continuación, atendiendo además a la
relación del potencial impacto con los Objetivos de Desarrollo Sostenible (ODS)
de la Agenda 2030 [83].

5.1 Impacto personal

El impacto personal está relacionado con aprender a usar las habilidades que
ya se tienen. Este proyecto tiene un potencial impacto personal tanto para las
personas que hagan uso de la aplicación creada como para los desarrolladores
y colaboradores que han participado en el proyecto.

Puesto que se trata de un proyecto de Ciencia Ciudadana en el que cualquier

persona puede participar sin necesidad de conocimientos previos específicos,
cualquier usuario puede acceder a las explicaciones relacionadas con el
experimento, y clasificar los sonidos simplemente respondiendo a unas sencillas
preguntas guiadas. Los usuarios, que ya cuentan con la habilidad de escuchar,
aprenderán a utilizar su sentido del oído para identificar características de los
meteoros, como la presencia de ecos o de efecto Doppler, algo que a priori no
resultaría intuitivo.

Los desarrolladores involucrados en el proyecto, además de esto, también

pueden mejorar sus habilidades y conocimientos en materia tecnológica, como
ocurre específicamente en este Trabajo Fin de Grado en el que se han podido
asentar muchas nociones aprendidas durante la carrera.

En este ámbito, no existe un objetivo concreto de la lista de Objetivos de

Desarrollo Sostenible que se alinee con el posible impacto, aunque podría
guardar relación con el Objetivo 4: Garantizar una educación inclusiva,
equitativa y de calidad y promover oportunidades de aprendizaje durante
toda la vida para todos, que se explica más adelante como parte del impacto
cultural.

5.2 Impacto empresarial

En el contexto empresarial no se considera un posible impacto positivo ni

negativo, ya que este se trata de un proyecto en el que únicamente colaboran
111
entidades dedicadas a la investigación, y que en general no tienen ningún tipo
de carácter lucrativo. Si se considera al grupo propulsor de la idea detrás de
Sonidos del Cielo (el Citizen Science Lab) como una empresa, a pesar de que no
lo es, se podría esperar un aumento de prestigio al darse a conocer en nuevos
sectores de la población como agrupaciones para personas con discapacidad
visual o incluso colegios que participen en las jornadas divulgativas. Sin
embargo, en este caso tampoco existiría una correspondencia de estos posibles
impactos en la lista de Objetivos de Desarrollo Sostenible de la Agenda de 2030.

5.3 Impacto social

El potencial impacto social del trabajo está relacionado con la contribución del
proyecto dentro de la Ciencia Ciudadana así como con la especial atención que
se ha dedicado a varios sectores de la población con limitaciones para acceder
a distintos recursos.
Por una parte la Ciencia Ciudadana pretende implicar o involucrar a los
ciudadanos en la investigación científica, sin importar su nivel de formación,
edad, género, raza o cualquier otra característica personal o social. A menudo,
a pesar de que no se pretende discriminar a grupos sociales, no se tienen en
cuenta las necesidades especiales de algunos de ellos, y esto puede suponer
una enorme barrera de acceso a las oportunidades de colaboración. Para evitar
estas diferencias en oportunidades, en este proyecto se ha puesto especial
atención a dos sectores de la población que pueden encontrar obstáculos
cuando se trata de acceder a experimentos de Ciencia Ciudadana: los niños y
las personas con discapacidad visual. Para ello, se ha creado un sistema que
permite la interacción por voz, de manera que los niños que no sepan leer o
escribir, así como las personas con problemas visuales, también puedan
participar sin ser discriminados y sin poner obstáculos a su colaboración.
Este impacto social está vinculado al Objetivo 10: Reducción de las
Desigualdades dentro de la lista de Objetivos de Desarrollo Sostenible. En
concreto, el proyecto se alinea con la meta 10.2 en la que se establece que de
aquí a 2030 se deberá potenciar y promover la inclusión social, económica y
política de todas las personas independientemente de su edad, sexo,
discapacidad, raza, etnia, origen, religión o situación económica u otra
condición.

5.4 Impacto económico

Respecto al potencial impacto económico del proyecto, no se establece ningún

objetivo en concreto a priori, sin embargo, es posible analizar qué impacto que
puede tener en este ámbito.
Sonidos del Cielo ha sido un proyecto financiado por la Fundación Española
para la Ciencia y Tecnología (FECYT), una fundación pública que fomenta la
innovación y desarrollo de la ciencia a través de ayudas económicas. La creación
de aplicaciones como la que se ha desarrollado en este trabajo es posible gracias
a la obtención de presupuestos públicos que permiten la formación de grupos
de desarrollo dedicados a la innovación, por lo que este proyecto pone de
manifiesto la importancia de este tipo de entidades y de la dedicación de una
gran parte de recursos económicos a la investigación e innovación.

112
Esto guarda una estrecha relación con el Objetivo 9 de la lista de Objetivos de
Desarrollo Sostenible, con el que pretende construir infraestructuras
resilientes, promover la industrialización sostenible y fomentar la
innovación, y que en concreto plantea metas como la 9.5 para fomentar la
innovación y aumentar el número de personas que trabajan en investigación y
desarrollo y los gastos de los sectores público y privado en investigación y
desarrollo.
Este proyecto deja ver la necesidad de este incremento de gastos públicos y
privados en innovación que pueda hacer posible crear más aplicaciones de
beneficio público, que ayuden a la sociedad y promuevan la cultura, ya que sin
este tipo de inversión, el proyecto no se habría llevado a cabo de manera exitosa
por falta de recursos.

5.5 Impacto medioambiental

Tal y como se incluye en la memoria técnica del proyecto Sonidos del Cielo, a
través de este proyecto se pretende concienciar a la sociedad de la importancia
de un cielo de calidad, libre de contaminación atmosférica y lumínica. Este y
otros proyectos de las entidades que participan en esta iniciativa ponen de
manifiesto la necesidad de disponer de un cielo libre de contaminación que
facilite el estudio astronómico, así como el disfrute de los aficionados que
realizan observaciones, por lo que con este trabajo se contribuiría a crear una
conciencia ecológica para proteger la calidad del cielo.
En este sentido, el impacto medioambiental del trabajo podría estar vinculado
con el Objetivo 7, que pretende garantizar el acceso a una energía, segura,
sostenible y moderna, el Objetivo 11 para lograr que las ciudades sean más
inclusivas, seguras, resilientes y sostenibles, o el Objetivo 12 para
garantizar modalidades de consumo y producción sostenibles, en el que se
incluye una meta para asegurar que las personas de todo el mundo tengan
información y conocimientos pertinentes para el desarrollo sostenible y los
estilos de vida en armonía con la naturaleza (objetivo 12.8 dentro del Objetivo
12 de ODS).

5.6 Impacto cultural

El potencial impacto cultural de este trabajo está estrechamente ligado al

objetivo principal del proyecto Sonidos del Cielo de hacer accesible la ciencia, y
en especial la astronomía, a niños y niñas de todas las edades (que no
necesariamente sepan leer), así como a personas con discapacidad visual.
Tal y como se explica en el capítulo de Introducción, este se trata de un proyecto
de Ciencia Ciudadana, por lo que con él se pretende implicar activamente al
público general (no especializado) en un experimento científico junto con
profesionales en el área. Para ello, se utilizan numerosas tecnologías que
permiten acceder a este proyecto de manera remota, a través de distintos
dispositivos, y además que ayudan a ofrecer la información necesaria a través
de distintos canales como lo son el auditivo o el visual. Con todo ello, se pretende
facilitar la disponibilidad y acceso a este experimento científico sin olvidar a
colectivos con algunas limitaciones, de modo que se reduzcan las diferencias de
oportunidades culturales en la población.

113
Este potencial impacto está alineado con el Objetivo 4 de la lista de Objetivos
de Desarrollo Sostenible, que pretende garantizar una educación inclusiva,
equitativa y de calidad y promover el aprendizaje durante toda la vida para
todos. En este objetivo se incluyen distintas metas para 2030, y de entre ellas,
este trabajo hace hincapié en promover la construcción y adecuación de
instalaciones educativas que tengan en cuenta las necesidades de los niños y
las personas con discapacidad y las diferencias de género, y que ofrezcan
entornos de aprendizaje seguros, no violentos, inclusivos y eficaces para todos
(meta 4.a del ODS número 4). Un claro ejemplo de cómo Sonidos del Cielo
pretende cumplir con esta meta es la organización de talleres sobre el
experimento en el Aula de Astronomía de Fuenlabrada con tabletas y
auriculares adquiridas con parte del presupuesto del proyecto para que los
niños puedan participar en este proyecto.

114
6 Bibliografía
[1] Comisión Europea. (2020, October 29). Ciencia Ciudadana. [Online].
Available: https://ec.europa.eu/digital-single-market/en/citizen-science.
[Accessed: 29-March-2021]
[2] F. Susana, F. Celina, “Ciencia ciudadana en la Sociedad de la Información:
nuevas tendencias a nivel mundial”, CTS. Ciencia, tecnología y sociedad, vol. 9,
nº27, pp. 11-31, Sept 2014
[3] Instituto Nacional de Estadística. (2020). Porcentaje de menores usuarios de
TIC. 2020. [Online] Available:
https://www.ine.es/jaxi/Datos.htm?path=/t00/mujeres_hombres/tablas_1/l
0/&file=c06002.px#!tabs-tabla. [Accessed: 29-March-2021]
[4] T. Ferran, “¿Qué es la gamificación? en Gamificación: fundamentos y
aplicaciones, 1º Edición, Barcelona, España, Editorial UOC, 2014.
https://books.google.es/books?id=SipNCgAAQBAJ&printsec=frontcover&hl=e
s&source=gbs_ge_summary_r&cad=0#v=onepage&q&f=false
[5] Asociación Española de Videojuegos, “La Industria del Videojuego en
España: Anuario 2019”, España, Madrid. 2019.
[6] Sonidos del Cielo. (2020). El proyecto. [Online]. Available:
http://www.sonidosdelcielo.org/. [Accessed: 29-March-2021]
[7] Citizen Science Lab UPM. (2020). Sky Sounds. [Online]. Available:
https://www.zooniverse.org/projects/cslab-upm/sky-sounds. [Accessed: 29-
March-2021]
[8] Fundéu. (2019, June 13). Chatbot, neologismo válido. [Online]. Available:
https://www.fundeu.es/recomendacion/chatbot-neologismo-valido/.
[Accessed: 30-March-2021]
[9] Grammarist. (2014). Chatbot. [Online]. Available:
https://grammarist.com/new-words/chatbot/. [Accessed: 30-marzo-2021]
[10] N. Joshi. (2018, October 23). Yes, Chatbots And Virtual Assistants Are
Different!. [Online]. Available:
https://www.forbes.com/sites/cognitiveworld/2018/12/23/yes-chatbots-
and-virtual-assistants-are-different/. [Accessed: 30-March-2021]
[11] A. Srikanth. (2020, November 5). Virtual assistants vs Chatbots: What’s the
Difference & How to Choose the Right One?. [Online]. Available:
https://freshdesk.com/customer-engagement/virtual-assistant-chatbot-
blog/#:~:text=Chatbots%20are%20intelligent%20enough%20to,a%20wide%20
range%20of%20requests. [Accessed: 30-March-2021]
[12] A. M. Turing, “Computing Machinery and Intelligence”, Mind, Vol. 59, No.
236, pp. 433-460. October, 1950.
[13] J. Weizenbaum, “ELIZA-A Computer Program for the Study of Natural
Language Communication Between Man and Machine”, Communications of the
ACM, Vol. 9, No. 1, pp. 36-45. January, 1966.
[14] M.L. Mauldin, “ChatterBots, TinyMUDs, and the Turing Test Entering the
Loebner Prize Competition”, Proceedings of the Association for the Advancement
of Artificial Intelligence Conference in Artificial Intelligence 1994, Vol. 1, pp. 16-
21. 1994.

115
[15] K.M. Colby, “Modeling a paranoid mind”, Behavioral and Brain Sciences,
Vol. 4, No. 4, pp. 515-534, December, 1981.
[16] G. Güzeldere, S. Franchi, “Dialogues with colorful personalities of early AI”,
Standford Humanities Review, Vol. 4, No. 2. July, 1995.
[17] R.S. Wallace, “The Anatomy of A.L.I.C.E” in Parsing the Turing Test,
Dordrecht, Springer, pp. 181-210. 2009.
[18] Cleverbot. (2021). About Cleverbot. [Online]. Available:
https://www.cleverbot.com/. [Accessed: 1-April-2021]

[19] Pandorabots. (2021). Pandorabots. [Online]. Available:

https://home.pandorabots.com/home.html. [Accessed: 1-April-2021]

[20] Guiness World Records. (2019, September 15). Most Loebner Prize wins.
[Online]. Available: https://www.guinnessworldrecords.com/world-
records/603076-most-loebner-prize-wins. [Accessed: 01-April-2021]

[21] D. Newnham, Mad Men of Mobile: Leading Entrepreneurs and Innovators

Share Their Stories, from SIRI to SHAZAM, CreateSpace Independent Publishing
Platform, 2013.

[22] Apple. (2021). Siri. [Online]. Available: https://www.apple.com/es/siri/.

[Accessed: 1-April-2021]

[23] D. Ferrucci, “Building Watson: An Overview of the DeepQA Project”, AIMag,

vol. 31, no. 3, pp. 59-79, July, 2010.

[24] R. High, “The Era of Cognitive Systems: An Inside Look at IBM Watson and
How it Works”, IBM Redbooks, IBM, U.S.A, 2012.

[25] Microsoft. (2014, April 17). Anticipating More from Cortana. [Online].
Available: https://www.microsoft.com/en-us/research/blog/anticipating-
more-from-cortana/ . [Accessed: 01-April-2021]

[26] Amazon. (2021). Conoce a Alexa. [Online]. Available:

https://www.amazon.es/gp/browse.html?node=15823644031&ref_=nav_em__
k_echo_aug_0_2_5_16. [Accessed: 01-April-2021]

[27] Google. (2021). Google Assistant. [Online]. Available:

https://assistant.google.com/intl/es_es/. [Accessed: 01-April-2021]

[28] M. Bates, "Health Care Chatbots Are Here to Help," in IEEE Pulse, vol. 10,
no. 3, pp. 12-14, May-June 2019, doi: 10.1109/MPULS.2019.2911816.

[29] Babylon Health. (2021). Ask Babylon. [Online]. Available:

https://www.babylonhealth.com/product/ask-babylon. [Accessed: 02-April-
2021]

[30] G. García, M. Fuertes-Alpiste, N. Molas-Castell, Briefing paper: los chatbots

en educación. Barcelona: eLearn Center, Universitat Oberta de Catalunya. 2018.
doi: https://doi.org/10.7238/elc.chatbots.2018

[31] AndyChatbot. (2021). Chat and Practice English with Andy. [Online].
Available: https://andychatbot.com/. [Accessed: 02-April-2021]

116
[32] Live Person. (2017, May 12). Customers prefer chatting with customer service
bots for simple tasks, new research finds. [Online]. Available:
https://pr.liveperson.com/index.php?s=43&item=496. [Accessed: 02-April-
2021]

[33] Just Eat UK. (2021). How does the Helper Bot chatbot work?. [Online].
Available: https://www.just-eat.co.uk/help/article/115005121685/how-
does-the-helper-bot-chatbot-work. [Accessed: 02-April-2021]

[34] World Health Organization. (2020, August 21). WHO Health Alert brings
COVID-19 facts to billions via WhatsApp. [Online]. Available:
https://www.who.int/news-room/feature-stories/detail/who-health-alert-
brings-covid-19-facts-to-billions-via-whatsapp. [Accessed: 02-April-2021]

[35] ICONIQ. (2021). Kuki AI. [Online]. Available: https://chat.kuki.ai/.

[Accessed: 02-April-2021]

[36] Microsoft. (2019). Microsoft Bot Framework. [Online]. Available:

https://dev.botframework.com/. [Accessed: 03-April-2021]
[37] Amazon. (2021). Amazon Lex IA conversacional para chatbots. [Online].
Available: https://aws.amazon.com/es/lex/. [Accessed: 03-April-2021]
[38] Google Cloud. (2021). Dialogflow. [Online]. Available:
https://cloud.google.com/dialogflow. [Accessed: 03-April-2021]
[39] IBM. (2021). Watson Assistant. [Online]. Available:
https://www.ibm.com/cloud/watson-assistant. [Accessed: 03-April-2021]
[40] Rasa. (2021). Rasa is the essential platform for creating superior customer
experiences. [Online]. Available: https://rasa.com/product/why-rasa/.
[Accessed: 03-April-2021]
[41] Wit.ai. (2021). Build Natural Language Experiences. [Online]. Available:
https://wit.ai/. [Accessed: 03-April-2021]
[42] Botpress. (2020). Build Digital Employees. Automate Routine Conversations.
[Online]. Available: https://botpress.com/. [Accessed: 03-April-2021]
[43] G. Cox. (2019). ChatterBot. Machine learning, conversational dialog engine.
[Online]. Available: https://chatterbot.readthedocs.io/en/stable/. [Accessed:
03-April-2021]
[44] A. Faizal. (2021, April 24). Chatbot. [Online]. Available:
https://chatbot.obbne.com/. [Accessed: 03-April-2021]
[45] NLTK Project. (2021, April 20). Natural Language Toolkit. [Online]. Available:
https://www.nltk.org/. [Accessed: 03-April-2021]
[46] M. van Gompel. (2019, March 13). PyNLPl – Python Natural Language
Processing Library. Available: https://github.com/proycon/pynlpl. [Accessed:
03-April-2021]
[47] spaCy. (2021). Industrial-Strength Natural Language Processing. Available:
https://spacy.io/. [Accessed: 03-April-2021]
[48] S. Loria. (2020). TextBlob: Simplified Text Processing. Available:
https://textblob.readthedocs.io/en/dev/. [Accessed: 03-April-2021]
[49] J. Meng, J. Zhang and H. Zhao, "Overview of the Speech Recognition
Technology," 2012 Fourth International Conference on Computational and
Information Sciences, 2012, pp. 199-202, doi: 10.1109/ICCIS.2012.202.
117
[50] K.H. Davis, R. Biddulph, S. Balashek, “Automatic Recognition of Spoken
Digits”, The Journal of the Acoustical Society of America, vol. 24, n. 6. November,
1952
[51] IBM. (2021). IBM Shoebox. [Online]. Available:
https://www.ibm.com/ibm/history/exhibits/specialprod1/specialprod1_7.ht
ml. [Accessed: 04-April-2021]
[52] Sonix.ai. (2021). A short history of speech recognition. [Online]. Available:
https://sonix.ai/history-of-speech-
recognition#:~:text=The%20first%20speech%20recognition%20systems,to%20
16%20words%20in%20English. [Accessed: 04-April-2021]
[53] B. T. Lowerre, “The HARPY Speech Recognition System”, Ph.D. dissertation,
Dep. Comp. Sci., Carnegie-Mellon University, Pittsburgh, Pennsylvania, 1976
[54] S. R. Eddy, “What is a hidden Markov model?”, Nature Biotechnology, vol.
22, n. 10, October, 2004
[55] M. Saba. (2021). A Brief History of Voice Recognition Technology. [Online].
Available: https://www.callrail.com/blog/history-voice-recognition/.
[Accessed: 04-April-2021]
[56] Google Cloud. (2021). Speech-to-Text. [Online]. Available:
https://cloud.google.com/speech-to-text?hl=es. [Accessed: 05-April-2021]
[57] Microsoft Azure. (2021). Speech-to-Text. [Online]. Available:
https://azure.microsoft.com/es-es/services/cognitive-services/speech-to-
text/. [Accessed: 05-April-2021]
[58] IBM. (2021). Watson Speech to Text. [Online]. Available:
https://www.ibm.com/es-es/cloud/watson-speech-to-text. [Accessed: 05-
April-2021]
[59] AWS Amazon. (2021). Amazon Transcribe. [Online]. Available:
https://aws.amazon.com/es/transcribe/. [Accessed: 05-April-2021]
[60] MDN Web Docs. (2021, April 23). Uso de la Web Speech API. [Online].
Available:
https://developer.mozilla.org/es/docs/Web/API/Web_Speech_API/Using_the_
Web_Speech_API. [Accessed: 25-April-2021]
[61] P. Taylor, “Introduction,” in Text-to-Speech Synthesis, Cambridge:
Cambridge University Press, 2009, pp. 1–7.
[62] H. Tora, I. B. Uslu, T. Karamehmet, “Implementation of Turkish Text-to-
Speech Synthesis on a Voice Synthesizer Card with Prosodic Features”, Anadolu
University Journal of Science and Technology, vol. 18, n. 3, pp. 584-594. June,
2017
[63] M.R. Schroeder, “A brief history of synthetic speech”, Speech
Communication, vol. 13, pp. 231-237, October, 1993
[64] S. Lemmetty, “Review of Speech Synthesis Technology”, M.S. thesis, Dep.
Of Electrical and Communication Engineering, Helsinki Univ. of Tech., Helsinki,
1999
[65] J.O. Smith. (2010). Dudley’s Vocoder. [Online]. Available:
https://ccrma.stanford.edu/~jos/pasp/Dudley_s_Vocoder.html#:~:text=A%20
manually%20controlled%20version%20of,fingers%20controlled%20the%20ban
dpass%20gains. [Accessed: 06-April-2021]

118
[66] P. Burk, L. Polansky, D. Repetto, M. Roberts, D. Rockmore, “The Synthesis
of Sound Computer” in Music and Computers. A Theoretical and Historical
Approach. USA, 2005, Key College Publishing, ch. 4, sec. 4.4
[67] Google Cloud. (2021). Text-to-Speech. [Online]. Available:
https://cloud.google.com/text-to-speech. [Accessed: 07-April-2021]
[68] Microsoft Azure. (2021). Text to Speech. [Online]. Available:
https://azure.microsoft.com/es-es/services/cognitive-services/text-to-
speech/#customer-stories. [Accessed: 07-April-2021]
[69] IBM. (2021). Watson Text to Speech. [Online]. Available:
https://www.ibm.com/cloud/watson-text-to-speech. [Accessed: 07-April-
2021]
[70] AWS. (2021). ¿Qué es Amazon Polly?. [Online]. Available:
https://docs.aws.amazon.com/es_es/polly/latest/dg/what-is.html. [Accessed:
07-April-2021]
[71] Indeed. (2021, April 14). What Is a Web Application? How it Works, Benefits
and Examples. [Online]. Available: https://www.indeed.com/career-
advice/career-development/what-is-web-application. [Accessed: 08-April-2021]
[72] Essential Designs. (2019, July 26). Website vs Web App: What’s the
Difference?. [Online]. Available:
https://medium.com/@essentialdesign/website-vs-web-app-whats-the-
difference-e499b18b60b4. [Accessed: 08-Abril-2021]
[73] W3Schools. (2021). HTML Responsive Web Design. [Online]. Available:
https://www.w3schools.com/html/html_responsive.asp. [Accessed: 08-April-
2021]
[74] D. Sin, E. Lawson and K. Kannoorpatti, "Mobile Web Apps - The Non-
programmer's Alternative to Native Applications," 2012 5th International
Conference on Human System Interactions, 2012, pp. 8-15, doi:
10.1109/HSI.2012.11.
[75] World Wide Web Foundation. (2021). History of the Web. [Online]. Available:
https://webfoundation.org/about/vision/history-of-the-web/. [Accessed: 09-
April-2021]
[76] Equipo de Google Chrome. (2021). La evolución de la Web. [Online].
Available: http://www.evolutionoftheweb.com/?hl=es. [Accessed: 09-April-
2021]
[77] M. Latorre, “Historia de las Web, 1.0, 2.0, 3.0 y 4.0”, Repositorio de la
Universidad Marcelino Champagnat
[78] State of JavaScript. (2020). Front-end Frameworks. [Online]. Available:
https://2020.stateofjs.com/en-US/technologies/front-end-frameworks/.
[Accessed: 10-April-2021]
[79] Facebook Open Source. (2021). React. [Online]. Available:
https://es.reactjs.org/. [Accessed: 10-April-2021]
[80] Angular. (2021). Angular. [Online]. Available: https://angular.io/.
[Accessed: 10-Abril-2021]
[81] E. You. (2021). Vue.js The Progressive JavaScript Framework. [Online].
Available: https://vuejs.org/. [Accessed: 10-April-2021]
[82] Simform. (2021, January 5). Best Frontend Frameworks of 2021 for Web
Development. Available: https://www.simform.com/best-frontend-
119
frameworks/#:~:text=Top%203%20Frontend%20Frameworks%20of,framework
s%20of%202021%20as%20well. [Accessed: 15-April-2021]
[83] Naciones Unidas. (2021). Objetivos de Desarrollo Sostenible. Available:
https://www.un.org/sustainabledevelopment/es/objetivos-de-desarrollo-
sostenible/. [Accessed: 23-May-2021]

120
7 Anexos

7.1 Repositorios del trabajo

Como parte del Trabajo Fin de Grado se han creado dos proyectos distintos
correspondientes al desarrollo del chatbot y a la aplicación web respectivamente.
Para poder llevar un control de los cambios que se han ido introduciendo en
ambos proyectos, así como para poder compartir el código generado o facilitar
su compartición, se ha empleado Github como sistema de control de versiones,
de manera que el código se encuentra publicado en los repositorios que se
incluyen a continuación.
x Proyecto del chatbot desarrollado en Rasa:
https://github.com/glitch3dbunny/sdc-chatbot-infantil

x Proyecto de la aplicación web desarrollada en Angular:

https://github.com/glitch3dbunny/sdc-chatbot-ui

7.2 Capturas de la API de Rasa

Una de las maneras de comunicarse con el servidor de Rasa es a través de la

API HTTP que permite recibir llamadas REST desde distintos tipos de
aplicaciones.
Para poder probar el correcto funcionamiento del chatbot durante el desarrollo,
se han realizado llamadas de prueba para verificar que el agente era capaz de
seguir el flujo diseñado y responder de manera adecuada a los mensajes de los
usuarios; en este apartado se recogen algunas de las llamadas de prueba
utilizadas durante el desarrollo desde la aplicación Postman.
Todas las llamadas empleadas en esta API son de tipo POST y se realizan sobre
la siguiente dirección: http://localhost:5005/webhooks/rest/webhook

x Saludo:

121
x Explicación:

122
x Comenzar a jugar:

x Respuesta a la pregunta 1:

123
x Respuesta a la pregunta 2:

x Respuesta a la pregunta 3:

124
x Preguntar acerca de Sonidos del Cielo:

x Preguntar qué es un meteoroide y/o meteoro:

x Preguntar qué hay que hacer:

125
x Despedida:

126
Este documento esta firmado por
Firmante CN=tfgm.fi.upm.es, OU=CCFI, O=Facultad de Informatica - UPM,
C=ES
Fecha/Hora Sat May 29 22:24:01 CEST 2021
Emisor del [email protected], CN=CA Facultad de
Certificado Informatica, O=Facultad de Informatica - UPM, C=ES
Numero de Serie 630
Metodo urn:adobe.com:Adobe.PPKLite:adbe.pkcs7.sha1 (Adobe
Signature)