PROGRAMACIÓN DE

NAO6

Autores:
Lavinia Felicia Fudulu

José María Prieto Crespo

Alberto Rodero Peña

Jesús Valeo Fernández

Manuel Ángel Pazos Ruiz

1
2
Contenido
Subdivisión del Equipo .................................................................................................................. 5
Contexto Histórico......................................................................................................................... 6
Evolución de la Robótica ........................................................................................................... 6
Primera generación ............................................................................................................... 6
Segunda generación .............................................................................................................. 7
Tercera generación................................................................................................................ 7
Cuarta generación ................................................................................................................. 8
NAO6 ............................................................................................................................................. 9
Experiencia humano-robot ..................................................................................................... 10
Principales áreas de mejora del hardware .............................................................................. 10
Práctica ........................................................................................................................................ 11
Introducción ............................................................................................................................ 11
Entrenamiento de la red neuronal .......................................................................................... 12
Preprocesamiento de datos .................................................................................................... 12
Organización de Datos ............................................................................................................ 15
Consideraciones .................................................................................................................. 16
Entrenamiento y Test .............................................................................................................. 16
Fallos.................................................................................................................................... 17
Modelo Preentrenado ............................................................................................................. 18
Evaluación del Modelo ............................................................................................................ 18
Conexión con 𝑁𝑎𝑜6 ................................................................................................................ 18
Contratiempos..................................................................................................................... 19
Coordinación con el grupo de Procesamiento del Habla ........................................................ 20
Fallos.................................................................................................................................... 21
Coordinación con el grupo de Visión ...................................................................................... 22
Bibliografía .................................................................................................................................. 23

3
Ilustración 1:Robot manipulador .................................................................................................. 6
Ilustración 2: Robot de Aprendizaje. ............................................................................................. 7
Ilustración 3: Robot inteligente de 3º generacion ........................................................................ 7
Ilustración 4:Robot inteligente de cuarta generación .................................................................. 8
Ilustración 5:Diferentes escenarios de uso ................................................................................... 9
Ilustración 6:Interacción con NAO ................................................................................................ 9
Ilustración 7:LA 6ª GENERACIÓN DE ROBOT HUMANOIDE NAO ................................................ 10
Ilustración 8: 6 PRINCIPALES ÁREAS DE MEJORA DEL HARDWARE............................................. 10
Ilustración 9:Estructura de una red neuronal ............................................................................. 11
Ilustración 10:Flujo de extracción de vectores característicos MFCC ......................................... 13
Ilustración 11:Microfonos Nao .................................................................................................... 19
Ilustración 12:Separación de palabras ........................................................................................ 19
Ilustración 13:Diagrama de Funcionamiento .............................................................................. 20

4
Subdivisión del Equipo

Procesamiento de Datos: Lavinia Felicia Fudulu, José María Prieto Crespo, Alberto Rodero
Peña

Organización de Datos: Jesús Valeo Fernández, Manuel Ángel Pazos Ruiz

Modelo Preentrenado: Jesús Valeo Fernández, Manuel Ángel Pazos Ruiz

Evaluación del Modelo: Jesús Valeo Fernández, Manuel Ángel Pazos Ruiz

Conexión con Nao6: José María Prieto Crespo, Alberto Rodero Peña

Coordinación: José María Prieto Crespo, Alberto Rodero Peña, Jesús Valeo Fernández, Manuel
Ángel Pazos Ruiz

Memoria: Lavinia Felicia Fudulu

5
Contexto Histórico

Nos centraremos en la evolución de la robótica gracias a la inteligencia artificial.

La palabra robot proviene del escritor checo Karel Capek, el cual acuño en 1921 dicho termino
en una de sus obras a partir de la palabra checa “robota” que significa servidumbre o trabajo
forzado. Posteriormente seria Isaac Asimov quien utilizaría el término “robótica” definiendo a la
ciencia que estudia los robots.

Actualmente, la robótica se define como la ciencia y tecnología de los robots. Se ocupa del
diseño, manufactura y aplicaciones de éstos y combina diversas disciplinas como la mecánica,
electrónica, información, inteligencia artificial e ingeniería de control.

Aquí es donde aparece el término de inteligencia artificial (IA). Mientras que la robótica, en
principio, evoluciona a la mecánica de los robots, la inteligencia artificial se encarga de la parte
analítica, consiguiendo comportamientos cada vez más humanos.

Evolución de la Robótica

Primera generación

La primera generación engloba los robots

“manipuladores 1 ”, que son aquellos que
repiten una o varias tareas de manera
programada bajo un software, en
secuencia. Estos no toman en
consideración las alteraciones que se
presenten en su entorno. Se aplican en
áreas nucleares, industriales, búsquedas
difíciles de mar y tierra, etc.

Sus sistemas mecánicos están hechos bajo

estructuras muy sencillas, aplicadas en
oficios secuenciales que solo necesiten el
movimiento continuo de unas pocas
piezas. Generalmente son dirigidas a la Ilustración 1:Robot manipulador
distancia por un operador humano y
reemplazan muchas manos humanas.

1
Robot Manipulador: https://www.youtube.com/watch?v=TGsXBE93EkM

6
Segunda generación

Dentro de la clasificación de los

robots de segunda generación 2, se
encuentran los que realizan tareas
luego de aprender los movimientos
que ejecutan los operadores
humanos. A pesar de utilizar una
tecnología más avanzada, los
movimientos de este tipo de robots
también se realizan en secuencia.

Lo que hace a las máquinas de

segunda generación, son sus sensores Ilustración 2: Robot de Aprendizaje.
especializados y sistemas de
retroalimentación. A través de estos
captan qué tareas deben hacer, cuáles son los movimientos necesarios para ello y comprobar
del resultado de su práctica.

Tercera generación

En la clasificación de los robots, la tercera generación 3 es

reprogramable a través de ordenadores. Estos también
cuentan con sensores artificiales y otras piezas que permiten
la visión y el tacto empleando lenguajes de programación.

También se les conoce como robots con control sensorizado y

suelen ser utilizados en áreas en las que se realizan múltiples
tareas, ya que al ser programables los humanos pueden
controlar su sistema mecánico a medida que necesiten
ejecutar cada tarea.

Ilustración 3: Robot inteligente de 3º

generacion

2
Programación de robots por Auto aprendizaje:
https://www.youtube.com/watch?v=FRzB4PKJo3k&t=772s
3
Robot inteligente: https://www.youtube.com/watch?v=RlAhM2lu1XE

7
Cuarta generación

Robots inteligentes 4. Son similares a

los anteriores, pero además poseen
sensores que envían información sobre
el estado del proceso a la computadora
de control. Esto permite una toma de
decisiones y el control del proceso en
tiempo real.

Ilustración 4:Robot inteligente de cuarta generación

4
Robots inteligentes cuarta generación: https://www.youtube.com/watch?v=4KUlavrIpjA

8
 6
NAO

Una vez vistas todas las generaciones, nos centraremos en

la tercera generación y trabajaremos con el robot
inteligente Nao en su versión más reciente Nao6, que se
introdujo en 2018.

Desde su lanzamiento en 2004, Nao ha sido probado y

desplegado en una serie de escenarios sanitarios, incluido
en el uso de residencias de ancianos, como asistente en
empresas y en centros educativos. Ahora Nao es una Ilustración 6:Interacción con NAO
innovadora y avanzada interfaz de comunicación,
interacción y educación con usos en diversos sectores:

Ilustración 5:Diferentes escenarios de uso

9
Experiencia humano-robot

Dispone de las siguientes características que hace que la interacción con el robot sea muy
natural.

Ilustración 7:LA 6ª GENERACIÓN DE ROBOT HUMANOIDE NAO

Principales áreas de mejora del hardware

Con el paso de los años Nao ha pasado por múltiples mejoras. La versión de la 6ª generación
de Nao trae las siguientes mejoras:

Ilustración 8: 6 PRINCIPALES ÁREAS DE MEJORA DEL HARDWARE

Para indagar más en profundidad en las características del robot visitar el enlace5.

5
https://developer.softbankrobotics.com/nao6

10
Práctica

Nao será un robot que oriente sobre los estudios en Informática en la UHU, es decir, mantendrá
una conversación amigable y cortés, y responderá a las preguntas que se le planteen con el
mayor nivel de interacción, realismo, apariencia de inteligencia, etc., posibles.

El robot debe identificar mediante la cámara a personas (esto es, detectar a una persona, y
seguirla con la cabeza desde ese momento), saludar mostrando que ha identificado a un posible
interlocutor, presentarse como un robot asesor de los estudios en informática de la UHU, y a
partir de ahí identificar lo que se le dice (se le pueden preguntar algunas cosas (sobre la titulación
en informática)). Así, responderá en consecuencia con información (de un banco de respuestas
en texto almacenadas), gesticular mientras habla para favorecer el realismo (moviendo la cabeza
…afirmando o negando… con los brazos…), y saber despedirse cortésmente cuando el
interlocutor se despida; volviendo al estado de identificar personas, saludar y presentarse,
interactuar… y volver a iniciar el proceso…

Introducción

Para el desarrollo de la práctica se han dividido las tareas entre tres grupos:

• Grupo de visión artificial (haciendo uso de Deep Learning): Reconocer una persona.
• Grupo de reconocimiento del habla (haciendo uso de Deep Learning): Nao debe
entender lo que le dicen.
• Grupo de procesamiento del habla (text to speech) y coordinación de todos los módulos:
Pasar de texto a audio de forma que pueda comunicarse.

Nosotros nos centraremos en el segundo grupo, en hacer que Nao reconozca el habla.

Las redes neuronales son modelos simples del funcionamiento del sistema nervioso. Las
unidades básicas son las neuronas, que generalmente se organizan en capas, como se muestra
en la siguiente ilustración.

Una red neuronal es un modelo simplificado

que emula el modo en el que el cerebro humano
procesa la información.

Funciona simultaneando un número elevado de

unidades de procesamiento interconectadas
que parecen versiones abstractas de neuronas.

Las unidades de procesamiento se organizan en

Ilustración 9:Estructura de una red neuronal
capas. Hay tres partes normalmente en una red
neuronal (ilustración 9):

• Una capa de entrada, con unidades que representan los campos de entrada.

11
 • Una o varias capas ocultas.
• Una capa de salida, con una unidad o unidades que representa el campo o los campos
de destino.

Cada conexión entre las neuronas se asocia con un peso. Este peso determina la importancia del
valor de entrada. Los datos de entrada se presentan en la primera capa, y los valores se propagan
desde cada neurona hasta cada neurona de la capa siguiente. Al final, se envía un resultado
desde la capa de salida.

Entrenamiento de la red neuronal

El entrenamiento de la IA es la parte más difícil de Deep Learning porque:

• Necesita un gran volumen de datos.

• Necesita una gran cantidad de potencia computacional.

El deep learning es un tipo de machine learning que entrena a una computadora para que realice
tareas como las hacemos los seres humanos, como el reconocimiento del habla, la identificación
de imágenes o hacer predicciones. En lugar de organizar datos para que se ejecuten a través de
ecuaciones predefinidas, el deep learning configura parámetros básicos acerca de los datos y
entrena a la computadora para que aprenda por cuenta propia reconociendo patrones mediante
el uso de muchas capas de procesamiento.

En nuestro caso, los datos de entrada serán:

• Audios. Para conseguirlos hemos sacado un banco de sonidos de la narración de las tres
batallas descritas en “Los episodios nacionales” de Benito Pérez Galdós. Consiguiendo
un total de 11016 audios.
• Archivos MFCC. Estos archivos los crea automáticamente el kit de desarrollo utilizado.
• Fonética a partir de un lexicón.
• Audios Transcritos.

Preprocesamiento de datos

1ª Parte

Hemos creado un script “procesarFicheroInexistentes” para procesar los ficheros y obtener los
audios.

El audio es un dato no estructurado. Para poder trabajar con él hay que sacar datos tangibles
con los que se pueda trabajar.

Los audios tienen varias características entre las que destacamos:

• Amplitud: Es la cantidad se presión sonora que ejerce la vibración en el aire.

12
 • Timbre. El timbre es una cualidad que caracteriza al sonido. Depende de la cantidad de
armónicos que tenga un sonido y de la intensidad de cada uno de ellos. Se trata de una
de las cualidades esenciales del sonido junto con el tono, la duración y la intensidad.
• Tono. El tono es la sensación auditiva psicológica de los sonidos que se caracteriza por
ser más agudos o graves en función de la frecuencia.

Para representar esta información hemos

usado MFCC (Mel Frequency Cepstral
Coefficients) que son coeficientes para la
representación del habla basada en la
percepción auditiva.

Al principio, por cada archivo de audio

sacábamos la información MFCC con un script Ilustración 10:Flujo de extracción de vectores característicos MFCC
que hicimos en Python. Pero más tarde nos
dimos cuenta de que en el ToolKit había una extracción de MFCC automática, así que decidimos
no utilizar el que hicimos.

2ª Parte

A continuación, necesitamos sacar la información del texto para asociar la información del audio
a la información del texto porque el audio se asocia como se pronuncia y no como se escribe.

Para ello necesitamos la pronunciación de nuestros textos. Esta pronunciación la obtendremos

de la transcripción fonética de cada palabra.

Tras realizar una exhaustiva búsqueda conseguimos encontrar un léxico de español, es decir,
una concordancia entre palabra y su fonética, si esta existe.

Contratiempos

Había palabras en el texto que no

existían en el lexicón, por lo que no FONÉTICA
podíamos conseguir la
transcripción fonética. Así que 100000
tuvimos que averiguar que 80000
palabras no existían en el léxico. 60000
40000
Para eso hicimos una búsqueda,
20000
palabra por palabra, y si no se
0
encontraba en el léxico lo Resumen de
apuntamos en un fichero aparte Palabras
llamado “inexistentes.txt”.
Total Palabaras SinFoneticaOriginal
En total, de las 91120 palabras, SinFoneticaProesadas SinFoneticaErroneas
29635 no existían.

13
Con el objetivo de ampliar el léxico, hemos procesado estas palabras para que estuviesen en el
mismo formato que el léxico original y poder sacar la fonética. Se obtuvo un total de éxito de
7327 palabras, mientras que 1824 dieron error.

3ª Parte

Partiendo de una lista de palabras o un fichero, con palabras procesadas (sin comillas, sin comas,
sin puntos, etc.) se hace una búsqueda en el léxico ampliado. Si existe se obvia la palabra porque
ya tiene transcripción, si no existe el objetivo es crear la fonética a partir de palabras que se
parezcan a esta.

¿Por qué lo hemos hecho así?

Una “u” tiene varias formas de pronunciarse, dependiendo de la palabra que la contenga. Por
ejemplo, “huevo” se traduce fonéticamente como “w” y “uso” es una “u” normal.

¿Cómo se hace?

Se llama a una función recursiva con una cadena de caracteres. Estos caracteres van a buscar
dentro de las palabras del léxico ampliado. Si encuentra la cadena, copia los caracteres fonéticos
correspondientes y los devuelve, sino divide la palabra por la mitad recursivamente hasta
encontrar la fonética y después de unir la fonética de toda la cadena de caracteres pasada
inicialmente la une y devuelve.

Contratiempos

1º

Hay caracteres que no se van a encontrar nunca así que hay palabras que no van a tener
transcripción fonética, por ejemplo “ae”. En este caso, la transcripción de la palabra seria ella
misma.

2º

El número de letras en texto no tiene por qué coincidir con el número de fonemas. Por ejemplo
“rr”, “ll”, “ch”, “h (muda)”, etc. La solución a esto es un “offset” positivo o negativo según el
caso.

Tras todo esto, la fonética sacada se añade a la anterior obteniendo un léxico ampliado.

14
Organización de Datos

Paralelamente al procesamiento de datos, hemos trabajado sobre la organización de datos que

emplea Kaldi.

Kaldi es un kit de herramientas de reconocimiento de voz de código abierto escrito en C ++ para

el reconocimiento de voz y el procesamiento de señales y es la herramienta que hemos utilizado
para entrenar nuestro modelo.

Se han creado cinco ficheros con información acerca de cómo están estructurados los archivos
en sí. Estos ficheros se crean sobre los datos que se usan para el entrenamiento de la red
neuronal.

1. El primero se llama wav.scp. Es un fichero que relaciona el id de un audio con la ruta

hacia el archivo de dicho audio.
2. El segundo se llama utt2spk. Relaciona el id del audio con el id del hablante que ha
realizado el audio.
3. Spk2utt. Este sería el contrario al segundo, relaciona el id del hablante con el id de los
audios de dicho hablante.
4. El penúltimo text. Relaciona el id de los audios con sus transcripciones.
5. Y por último spk2gender. A partir del id del hablante relaciona el género de cada uno de
los hablantes que están en el dataset.

Hay que tener en cuenta que toda la generación de los diferentes ficheros, el tratamiento de las
transcripciones, la ruta del archivo y los id’s de audio y hablantes se han hecho automáticamente
haciendo uso de un script de Python.

Esta información generada ya puede ser usada por Kaldi para extraer datos a partir de los
ficheros de audio y generar un modelo acústico

Hay que considerar que a la par que vamos a generar el modelo de audio también vamos a
generar un modelo del lenguaje que se va a combinar con este último. Este modelo de lenguaje
se obtiene de los datos de pronunciación, es decir, se sacará del lexicón que se ha generado en
la parte del procesamiento de datos. Se necesitarán los archivos del lexicón en sí, que va a
relacionar cada una de las palabras con su transcripción fonética, y otros tres archivos más que
le van a indicar a Kaldi cuales son los fonemas que son mudos, cuáles no son mudos y cuáles
pueden ser mudos. Estos archivos serían nonsilence phones para los no mudos, silence phones
para los mudos y optionals silence para los que son opcionalmente mudos.

Una vez ya obtenidos los archivos del modelo del lenguaje lo siguiente sería generar el propio
modelo del lenguaje. Esto lo hace el propio kit de desarrollo utilizando el lexicón obtenido en la
parte del procesamiento de datos además de las transcripciones que tenemos en los datos de
los propios audios.

Tras el modelo de lenguaje hemos generado el modelo acústico.

15
1ª Parte

En esta primera parte lo que se hace es extraer los mfcc de los audios. Esta era la parte que en
principio habíamos empezado a hacer, pero luego observamos que lo podía hacer
automáticamente el propio kit de desarrollo.

MFCCs son coeficientes para la representación del habla basados en la percepción auditiva
humana.

2º Parte

En principio se entrena un módulo básico que está basado en modelos ocultos de Markov, con
el objetivo de sentar la base de cómo se va a entrenar después la red neuronal.

Una vez obtenido el modelo básico basado en HMM (Hidden Markov Models) lo siguiente es
entrenar la red en sí, a partir de los modelos y todos los datos que ha recopilado Kaldi.

Consideraciones

Hay que tener en cuenta que esta red neuronal profunda solo se entrena en cuanto a modelo
acústico se refiere, es decir, el modelo del sonido. Para mejorar las transcripciones que hacen,
porque en principio solo sabe identificar fonemas, hay que combinarla con el modelo de
lenguaje. Con esto será capaz de traducir estos fonemas a palabras en sí. Dicho de otra forma,
el modelo Speech‑to‑Text lo realiza la combinación de los modelos acústicos y del lenguaje.
Como es obvio, el modelo del lenguaje va a hacer mucho uso del lexicón y de la información
acerca de los fonemas que se pronuncian y los que no.

Entrenamiento y Test

Tras hacer todo lo mencionado anteriormente, lo que queda es probar el modelo generado con
una información que no se haya utilizado en su entrenamiento. En nuestro caso, como teníamos
varios miles de audios hemos seleccionado nueve mil para el entrenamiento y el resto lo hemos
utilizado para hacer el test, es decir, para evaluar el modelo en sí.

Una vez probado el modelo con los archivos de audio de test lo que se tiene que hacer es
evaluarlo. Para eso hemos usado una técnica que se denominada Word Error Rate (WER).

La tasa de error de palabras (WER) es una métrica común del rendimiento de un sistema de
reconocimiento de voz o traducción automática.

La dificultad general de medir el desempeño radica en el hecho de que la secuencia de palabras

reconocida puede tener una longitud diferente de la secuencia de palabras de referencia
(supuestamente la correcta).

16
La tasa de error de palabras se puede calcular como:

𝑺+𝑫+𝑰 𝑺+𝑫+𝑰
𝑾𝑬𝑹 = =
𝑵 𝑺+𝑫+𝑪
Dónde:

S es el número de sustituciones,

D es el número de eliminaciones,

I es el número de inserciones,

C es el número de palabras correctas,

N es el número de palabras en la referencia (N=S+D+C)

En conclusión, tras evaluar nuestro modelo vemos que el WER es del 98%, es decir, comete
algún error en el 98% de los casos en los que probamos el modelo.

Fallos

Estos porcentajes de error son debidos a que

nuestro modelo falla en varios aspectos. En WER
principio esto ocurre porque hay pocos hablantes,
Continuando con lo de antes, significa que no hay
muchas personas que tengan distintos timbres,
2%
tonos etc... , los hablantes tienen el mismo acento
y la misma entonación. Tampoco hay una variedad
en torno a la temática de los audios lo cual hace
que no se tenga conocimiento de todas las 98%
palabras que puedan existir y por tanto acaba
desembocando en un error bastante grande a la
hora de realizar la transcripción de los audios. Algo Aciertos Fallos
a tener en cuenta es que para ser un
entrenamiento de una red neuronal profunda tampoco se ha utilizado una inmensa cantidad de
horas de audios, por lo que pueden empeorar los resultados ya que se necesitan muchísimos
más, del orden de miles de horas de grabaciones transcrita y nosotros solo contamos con nueve
mil para el entrenamiento.

17
Modelo Preentrenado

Debido a los fallos mencionados anteriormente y dado que teníamos que tomar un modelo que
funcionase decidimos hacer uso de un modelo preentrenado que ya existía y que esta entrenado
con la mayor librería de audios transcritos del mundo llamada librispeech 6. Es una librería de
audios transcritos libre.

Hay que tener presente que la que usamos es la librispeech en español. Hay una librería de
audios en ingles que es mucho más grande.

Este modelo esta entrenado y realizado por el Instituto de Ingeniería del Conocimiento (IIC) que
es un centro español de investigación, desarrollo e innovación, ubicado en el campus de la
Universidad Autónoma de Madrid.

Evaluación del Modelo

WER
Este modelo tiene en la web una Tasa de error WER,
tras evaluarlo con el dataset que han empleado, del 0.0730 0.04091
0’073%. En cambio, cuando lo hemos probado con
nuestro dataset, mejor dicho, con nuestros audios de Fallos
99.927 99.959
test, las tasas de error de este modelo son de Aciertos
0’04091%, es decir, que son aún mejores que las que
presentan en la web.
IIC UHU
La elección del modelo final resulta obvia: el modelo
preentrenado desbanca por completo al que hemos entrenado en el laboratorio. Hemos creado
un script que sea capaz de utilizar este modelo a partir de los audios obtenidos del propio NAO.

Conexión con 𝑁𝑎𝑜6

En la página oficial7 había diferentes formas de conectarse con el robot, pero era haciendo uso
de código en C, con lo cual no nos sirvió de mucho.

Tras investigar un poco hemos encontrado un código en Python. El problema que tuvimos con
esto fue que el código funcionaba con una versión de Python diferente a la que fuimos usando
hasta el momento. Tuvo rápida solución ya que solo debíamos instalar la otra versión.

Tras conseguir conectarnos al robot hicimos dos scripts, grabarAudio.py y transcribirAudio.py.

6
https://www.openslr.org/12
7
http://doc.aldebaran.com/2-5/home_nao.html

18
GabarAudio.py: Se conecta a Nao, espera un tiempo, que es el tiempo que va a estar grabando
y una vez terminada la grabación, guarda todos los datos en un .raw, que es el formato en el que
graba audios Nao.

La edición NAO Academics viene con 4

micrófonos, tal como se ve en la
ilustración 11. Cuando realizamos las
grabaciones, tras hacer pruebas con los
cuatro micrófonos decidimos que
usaríamos el micrófono fontal porque es
el que mejor se escucha. En los demás se
escucha de fondo el ventilador interno de
Nao e impide la claridad de los audios.

Tras la generación de los. raw los

convertimos en .wav para poder Ilustración 11:Microfonos Nao
pasárselo al modelo.

TranscribirAudio.py: Coge el audio generado en grabarAudio.py y lo transcribe en un fichero

.txt.

Anteriormente se mencionó que tuvimos que cambiar de versión de Python 3 por culpa del
modelo. Decidimos hacer un archivo .bat para movernos a la carpeta donde trabajamos con
Python 2 y para que funcionase todo.

Se trata de archivos de texto sin formato, guardados con la extensión .BAT que contienen un
conjunto de instrucciones. Cuando se ejecuta este archivo, las órdenes contenidas son
ejecutadas en grupo, de forma secuencial, permitiendo automatizar diversas tareas.

Funciona de la siguiente forma: Llama a WER

grabarAudio.py, una vez se genera el archivo .wav
llama desde python 3 a transcribir el audio y cuando Aciertos Fallos
termina de escribir el .txt, se para.
5%
Hay que mencionar que funciona bastante bien, tan
solo obtuvimos un 5% de error. 95%

Contratiempos

Se han dado casos en los que ha habido palabras que las

ha dividido sin querer. Por ejemplo, la palabra
informática, por un lado, dice infor y por otro mática.

Esto es debido a que no estamos pasando palabras que

se parecen por letras a un banco de palabras porque no
sabemos que palabras necesita entender el programa Ilustración 12:Separación de palabras
que hacen el equipo de procesamiento del habla.

19
Coordinación con el grupo de Procesamiento del Habla

Como ya se sabía desde un principio, uno de los tres equipos debía coordinar el trabajo de los
tres grupos. Dado que el equipo de visión y el equipo de tts han tenido ciertos contratiempos
en la finalización del modelo, el equipo de stt asumió la tarea.

Por otro lado, al grupo de procesamiento del habla le pasaba lo mismo que al nuestro con las
versiones de Python. Ellos tenían un script que hacían aproximadamente lo mismo que el
nuestro, con Python 3 reconocían un .txt y con Python 2 se conectaban al robot. La solución a la
que llegamos para unir su script con el nuestro fue hacer un .bat. Lo primero que ejecutaba era
una llamada al script del grupo de procesamiento del habla para que se conectase a Nao y dijese
“Háblame”. A continuación, llamaba a nuestro script grabarAudio.py, y se graba el audio
alrededor de unos 5s, después hay que cambiar el formato de audio .raw a .wav. Tras todo esto,
hace una llamada a transcribirAudio.py para pasar el audio a un .txt.

Una vez conseguido la transcripción del audio en un .txt, el .bat ejecutaba una llamada a su script
de reconocimiento de .txt.

A grandes rasgos, lo que hacia ese script era abrir nuestro .txt, sacaba una de las cinco distintas
frases que podía decir, se conectaba a Nao de nuevo y le pasaba lo que el robot tenia que decir
y este lo decía.

Ilustración 13:Diagrama de Funcionamiento

20
Fallos

Pese a que funcionaba relativamente bien, el problema se producía cuando el grupo de tts cogía
nuestro texto. Esto se debía a que ellos en el texto buscaban palabras clave o frases clave y como
era de esperarse, el sistema stt no es perfecto, con lo que algunas palabras las divide, otras
palabras que empiezan por h no se la ponen y a veces no diferencia entre s, c y z dependiendo
mucho del acento en este último caso. Con todo esto, hay palabras que se parecen bastante a
lo que debería ser, pero no lo son exactamente. Este conjunto de errores produce que haya
veces en las que el sistema tts no sea capaz de saber entender lo que se le está diciendo.

Un ejemplo sería el caso en el que para saludar tiene que reconocer “HOLA”. En este caso ocurre
que si le dice hola a Nao la h no la coge porque no se pronuncia, así que saca “O-L-A” y cuando
el equipo de tts busca en el texto no encuentra hola con h así que no sabe que le han dicho hola.
Este seria uno de los fallos que se produce, aunque se podría decir que 7 de cada 10 veces
funciona bien.

Otro problema que observamos fue la latencia. Como primero se tiene que conectar el equipo
de tts a Nao para decir “HABLAME” y se tiene que desconectar y luego tiene que conectarse
nuestro script para grabar el audio. Al hacer todo esto se produce un retraso, mientras dice
“HABLAME” y que empieza a escucharte lo que puede producir es que la primera y última
palabra no las reconozca. Después tiene que reconvertir el audio, con esto tarda algún tiempo
más. Aproximadamente tarda entre 5s-10s en procesar todo el audio y después pasarlo a texto.
Y luego se tienen que conectar los del equipo tts…etc, con todo esto, al final el retraso que se
produce es bastante considerable, de aproximadamente entre 15s-20s. Pese a todo esto
funciona bastante bien.

¿Cómo se podría solucionar?

Con una correlación de palabras clave entre grupos, ya sea por parte del grupo de stt o el grupo
de tts. Es decir, si nuestro grupo tenemos el texto y tenemos que sacar las palabras que Nao no
ha entendido bien o que las ha cortado por la mitad o tal vez que las haya dividido…, etc.,
deberíamos haber tenido un listado con las palabras que reconoce el equipo de tts.

El problema principal fue la comunicación porque el primer día que vimos como funcionaba el
script del equipo tts fue el día de la entrega. En conclusión, poca coordinación entre los equipos.

También hay que mencionar que una vez implementado todo era mucho más lento porque tenia
que ejecutar todo. Aparte que nuestra parte se tiene que ejecutar en serie porque no es posible
escuchar y responder al mismo tiempo. Aproximadamente se produce un retraso de entre 30s-
40s. Aparte del problema de la latencia, otro problema que no hemos tenido en cuenta es que,
al implementar los tres modelos, si grabamos y el robot mueve la cabeza, la cámara, hace que
se produzca ruido interno y como no hay correlación entiende peor, es decir, el ruido por letra
aumenta.

En cuanto a la latencia, es muy complicado mejorar eso. Se podría mejorar haciendo que los
scripts los ejecute Nao desde dentro y no tenga que conectarse desde un PC. En nuestro caso
no podimos ejecutar Python 3 dentro de Nao así que tuvimos que conectarlo desde un
ordenador.

21
Otra mejora podría haber sido tener un representante por grupo, incluido el grupo de
coordinación, y un coordinador que hablase con el representante de cada grupo para así tener
en cuenta como hacen las cosas los demás grupos, para coordinarnos. De esta forma se evitaría
la falta de comunicación que entre los grupos. Un ejemplo muy claro de falta de comunicación
fue que hasta el día de la presentación no supimos como el equipo de tts reconocían nuestro
texto y viceversa.

Coordinación con el grupo de Visión

Sobre la coordinación con el grupo de visión tan solo hay que decir que la rutina del
reconocimiento del habla y toda la coordinación que hay con el procesamiento y su posterior
conversión de texto a dialogo se activa cuando Nao detecta un humano mediante el modelo que
han hecho el grupo de visión.

22
Bibliografía

https://www.it.uc3m.es/jvillena/irc/practicas/09-10/26mem.pdf

https://static.rapidonline.com/pdf/567052_v1.pdf

https://idus.us.es/bitstream/handle/11441/101412/TFG-2880-
RODRIGUEZ%20RAMIREZ.pdf?sequence=1&isAllowed=y

https://developer.softbankrobotics.com/nao6

https://hmong.es/wiki/Nao_(robot)

https://grupoadd.es/el-robot-nao6

https://www.euroinnova.edu.es/blog/clasificacion-de-los-robots

https://alisysrobotics.com/es/robots/robot-nao

https://freedoomforlife.wordpress.com/cuarta-generacion/

https://es.wikipedia.org/wiki/Nao_(robot)#Historia

https://www.maplesoft.com/content/EngineeringFundamentals/13/MapleDocument_13/Posi
tion,%20Orientation%20and%20Coordinate%20Transformations.pdf

https://www.sciencedirect.com/topics/engineering/robotic-manipulator

https://www.sas.com/es_es/insights/analytics/deep-learning.html

https://www.ibm.com/docs/es/spss-modeler/SaaS?topic=networks-neural-model

https://chova.com/propiedades-del-sonido-amplitud-y-frecuencia/

https://medium.com/swlh/automatic-speech-recognition-system-using-kaldi-from-scratch-
337eb7c8eea8

23