UNIVERSIDAD POLITÉCNICA DE MADRID ESCUELA TÉCNICA SUPERIOR DE...

UNIVERSIDAD POLITÉCNICA DE MADRID

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA YDISEÑO INDUSTRIAL

Grado en Ingeniería Electrónica y Automática Industrial

TRABAJO FIN DE GRADO

ESTUDIO Y ANÁLISIS DE LAS ARQUITECTURASDE REDES NEURONALES APLICADAS A

AGENTES CONVERSACIONALES

Mario Rodríguez Cantelar

Cotutor (si lo hay):Departamento:

Tutor: Pablo San Segundo CarrilloDepartamento: IngenieríaElectrónica y Automática

Madrid, Septiembre de 2018

UNIVERSIDAD POLITÉCNICA DE MADRID

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA YDISEÑO INDUSTRIAL

Grado en Ingeniería Electrónica y Automática Industrial

TRABAJO FIN DE GRADO

ESTUDIO Y ANÁLISIS DE LAS ARQUITECTURASDE REDES NEURONALES APLICADAS A

AGENTES CONVERSACIONALES

Firma Autor

Firma Cotutor (si lo hay) Firma Tutor

v

Copyright ©2018. Mario Rodríguez Cantelar

Esta obra está licenciada bajo la licencia Creative CommonsAtribución-NoComercial-SinDerivadas 3.0 Unported (CC BY-NC-ND 3.0). Para ver una copia deesta licencia, visite http://creativecommons.org/licenses/by-nc-nd/3.0/deed.es o envíe una cartaa Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, EE.UU.

Todas las opiniones aquí expresadas son del autor, y no reflejan necesariamente las opiniones dela Universidad Politécnica de Madrid.

vii

TÌtulo: Estudio y Análisis de las Arquitecturas de Redes Neuronales Aplicadas aAgentes ConversacionalesAutor: Mario Rodríguez CantelarTutor: Pablo San Segundo Carrillo

EL TRIBUNAL

Presidente:

Vocal:

Secretario:

Realizado el acto de defensa y lectura del Trabajo Fin de Grado el día ....... de.................... de ... en .........., en la Escuela Técnica Superior de Ingeniería y DiseñoIndustrial de la Universidad Politécnica de Madrid, acuerda otorgarle la CALIFI-CACIÓN de:

VOCAL

SECRETARIO PRESIDENTE

Agradecimientos

En primer lugar, quiero mostrar mi agradecimiento a la Universidad Politécnicade Madrid por estos años en los que he disfrutado aprendiendo.

A mi tutor del trabajo, Pablo San Segundo Carrillo, quiero agradecerle el apoyoy el haberme otorgado la oportunidad de poder realizar un proyecto que me haapasionado.

dedicación que me ha dado durante los últimos meses.

A Francisco Ruzafa Costas, le agradezco todo el apoyo que me ha brindado, eltiempo que me ha dedicad desde el inicio del proyecto y todo lo que he aprendidode él, sin su ayuda esto no habría sido posible.

A mi familia, amigos y pareja tengo que darles las gracias por el apoyo que mehan dado. Siempre que los he necesitado, he podido contar con ellos.

I want the world to be better because I was here.

-Willard C. Smith

ix

Resumen

La comunicación entre personas es uno de los aspectos más importantes pa-ra la sociedad y, más concretamente, el lenguaje es uno de los principales mediospara el entendimiento. En este proyecto, vamos a ahondar sobre el Procesamientodel Lenguaje Natural Procesamiento del Lenguaje Natural (NLP), encargado de laconversación hombre-máquina. Este concepto ha crecido ampliamente durante losúltimos 10 años debido a sus diversas aplicaciones, tales como los agentes conver-sacionales, los cuales se encargan de analizar y contextualizar una frase de entraday poder ofrecer la respuesta más acertada posible. Los agentes conversacionalesmás avanzados están siendo estudiados para conseguir poder desenvolverse en cual-quier circunstancia, ambiente o idioma en una conversación con personas de todoel mundo. Los estudios más punteros están estudiando las emociones como posibleincorporación en el mundo de los agentes conversacionales, haciendo más natural laconversación y también ayudando en campos como el de la salud, por ejemplo, comoapoyo psicológico.

Más brevemente, un agente conversacional puede ser entendido fácilmente comoun programa que simula las conversaciones humanas, aportando respuestas previa-mente aprendidas ante una entrada realizada por un humano. Los agentes conver-sacionales están en auge actualmente, siendo muy habitual poder interaccionar conuno en ambientes controlados.

A fin de implementar apropiadamente los agentes conversacionales, diferentestécnicas de aprendizaje profundo han de ser usadas. De este modo, los agentesconversacionales usan redes y modelos de aprendizaje profundo para generar sussalidas, con resultados muy prometedores. En este proyecto vamos a estudiar unode ellos, el modelo de agente conversacional Retrieval-Based, compuesto de una RedNeuronal Recurrente, a su vez formada por neuronas de tipo LSTM (Long ShortTerm Memory Network). Durante el estudio se llevará a cabo por una parte, unanálisis teórico, en el que se estudiarán tanto la arquitectura como los parámetrosque definen este tipo de redes; y por otra parte, un análisis práctico, evaluando sufuncionamiento y el impacto de los parámetros en el mismo.

Aunque los agentes conversacionales se ha estudiado en profundidad y aborda-do sus principales debilidades, todavía no están completamente maduros. Hemosidentificado que los principales problemas provienen de la limitación y rigidez enlas respuestas, así como de los errores en las respuestas y su apariencia automática,que es intrínsecamente antinatural. Por lo tanto, una parte importante de la comu-

xi

xii Capítulo 0. Resumen

nidad investigadora está trabajando en cómo hacer que las conversaciones sean másnaturales y resulten más atractivas para los interlocutores humanos.

El objetivo de este proyecto es el estudio de todos los parámetros que influyenen los agentes conversacionales, comúnmente llamados chatbots. El proyecto estácimentado en un agente conversacional basado en un encoder dual de LSTM para lageneración de respuestas automáticas de diálogo. El dataset escogido es el UbuntuDialog Corpus Ubuntu Dialog Corpus (UDC) debido a su extensión y a su carácterde dominio público. La razón por la que se usa el modelo Dual Encoder es porque suviabilidad como agente conversacional ha sido demostrada y los resultados a replicarson superiores a otros modelos de redes neuronales recurrentes. Las herramientasempleadas para el desarrollo y análisis han sido, TensorFlow para implementación yel entrenamiento del código, y TensorBoard para una fácil visualización de los datosobtenidos. Todo el proyecto está escrito en el lenguaje de programación Python.

La herramienta TensorFlow es, hoy por hoy, la más utilizada en el campo delaprendizaje profundo por la enorme cantidad de posibilidades que ofrece como lafacilidad de uso, una extensa documentación y una gran comunidad de programa-dores. Algunos ejemplos directos de vanguardia de esta herramienta, en relación aeste proyecto son Google’s Smart Reply o Google Translate.

El modelo Retrieval-Based aporta la ventaja de poder relacionar y compararun contexto de entrada con una respuesta de salida, y asignarle un vector a estasrelaciones, el cual en función de su tamaño nos dirá la calidad de la respuesta enrelación a la entrada. En cuanto a las neuronas de tipo LSTM usadas en el modelo sonmuy adecuadas por la memoria de contexto que presentan durante la conversación,dándonos una mejora significativa en los resultados a la hora de conversar con elagente conversacional.

Un poco más detalladamente, un agente conversacional se divide en dos fases:la primera se convierte el dataset en un vocabulario, donde cada palabra está repre-sentada por un vector numérico; la segunda, se divide el dataset y se entrena unared con frases de entrada y de respuesta, donde las frases en lugar de estar formadaspor palabras (strings), están formadas por vectores que representan palabras (wordembedding) para optimizar el coste computacional. Después de entrenar el modelose estima la calidad del mismo mediante métricas de evaluación.

Algunos de los parámetros generales más destacables de un agente conversacionalson el número de capas y neuronas por capa (siendo esta una matriz) que se usaen red neuronal, estos determina la capacidad de aprendizaje de la misma, la tasade aprendizaje nos indica la velocidad con que convergerá la red hacia el ratio desolución, el tamaño del batch (lote) nos dice la cantidad de frases de entrada quecompara en cada step (iteración) en su aprendizaje y, por último, la función decoste (pérdidas) calculada a lo largo del entrenamiento para ver lo que se asemejala solución predicha a la real.

Palabras clave: agente conversacional, modelo retrieval-based, conversación, LSTM,red neuronal recurrente, tensorflow, tensorboard, machine learning, deep learning,inteligencia artificial.

Abstract

Communication between people is one of the most important aspects for societyand more specifically the language is one of the main means for understanding. Inthis project we are going to delve into the concept of Natural Language Processing(NLP), which is in charge of the human-machine conversation. This concept haswidely grown during the last 10 years due to its diverse applications, such as conver-sational agents, which are the responsible of analyzing and contextualizing an inputphrase and are able to offer the most accurate answer. The most advanced conver-sational agents are being studied in order to enable its usage in any circumstance,in environment or language in a conversation with people from all over the world.Most novel works in the literature are studying emotions as a possible incorporationin the world of conversational agents, making conversation more natural and alsohelping in fields such as health, for example, as psychological support.

Summarizing, a conversational agent can be understood easily as a software thatsimulates human conversations, providing previously learned answers to an inputmade by a human. Conversational agents are currently very popular, nowadays it isgreatly common to interact with one in controlled environments.

In order to properly implement a conversational agent, several deep learningtechniques are required. In this way, conversational agents rely on networks andmodels to generate their outputs, with very promising results. In this project we aregoing to use specific type of conversational agent model, the Retrieval-Based con-versational agent model, composed of a Recurrent Neural Network, in turn consistsof LSTM (Long Short Term Memory network) neurons. In this project, a theoreti-cal analysis is carried out, on the one hand, which will study both the architectureand the parameters that define this type of networks; and on the other hand, apractical analysis is performed by evaluating its functionality and the impact of theparameters in it.

Although conversational agents have been studied in depth, and their main weak-nesses have been addressed, they are still not completely mature. We have identifiedthat the main problems come from the limitation and rigidity in the answers, aswell as the answering errors and their automatic appearance, which is inherentlyunnatural. Thus, an important part of the research community is working on howto make conversations more natural and more attractive to human interlocutors.

The objective of this project is the study of all the parameters that influencethe conversational agents, commonly called chatbots. The project is founded on

xiii

xiv Capítulo 0. Abstract

a conversational agent based on a dual LSTM encoder has been used to generateautomatic dialogue responses. We have chosen the Ubuntu Dialog Corpus (UDC)dataset for our dialogue responses, as it is one of the largest public dialog datasetsavailable. The reason why the Dual Encoder model is used is because its viabilityas a conversational agent has been reported and the results to be replicated arehigher to other models of recurrent neural networks. The tools used for programmingand analysis were TensorFlow for the implementation and training of the code andTensorBoard for an easy visualization of the obtained data. The whole project iswritten in the programming language Python.

Currently, the most used tool in the field of deep learning is TensorFlow, be-cause of the large number of possibilities offered, the ease of use and has extensivedocumentation and a large community of programmers. Some cutting-edge directexamples of this tool, in relation to this project are Google’s Smart Reply or GoogleTranslate.

The Retrieval-Based model provides the advantage of being able to relate andcompare an input comment with an output response, and assign this relationshipto a vector, which according to its size will tell us the quality of the response inrelation to the input. As for the LSTM neurons used in the model, they are verysuitable for the context memory they present during the conversation, giving us asignificant improvement in the results when talking with the conversational agent.

A little more in detail, a conversational agent is divided into two phases: thefirst one turns the dataset into a vocabulary, where each word is represented by anumerical vector; the second, divide the dataset and train a network with input andresponse phrases, where the sentences instead of being composed of words (strings),are composed of vectors that represent words (word embedding) to optimize thecomputational cost. After training the model the quality of the model is estimatedthrough evaluation metrics.

Some of the most remarkable general parameters of a conversational agent arethe number of layers and neurons per layer (this being a matrix) that is used in theneural network, these determine their learning capacity, the learning rate tells usthe speed with which the network will converge towards the solution ratio, the sizeof the batch tells us the number of input phrases that it compares in each iterationor step in its learning and finally the cost or loss function that is calculated alongthe training to know how much the predicted solution resembles the real one.

Keywords: conversational agent, retrieval-based model, conversation, LSTM, re-current neural network, tensorflow, tensorboard, machine learning, deep learning,artificial intelligence.

Índice general

Agradecimientos ix

Resumen xi

Abstract xiii

1 Introducción 11.1 Motivación del proyecto . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2 Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.3 Materiales utilizados . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.4 Estructura del documento . . . . . . . . . . . . . . . . . . . . . . . . . 3

2 Estado del arte 52.1 Procesamiento del Lenguaje Natural (NLP) . . . . . . . . . . . . . . . 5

2.1.1 Historia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.1.2 Sistemas basados en Reglas . . . . . . . . . . . . . . . . . . . . . 62.1.3 Machine learning . . . . . . . . . . . . . . . . . . . . . . . . . . 62.1.4 Algoritmos de Machine Learning . . . . . . . . . . . . . . . . . . 72.1.5 Deep learning o Aprendizaje Automático (DL) . . . . . . . . . . 102.1.6 Redes neuronales recurrentes (RNN) . . . . . . . . . . . . . . . . 122.1.7 Topología: Arquitectura y disposición neuronal de las RNN . . . 13

2.2 Gestión del diálogo: Redes LSTM . . . . . . . . . . . . . . . . . . . . . 142.2.1 Historia y actualidad . . . . . . . . . . . . . . . . . . . . . . . . 142.2.2 El problema de las dependencias a largo plazo . . . . . . . . . . 152.2.3 LSTMs RNN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162.2.4 Variantes en las LSTM . . . . . . . . . . . . . . . . . . . . . . . 172.2.5 Futuro de las LSTMs RNN . . . . . . . . . . . . . . . . . . . . . 18

2.3 Agentes conversacionales . . . . . . . . . . . . . . . . . . . . . . . . . . 182.3.1 Clasificación general . . . . . . . . . . . . . . . . . . . . . . . . . 19

2.4 Taxonomía de los modelos: Tipos de agentes conversacionales . . . . . 192.4.1 Retrieval-Based bots vs. Generative bots . . . . . . . . . . . . . 192.4.2 Conversaciones largas vs. cortas . . . . . . . . . . . . . . . . . . 212.4.3 Dominio abierto, semiabierto y cerrado . . . . . . . . . . . . . . 21

3 Marco Teórico 233.1 LSTM: Modelo basado en recuperación y algoritmos . . . . . . . . . . 233.2 Dataset: Ubuntu Dialog Corpus (UDC) . . . . . . . . . . . . . . . . . 253.3 Word embedding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3.3.1 Modelo del word embedding: GloVe . . . . . . . . . . . . . . . . 283.3.2 Representación del word embedding: t-SNE y PCA . . . . . . . . 28

xv

xvi Índice general

3.4 Fundamentos teóricos del modelo Dual Encoder LSTM . . . . . . . . . 313.4.1 Funcionamiento del modelo . . . . . . . . . . . . . . . . . . . . . 313.4.2 Arquitectura del modelo . . . . . . . . . . . . . . . . . . . . . . 323.4.3 Parámetros de la red . . . . . . . . . . . . . . . . . . . . . . . . 343.4.4 Entrenamiento de la red: Conceptos generales . . . . . . . . . . . 343.4.5 Función de puntuación de las predicciones: Recall@k . . . . . . . 39

3.5 Herramientas y metodología . . . . . . . . . . . . . . . . . . . . . . . . 403.5.1 Sistema operativo . . . . . . . . . . . . . . . . . . . . . . . . . . 403.5.2 Gestor de entornos . . . . . . . . . . . . . . . . . . . . . . . . . 413.5.3 Control de versiones . . . . . . . . . . . . . . . . . . . . . . . . . 413.5.4 Lenguaje de programación . . . . . . . . . . . . . . . . . . . . . 423.5.5 Entorno de Desarrollo Integrado (IDE) . . . . . . . . . . . . . . 423.5.6 Biblioteca . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443.5.7 Librerías . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443.5.8 Administrador de archivos . . . . . . . . . . . . . . . . . . . . . 46

4 Desarrollo del proyecto 494.1 Archivos y ficheros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494.2 Preprocesamiento de los datos . . . . . . . . . . . . . . . . . . . . . . . 504.3 Función de entrada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 514.4 Creando el modelo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524.5 Entrenamiento, validación y evaluación del modelo . . . . . . . . . . . 534.6 Métrica de evaluación: Recall@k . . . . . . . . . . . . . . . . . . . . . 554.7 Predicciones: Evaluar el modelo . . . . . . . . . . . . . . . . . . . . . . 574.8 Grafo del modelo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

5 Resultados y discusión 635.1 Resultados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 635.2 Entrenamiento, validación y test . . . . . . . . . . . . . . . . . . . . . 65

5.2.1 Grupo 1: Train 1, 2 y 3 . . . . . . . . . . . . . . . . . . . . . . . 655.2.2 Grupo 2: Train 4 y 5 . . . . . . . . . . . . . . . . . . . . . . . . 665.2.3 Grupo 3: Train 6 y 7 . . . . . . . . . . . . . . . . . . . . . . . . 685.2.4 Grupo 4: Train 8 y 9 . . . . . . . . . . . . . . . . . . . . . . . . 695.2.5 Grupo 5: Train 10, 11 y 12 . . . . . . . . . . . . . . . . . . . . . 705.2.6 Grupo 6: Train 13 y 14 . . . . . . . . . . . . . . . . . . . . . . . 725.2.7 Grupo 7: Train 15, 16 y 17 . . . . . . . . . . . . . . . . . . . . . 745.2.8 Grupo 8: Train 18 y 19 . . . . . . . . . . . . . . . . . . . . . . . 755.2.9 Grupo 9: Train 20 y 21 . . . . . . . . . . . . . . . . . . . . . . . 77

5.3 Resultados con PCA y t-SNE . . . . . . . . . . . . . . . . . . . . . . . 795.3.1 Representación en PCA . . . . . . . . . . . . . . . . . . . . . . . 795.3.2 Representación en t-SNE . . . . . . . . . . . . . . . . . . . . . . 80

5.4 Predicciones: Evaluar el modelo . . . . . . . . . . . . . . . . . . . . . . 865.5 Discusión . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

6 Gestión del proyecto 916.1 Ciclo de vida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 916.2 Planificación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

6.2.1 Planificación temporal . . . . . . . . . . . . . . . . . . . . . . . 936.2.2 Planificación inicial . . . . . . . . . . . . . . . . . . . . . . . . . 93

Índice general xvii

6.2.3 Planificación final . . . . . . . . . . . . . . . . . . . . . . . . . . 936.3 Presupuesto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

6.3.1 Personal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 956.3.2 Material . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 956.3.3 Resumen de costes . . . . . . . . . . . . . . . . . . . . . . . . . . 96

7 Conclusiones y líneas futuras 977.1 Conclusión . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 977.2 Líneas futuras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

7.2.1 Desafíos comunes . . . . . . . . . . . . . . . . . . . . . . . . . . 98

A Anexo documentación 101

B Anexo cursos 103

C Entorno socio-económico 105

Acrónimos 107

Bibliografia 109

Índice de figuras

2.1 Arquitectura de una red neuronal simple y profunda. [1] . . . . . . . . 112.2 Arquitectura de una red neuronal recurrente. [2] . . . . . . . . . . . . . 122.3 Arquitectura de una red neuronal recurrente genérica. [3] . . . . . . . . 132.4 Representación del problema en las largas dependencias en una RNN. [2] 152.5 Arquitectura interna de una red neuronal recurrente de tipo LSTM. [2] 162.6 Notación de la red neuronal recurrente de tipo LSTM. [2] . . . . . . . 162.7 Arquitectura de una red neuronal recurrente de tipo Seq2Seq para

traducciones. [4] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

3.1 Disposición datos de entrenamiento del archivo en formato CSV. [5] . . 263.2 Disposición datos de evaluación y evaluación del archivo en formato

CSV. [5] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263.3 Relación lineal de Word embedding. [6] . . . . . . . . . . . . . . . . . . 273.4 Visualización t-SNE de palabras embebidas. Izquierda: Región núme-

ros; Derecha: Región de empleos. [7]. . . . . . . . . . . . . . . . . . . . 283.5 Visualización t-SNE del espacio de palabras semánticas. [8] . . . . . . . 293.6 Visualización PCA. Los datos normalizados y proyectados después de

PCA, no perpendicularmente. [9] . . . . . . . . . . . . . . . . . . . . . 293.7 Visualización PCA. Los datos normalizados y proyectados después de

PCA, perpendicularmente. [9] . . . . . . . . . . . . . . . . . . . . . . . 303.8 Visualización PCA. Los datos normalizados y proyectados después de

PCA en 2D. [10] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303.9 Visualización PCA vs. t-SNE. Agrupamiento en 2 dimensiones usando

t-SNE vs PCA. [11] . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313.10Arquitectura interna de una LSTM de tipo Dual Encoder. [5] . . . . . 323.11Visualización gráfica del Descenso del Gradiente. [12] . . . . . . . . . . 363.12Variación de la tasa de aprendizaje. . . . . . . . . . . . . . . . . . . . . 363.13 Tux, logotipo de Linux. . . . . . . . . . . . . . . . . . . . . . . . . . . 403.14 Logotipo de Anaconda. . . . . . . . . . . . . . . . . . . . . . . . . . . 413.15 Logotipo de GitHub. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413.16 Logotipo de Bitbucket. . . . . . . . . . . . . . . . . . . . . . . . . . . . 423.17 Logotipo de Python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423.18 Logotipo de Pycharm IDE. . . . . . . . . . . . . . . . . . . . . . . . . 423.19 Logotipo de Visual Studio Code. . . . . . . . . . . . . . . . . . . . . . 433.20 Logotipo de Gedit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433.21 Logotipo de TensorFlow. . . . . . . . . . . . . . . . . . . . . . . . . . . 443.22 Logotipo de Numpy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453.23 Logotipo de Pandas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453.24 Logotipo de TFLearn. . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

xix

xx Índice de figuras

3.25 Logotipo de Jupyter. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463.26 Logotipo de Google Colab. . . . . . . . . . . . . . . . . . . . . . . . . . 46

4.1 Distribución directorios y archivos del proyecto. . . . . . . . . . . . . . 494.2 Gráfica que muestra las pérdidas respecto de los steps a lo largo del

entrenamiento. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 554.3 Gráfica que muestra el recall@1 respecto de los steps a lo largo del

entrenamiento. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564.4 Predicción de un ejemplo del UDC, de la respuesta y los 9 distractores

a una respuesta concreta. . . . . . . . . . . . . . . . . . . . . . . . . . 584.5 Predicción de un ejemplo introducido por el usuario. . . . . . . . . . . 584.6 Grafo que muestra el flujo de datos del modelo durante el entrenamiento. 604.7 Grafo que muestra el flujo de datos del modelo durante la evaluación. . 61

5.1 Pérdidas en los entrenamientos 4 y 5. . . . . . . . . . . . . . . . . . . . 665.2 Recall@k en el Train 4. . . . . . . . . . . . . . . . . . . . . . . . . . . 675.3 Recall@k en el Train 5. . . . . . . . . . . . . . . . . . . . . . . . . . . 675.4 Pérdidas Recall@10 para todos los entrenamientos. . . . . . . . . . . . 675.5 Pérdidas en los entrenamientos 6 y 7. . . . . . . . . . . . . . . . . . . . 685.6 Recall@k en el Train 6. . . . . . . . . . . . . . . . . . . . . . . . . . . 695.7 Recall@k en el Train 7. . . . . . . . . . . . . . . . . . . . . . . . . . . 695.8 Pérdidas en los entrenamientos 8 y 9. . . . . . . . . . . . . . . . . . . . 705.9 Recall@k en el Train 8. . . . . . . . . . . . . . . . . . . . . . . . . . . 705.10Recall@k en el Train 9. . . . . . . . . . . . . . . . . . . . . . . . . . . 705.11 Pérdidas en los entrenamientos 10, 11 y 12. . . . . . . . . . . . . . . . 715.12Recall@k en el Train 10. . . . . . . . . . . . . . . . . . . . . . . . . . . 725.13Recall@k en el Train 11. . . . . . . . . . . . . . . . . . . . . . . . . . . 725.14Recall@k en el Train 12. . . . . . . . . . . . . . . . . . . . . . . . . . . 725.15 Pérdidas en los entrenamientos 13 y 14. . . . . . . . . . . . . . . . . . 735.16Recall@k en el Train 13. . . . . . . . . . . . . . . . . . . . . . . . . . . 735.17Recall@k en el Train 14. . . . . . . . . . . . . . . . . . . . . . . . . . . 735.18 Pérdidas en los entrenamientos 15, 16 y 17. . . . . . . . . . . . . . . . 745.19Recall@k en el Train 15. . . . . . . . . . . . . . . . . . . . . . . . . . . 755.20Recall@k en el Train 16. . . . . . . . . . . . . . . . . . . . . . . . . . . 755.21Recall@k en el Train 17. . . . . . . . . . . . . . . . . . . . . . . . . . . 755.22 Pérdidas en los entrenamientos 18 y 19. . . . . . . . . . . . . . . . . . 765.23Recall@k en el Train 18. . . . . . . . . . . . . . . . . . . . . . . . . . . 765.24Recall@k en el Train 19. . . . . . . . . . . . . . . . . . . . . . . . . . . 765.25 Pérdidas Train 20. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 775.26Recall@k en el Train 20. . . . . . . . . . . . . . . . . . . . . . . . . . . 785.27 Pérdidas Train 21. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 785.28Recall@k en el Train 21. . . . . . . . . . . . . . . . . . . . . . . . . . . 795.29Representación PCA en 3D mostrando las agrupaciones por colores de

cada punto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 795.30Representación PCA en 3D mostrando las palabras de cada punto. . . 805.31Representación t-SNE en 2D con perplejidad 76. . . . . . . . . . . . . 815.32Representación t-SNE en 2D con perplejidad 76. . . . . . . . . . . . . 815.33Representación t-SNE en 3D con perplejidad 76. . . . . . . . . . . . . 825.34Representación t-SNE en 3D con perplejidad 76. . . . . . . . . . . . . 82

Índice de figuras xxi

5.35Representación t-SNE en 3D con perplejidad 100. . . . . . . . . . . . . 835.36Representación t-SNE en 3D con perplejidad 100. . . . . . . . . . . . . 835.37Representación t-SNE en 3D con perplejidad 38. . . . . . . . . . . . . 845.38Representación t-SNE en 3D con perplejidad 5, iteración 700. . . . . . 845.39Representación t-SNE en 3D con perplejidad 5, iteración 700. . . . . . 855.40Representación t-SNE en 3D con perplejidad 5, iteración 1200. . . . . . 855.41 Predicción de una respuesta ante un contexto aleatorio del UDC. . . . 865.42 Predicción de una respuesta ante un contexto aleatorio del UDC. . . . 865.43 Predicción de una respuesta ante un contexto aleatorio del UDC. . . . 875.44 Predicción de una respuesta ante un contexto introducido por el usuario. 87

6.1 Estructura de descomposición del trabajo. . . . . . . . . . . . . . . . . 926.2 Estructura de descomposición del proyecto. . . . . . . . . . . . . . . . 94

7.1 Respuestas incoherentes de un modelo conversacional. [4] . . . . . . . . 99

Índice de tablas

5.1 Tabla de los parámetros de entrenamiento. . . . . . . . . . . . . . . . . 645.2 Tabla de resultados recall@k . . . . . . . . . . . . . . . . . . . . . . . . 78

6.1 Presupuesto del personal. . . . . . . . . . . . . . . . . . . . . . . . . . 956.2 Presupuesto del material. . . . . . . . . . . . . . . . . . . . . . . . . . 966.3 Presupuesto total. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

xxiii

Capítulo 1

Introducción

Este capítulo trata de la explicación de la idea principal del proyecto, los agentesconversacionales. Seguidamente se hablará de los objetivos principales y secunda-rios del proyecto. Después se citarán los materiales usados, tanto hardware comosoftware. Finalmente se detallará el contenido de cada capítulo a desarrollar en estedocumento.

1.1. Motivación del proyecto

Este proyecto nace de la motivación de algún día poder mejorar la comunicacióncon inteligencias artificiales. Los agentes conversacionales son actualmente los méto-dos más utilizados para conversar con máquinas mediante el habla o la escritura. Lacomprensión de su funcionamiento es esencial para el futuro desarrollo de agentesconversacionales más inteligentes y funcionales.

Se han estudiado los conceptos y algoritmos básicos del aprendizaje automático,redes neuronales y aplicaciones a tareas concretas. Posteriormente, se han anali-zado las arquitecturas más utilizadas en los agentes conversacionales, incluyendolos parámetros de la red, los parámetros de entrenamiento y los del propio agenteconversacional.

Desde hace unas décadas se han estudiado diferentes tipos de redes neuronalesy modelos para la mejora de los agentes conversacionales, y con relativo éxito ahorapodemos utilizar inteligencias artificiales como Google Assistant, Siri o Cortanamediante texto y voz, sin embargo aún distan de ser perfectos.

El estudio de mejores algoritmos tanto en investigación como a nivel empresariales ahora mismo uno de los sectores donde más se está trabajando, considerándoselos agentes conversacionales un futuro bastante cercano.

El Grupo de Control Inteligente del Departamento de Automática, IngenieríaElectrónica e Informática Industrial del Centro de Automática y Robótica (CSIC-UPM) en la Escuela Técnica Superior de Ingenieros Industriales de la Universidad

1

2 Capítulo 1. Introducción

Politécnica de Madrid, es un claro ejemplo de la importancia que tiene la InteligenciaArtificial (AI) en el mundo de la investigación, usando aprendizaje automático paraprácticamente todos los estudios que realizan. Junto a este laboratorio se ha llevadoa cabo el estudio de este proyecto.

1.2. Objetivos

Los principales objetivos a cumplir durante el desarrollo del proyecto han sidolos siguientes:

Aprendizaje de conceptos y algoritmos básicos de aprendizaje automático.

Aprendizaje de redes neuronales aplicadas a agentes conversacionales.

Búsqueda, selección y tratamiento de datos de entrenamiento.

Estudio del estado del arte a través de publicaciones relacionadas.

Análisis y optimización de parámetros críticos de los modelos.

Colaboración en líneas de investigación del Grupo de Control Inteligente.

Adicionalmente, durante la evolución del estudio de los agentes conversacionaleshan ido apareciendo objetivos secundarios que se consideran de especial interés parala programación y análisis de los algoritmos. Dichos objetivos son los siguientes:

Aprendizaje de herramientas como TensorFlow y TensorBoard.

Aprendizaje del lenguaje de programación Python y las librerías Numpy yScipy.

Aprendizaje de Anaconda, generador de entornos y distribuciones de Python.

1.3. Materiales utilizados

Como hardware se ha usado un HP ProBook-6470b con procesador Intel i5 conCPU de 2,60 GHz y 8 GB de memmoria RAM. Como sistema operativo se hautilizado Linux, concretamente Ubuntu 16.04 LTS.

El software objeto de análisis de este proyecto ha sido la implementación de unmodelo de agente conversacional Dual LSTM Encoder for Dialog Response Gene-ration del repositorio1 de Denny Britz [13] en GitHub, donde está desarrollado elagente conversacional “Retrieval-Based Conversational Model in Tensorflow (Ubun-tu Dialog Corpus)”. Además se han usado diferentes herramientas de software comoTensorFlow, Python y UDC, entre otras. Todas estas herramientas serán explicadasmás adelante.

1https://github.com/dennybritz/chatbot-retrieval

https://github.com/dennybritz/chatbot-retrieval

https://github.com/dennybritz/chatbot-retrieval

1.4. Estructura del documento 3

1.4. Estructura del documento

A continuación se explicará brevemente los diferentes capítulos que forman eldocumento, el cual esta compuesto por un índice general, un índice de figuras, uníndice de tablas, siete capítulos, dos apéndices y la bibliografía.

Capítulo 1, se realiza una introducción a grandes rasgos de lo que nos vamosa encontrar en el documento, también se explican los objetivos principales ysecundarios y por último los materiales usados durante el proyecto.

Capítulo 2, se expone la situación actual del procesamiento de lenguaje natural,de los agentes conversacionales, su clasificación, métodos, topología y tipos.

Capítulo 3, se detalla en diferentes apartados como se desarrolla el flujo dedatos dentro de un agente conversacional.

Capítulo 4, se hace un repaso de los algoritmos y modelos usados en los agentesconversacionales. Se explica el funcionamiento y los parámetros usados en elagente conversacional que hemos usado. Se describen las herramientas y losmétodos usados en el análisis del agente conversacional. Finalmente se explicanalgunos aspectos teóricos del modelo usado en el proyecto.

Capítulo 5, se exponen los resultados obtenidos en el proyecto y se realiza unadiscusión de los mismos.

Capítulo 6, se realiza un análisis de la gestión que se ha llevado a cabo duranteel proyecto, teniendo en cuenta su planificación y presupuesto.

Capítulo 7, se explican las conclusiones finales del proyecto, así como los posiblesdesarrollos futuros que puede tener el proyecto.

Apéndice A, se explica la documentación utilizada como guía en el proyecto.

Apéndice B, se explica los cursos hechos como formación inicial en el proyecto.

Apéndice C, se exponen los cursos realizados durante el proyecto que han per-mitido desarrollar el mismo.

Capítulo 2

Estado del arte

En este capítulo vamos a repasar los diferentes estudios que conforman la situa-ción actual de los agentes conversaciones. Empezaremos por el Procesamiento delLenguaje Natural, seguidamente los aspectos más generales de los agentes conver-sacionales, situándolo en el marco del aprendizaje automático. Por último, se veránlos diferentes tipos de agentes conversacionales y los principales factores que losdistinguen.

2.1. Procesamiento del Lenguaje Natural (NLP)

El NLP [14] es el campo de la Inteligencia Artificial que se encarga de comunicarlas máquinas con las personas, a través del uso de lenguas naturales como puedenser el español o el inglés. La lengua más utilizada en el NLP es el inglés, por suinterés económico y su uso en la práctica, al ser el más utilizado en el mundo de losnegocios. De cualquier forma, se puede utilizar y desarrollar el NLP en diferenteslenguas.

Algunas de las aplicaciones más destacadas del NLP es el procesamiento tantode texto como de audio, siendo el primero del que tenemos mayor número de datosen las bases de datos con los que tratar, por lo que es el más desarrollado. En cuantoa los audios, primero hay que transcribirlos a texto para poder procesarlos, despuésse volverá a pasar a audio para poder reproducirlo.

Claros ejemplos de Inteligencia Artificial pueden ser Siri, Google Assistant oCortana. Estos tres agentes conversacionales son los más avanzados en el mercado,pudiendo hablar en multitud de idiomas sin problema.

2.1.1. Historia

El NLP comienza en 1950 con la publicación de Computing Machinery and In-telligence [15] de Alan Turing, donde se propuso el famoso Test de Turing, conside-

5

6 Capítulo 2. Estado del arte

rándose un criterio sobre si una máquina una comprensión automática del lenguajenatural, es decir, tiene la habilidad de comportarse como un humano.

El experimento de Georgetown [16] en 1954 se hizo la traducción automáticadesde el ruso al inglés de más de sesenta frases. Los resultados tuvieron gran éxito yllevaron a creer a los autores que en unos pocos años la traducción automática seríacasi perfecta, sin embargo, en ambientes no controlados y con vocabularios másgenéricos, se dieron cuenta de las grandes dificultados que suponía la traducciónautomática. El progreso real en traducción automática fue más lento y después delreporte ALPAC 1 en 1966, donde se critica el experimento y se demuestra su bajorendimiento. No sería hasta finales de 1980, cuando se empezaron a investigar losprimeros sistemas de traducción automática basados en la estadística, siendo posiblegracias a la mejora en la velocidad de cálculo de los ordenadores.

Los siguientes años se empezaron a desarrollar los primeros enfoques de apren-dizaje automático, como los árboles de decisiones, los sistemas basados en reglashechas a mano, comparable a las declaraciones if-else en programación, entre otros.Durante este proyecto, se utiliza un enfoque que ha evolucionado bastante en lasdos últimas décadas, las redes neuronales.

En los últimos años, las mejoras han venido de la mano del procesamiento delas grandes cantidades disponibles de corpus en formato digital. Como resultadotenemos como ejemplos los motores de búsqueda web, Google’s Smart Reply [17] oGoogle Translate [18].

2.1.2. Sistemas basados en Reglas

Las reglas lingüísticas constituyen una técnica capaz de ejercer de interfaz entreel modo de razonamiento humano y el de procesamiento de un ordenador. Estasreglas hacen uso de términos lingüísticos y siguen una estructura condicional com-puesta por antecedentes y consecuentes, conformando sentencias condicionales deltipo “si X entonces Y”, fácilmente comprensibles por un ser humano a la par queprocesables por un algoritmo. Estas reglas también se conocen como reglas de infe-rencia debido a su capacidad de inferir conclusiones a partir del conocimiento actualdel entorno.

2.1.3. Machine learning

Tal y como indica la comunidad de IBM 2, una posible forma de definir elmachine learning es la establecida por Arthur Samuel uno de los padres del machinelearning, quien además acuñó este mismo término y lo definió como sigue: ArthurSamuel (1959). Machine Learning: Field of study that gives computers the abilityto learn without being explicitly programmed. Más tarde Tom mitchell, uno de losmayores expertos en machine learning propuso una definición más precisa: TomMitchell (1998) Well-posed Learning Problem: A computer program is said to learn

1http://www.mt-archive.info/ALPAC-1966.pdf2https://www.ibm.com/developerworks/community/blogs/jfp/entry/What_Is_Machine_Learning?lang=en

http://www.mt-archive.info/ALPAC-1966.pdf

https://www.ibm.com/developerworks/community/blogs/jfp/entry/What_Is_Machine_Learning?lang=en

http://www.mt-archive.info/ALPAC-1966.pdf

https://www.ibm.com/developerworks/community/blogs/jfp/entry/What_Is_Machine_Learning?lang=en

2.1. Procesamiento del Lenguaje Natural (NLP) 7

from experience E with respect to some task T and some performance measure P, ifits performance on T, as measured by P, improves with experience E.

Esta primera forma de describir el Machine Learning (ML) habla sobre la cons-trucción de máquinas, tanto hardware como software. Una segunda forma de definirlosería a través de los algoritmos, los cuales se diferencian en que necesitan un set deejemplos de los que aprender mediante entrenamiento. De estos últimos hablaremosmás adelante.

El ML a aportado nuevas capacidades para los ordenadores, dividiéndose endos grandes grupos: los sistemas que se encargan de eliminar la necesidad de unexperto en el análisis de los datos para el correcto funcionamiento y los sistemasque se encargan de colaborar con los expertos. De todas formas, la necesidad deprogramación humana y la caracterización de los mismos para procesar los datos essiempre de obligado cumplimiento.

El ML tiene múltiples aplicaciones en nuestra vida cotidiana. Algunos de losejemplos más reconocibles actualmente son:

Minería de datos, grandes conjuntos de datos provenientes del crecimiento de laautomatización y las webs. Por ejemplo: datos de clicks en las webs o tambiénde registros de médicos, biólogos o ingenieros.

Aplicaciones que no pueden ser programadas a mano. Por ejemplo: helicópterosautónomos, reconocimiento de escritura a mano, la mayoría de los modelos delNLP.

Programas de auto-personalización. Por ejemplo: Amazon, recomendación deproductos en Netflix.

Comprensión del aprendizaje humano. Por ejemplo: el cerebro o la AI real.

2.1.4. Algoritmos de Machine Learning

Podemos agrupar los algoritmos de machine learning en una taxonomía en fun-ción de sus salidas. Estos son los distintos tipos que existen:

2.1.4.1. Reducción dimensional

Este algoritmo es un proceso capaz de reducir [19] la cantidad de variablesaleatorias y obtener unas variables características, las cuales ocupan menos espacio yesto ahorra muchos costes computacionales. El algoritmo puede seleccionar o extraerunas características en concreto.

En la selección de características (atributos), se buscan subconjuntos de lasvariables que teníamos en el origen. En el nuevo espacio más reducido es más fácilaplicar la regresión o la clasificación como métodos de análisis.


En la extracción de características se reduce la dimensión del espacio por mediode la transformación de los datos. El método más popular de transformación dedatos es el Análisis de Componentes Principales (PCA), siendo esta una técnicalineal. Por otro lado, también existen métodos no lineales.

2.1.4.2. Ensemble Learning

Los algoritmos de conjunto se utilizan para combinar varios métodos de ML ala vez, obteniendo rendimientos en la predicción del sistema mucho mayores que losque se obtendrían con los mismos métodos por separado. Además, en conjunto estosmétodos tienen una flexibilidad superior a la hora de afrontar diferentes tipos deproblemas.

Debido a la dificultad de encontrar hipótesis óptimas en algunos problemas, losmétodos de conjunto combinan múltiples hipótesis para dar como resultado unamejor. Este cálculo de múltiples hipótesis conlleva muchísimos más cálculos, lo quese traduce en un coste computacional mayor, por lo que, el aprendizaje conjuntosolo se suele usar combinando algoritmo rápidos como el árbol de decisión.

2.1.4.3. MetaAprendizaje

Este algoritmo se encarga de aplicar métodos de machine learning a metadatosque describen otros algoritmos de machine learning. La idea principal es mejorar elrendimiento de los algoritmos, aumentar la flexibilidad para resolver problemas delos propios algoritmos o aprender de ellos, es decir, aprende a aprender. Utilizandodiferentes tipos de metadatos podemos utilizar diferentes tipos de algoritmos pararesolver el problema y ver cual se ajusta más a la solución objetivo.

A menudo, la efectividad de un algoritmo y el problema del aprendizaje desdeuna base de datos tiene una relación de difícil comprensión. Esto dificulta la posi-bilidad de poder utilizar distintas técnicas para un mismo problema y conocer elporqué unas funcionan mejor que otras. Por lo tanto, la flexibilidad a la hora deutilizar un método u otro es importante, ya que, cada uno trabaja bien con unosparámetros en particular, y el problema ha de coincidir con ellos o no se obtendránbuenos resultados.

2.1.4.4. Aprendizaje supervisado

El aprendizaje supervisado es la rama del ML encargada de calcular una pre-dicción de salida tras aprender a través de una función de los datos que se le hanaportado. Estos datos suelen ser vectores que contienen la información de entraday su salida correspondiente, para con ellos poder entrenar a la red produciendo unafunción, la cual más tarde se usará para poder hacer predicciones ante entradasnunca vistas por la red.


El algoritmo entrena una función que representa la relación entre las entradasaportadas y las salidas esperadas. Un ejemplo muy básico es el que trata de predecirel precio de un inmueble, tras haber entrenado la red con miles de casos reales,donde se le aporta a la red los datos de entrada y las salidas reales a esos datos,para entrenarla y aprenda a hacer predecir el precio de salida según unos datos deentrada nunca vistos por la red en el entrenamiento.

Existen diferentes algoritmos de aprendizaje supervisado, cada uno destacable enun tipo de problema, no hay ninguno que sea bueno en todos los tipos de problemas.Los algoritmos de aprendizaje más utilizados son:

Máquinas de soporte vectorial.

Regresión lineal.

Regresión logística.

Naive Bayes.

Análisis discriminante lineal.

Árboles de decisión.

k-vecinos más próximos.

Redes neuronales (perceptrón multicapa).

2.1.4.5. Aprendizaje no supervisado

El aprendizaje no supervisado es la rama del ML encargada de producir unafunción que clasifique o categorice la estructura no visible de un conjunto de ejemplosno etiquetados aportados al sistema. Estos datos al no poder ser etiquetados, sedesconoce la información de sus salidas, la propia red deberá encontrar los patronesa través de la función de la red neuronal para poder etiquetar y estructurar lasnuevas entradas. Al no disponer de las salidas reales correspondientes a las entradasrespectivas, no se puede medir o evaluar la precisión de la estructura producida porel algoritmo de la red.

El aprendizaje no supervisado está basado en el principio de la redes neuronalesnaturales de Donald Hebb en su libro The Organization of Behavior 3, donde esta-blece que las neuronas que se activan a la vez están conectadas entre sí. La hipótesisde Hebbian Learning ayuda a la función a aprender como las neuronas, teniendo encuanta el tiempo que tardan las neuronas naturales en aprender u olvidar. Algunosejemplos prácticos del aprendizaje no supervisado son la agrupación de spam en elcorreo electrónico o de usuarios en redes sociales. Los enfoques para el aprendizaje

3https://www.ncbi.nlm.nih.gov/pubmed/10643472

https://www.ncbi.nlm.nih.gov/pubmed/10643472

https://www.ncbi.nlm.nih.gov/pubmed/10643472


no supervisado incluyen:

Clustering.

Detección de anomalías.

Redes neuronales.

Enfoques para el aprendizaje de modelos variables latentes.

2.1.4.6. Aprendizaje semisupervisado

El aprendizaje semisupervisado es la rama del ML que combina los dos últimosalgoritmos explicados, el supervisado y el no supervisado para obtener una mejoraimportante en la precisión del aprendizaje. Este tipo de algoritmo hace uso de datosetiquetados y no etiquetados. Normalmente se alimenta la red con una pequeñacantidad de datos etiquetados y una basta cantidad de datos no etiquetados.

Este método es útil en situaciones donde la cantidad de datos es enorme y unetiquetado completo requiere una cantidad de tiempo ingente por parte del factorhumano, ya que los datos etiquetados han de realizarse a mano. Con este algoritmosolo se requiere de la etiquetación de unos pocos datos de entrada y el resto dedatos pueden continuar sin etiqueta, el resultado será muchísimo mayor que si seusará un algoritmo no supervisado con todos los datos sin etiquetar o un algoritmosupervisado descartando todos los datos sin etiquetar.

2.1.4.7. Aprendizaje por refuerzo

El aprendizaje por refuerzo es la rama del ML se encarga de aprender observandoel mundo que le rodea. Los datos de entrada son la retroalimentación que obtienea sus acciones y trata de maximizar una recompensa acumulativa. El algoritmo sedesenvuelve en un entorno desconocido y nadie le enseña a que acciones tomar, debeprobar todas las acciones posibles y averiguar cuáles le dan la mayor recompensa.

Este tipo de algoritmos no siguen un modelo matemático, se basan en la decisión.Se tiene que elegir constantemente que datos de salida elegir, intentando maximizarel rendimiento entre los datos ya conocidos y los que quedan por conocer, ya que,los nuevos datos solamente realimentan los ya conocidos.

2.1.5. Deep learning o Aprendizaje Automático (DL)

El Aprendizaje Profundo (DL) es una rama del machine learning, aunque algunosautores lo consideran como una familia de aprendizaje automático diferente. Eldeep learning puede usar métodos de aprendizaje supervisado, semisupervisado ono supervisado. Todos estos algoritmos están basados la probabilidad, utilizando asíel teorema de la aproximación universal o de la inferencia probabilística.


Las arquitecturas de deep learning más utilizados son:

Redes Neuronales Profundas (DNN).

Redes de Creencias Profundas (DBN).

Redes Neuronales Recurrentes (RNN).

Redes Neuronales Convolucionales (CNN).

Todas estas clases de redes tienen múltiples aplicaciones como en el procesa-miento del lenguaje natural, visión artificial, reconocimiento de voz o audio, filtradode redes sociales, traducción automática, bioinformática y diseño de fármacos. Enalgunos casos han desempeñado resultados mejores que los de los humanos.

El DL está vagamente bioinspirado en las redes neuronales animales y el sistemanervioso, siendo parecido el funcionamiento del procesamiento y comunicación de lainformación. La mayor parte de los métodos de deep learning se basan en redes neu-ronales artificiales, las cuales tienen una estructura que posee propiedades diferentesa las reales.

Las Redes Neuronales (NN) están esencialmente estructuradas en una cascadade varias capas de múltiples unidades de procesamiento no lineales, llamadas neu-ronas. Cada neurona tiene unos pesos numéricos que determinan la importancia deesa neurona en la capa, estos se adaptan según la experiencia que va adquiriendola red con el aprendizaje. De esta manera, las neuronas se adaptan a un impulsoy son capaces de aprender. Cada capa sucesiva usa como entrada la informaciónde salida de la capa anterior. Estas capas se encargan de procesar la información,para seguidamente obtener y transformar sus características. En cada una se cogeuna parte de la información, para después las neuronas aprender a abstraer y trans-formar los datos que les entran en una representación más abstracta y compuesta.La red es capaz de aprender que características abstraer y seleccionar por si mismapara aumentar el rendimiento, aunque siempre hace falta un factor humano para laelección de las características. Finalmente se obtiene una hipótesis de salida tras laúltima capa.

Figura 2.1: Arquitectura de una red neuronal simple y profunda. [1]


Las DNN están compuestas de una Red Neuronal Artificial (ANN), con capasocultas dispuestas entre la entrada y la salida. Como se puede ver en la imagensuperior (figura 2.1), la arquitectura de las redes neuronales pueden tener multitudde disposiciones de las capas y las neuronas, variando el número de ambas. Cadaarquitectura tiene un propósito específico.

Las DNN suelen tener un flujo de datos desde la capa de entrada hacia la desalida, pero existen otro tipos de arquitecturas que permiten otro tipo de flujos.Algunos de estos tipos son las CNN, las cuales se usan en visión artificial o en modelospara el Reconocimiento Automático de Voz (ASR). Otro ejemplo son las RNN, dondela información puede fluir en cualquier dirección, esto facilita la memoria de lainformación a lo largo del tiempo, lo que hace a esta arquitectura la más usada parael NLP, habiendo demostrado ser prometedoras en muchas tareas de este campo,como la que nos concierne en este proyecto, los agentes conversacionales.

2.1.6. Redes neuronales recurrentes (RNN)

Las redes neuronales recurrentes son un tipo de red neuronal artificial, dondecada nodo está conectado al siguiente a lo largo de una secuencia. Esta disposiciónpermite que la información viaje de forma dinámica durante el tiempo. Aprovechan-do esta dinamicidad de la información permite que el estado interno (memoria) decada nodo pase entre los nodos de la red y sea visible por todos ellos, pudiendo“recordar” estados. Esta cualidad hace idóneas a este tipo de redes para procesar elreconocimiento de escritura o voz.

Figura 2.2: Arquitectura de una red neuronal recurrente. [2]

Si quisiéramos predecir la palabra siguiente en una oración, sería de especialutilidad que supiéramos la palabra que precede a la palabra que queremos predecir.Como se puede ver en la imagen superior (figura 2.2), si Xn son las palabras deentrada de la oración y hn las respuestas en salida, el contexto de la frase es trans-mitido a lo largo del tiempo por la línea horizontal entre nodos A. Dependiendodel número de palabras de la oración, la red se desenrollará en tantas capas comopalabras haya. Esta acción se repite recurrentemente (de ahí viene el nombre de estetipo de red neuronal) para cada oración de entrada, dependiendo la salida de cadacálculo previo.

Las RNN se diferencian de las normales en que cada capa no utiliza diferentesparámetros, en este tipo de redes todas las capas comparten los mismos parámetros,para diferentes entradas. Esto nos ayuda a reducir considerablemente el número deparámetros que vamos a necesitar aprender en la red.


El tipo más utilizado en el NLP de RNN son las long short-term memory(LSTM), las cuales son las que mejor capturan las dependencias a largo plazo. EstasLSTM serán las que usaremos para desarrollar el agente conversacional durante elproyecto. Otro tipo de redes neuronales recurrentes que han tenido bastante éxitoen el NLP son las redes neuronales recurrentes, las cuales se caracterizan por tenerun mismo conjunto de ponderaciones recursivas para distintos tamaños de entrada.

Algunas otras aplicaciones de las RNN son el modelado de lenguaje y generaciónde texto [20] [21] [22], máquina traductora [23] [24] [25], reconocimiento de voz [26] ogenerando descripciones de imagen [27]. En la publicación de Andrej Karpathy, TheUnreasonable Effectiveness of Recurrent Neural Networks 4, se pueden ver muchasde las grandes proezas que se han conseguido con las RNN.

2.1.7. Topología: Arquitectura y disposición neuronal de las RNN

Las redes neuronales recurrentes más básicas tienen como arquitectura una seriede nodos parecidos a neuronas, conectando cada nodo de forma unidireccional a losotros nodos. Cada nodo (neurona) tiene una señal de activación diferente que varíaen función del tiempo. Cada conexión (sinapsis) depende de un peso modificable,siendo este un número real. Respecto a ls nodos, hay de entrada, los cuales recibenlos datos del exterior, nodos ocultos que modifican los datos en el interior de lared, y por último los nodos de salida, que evalúan el rendimiento en función de losresultados.

Figura 2.3: Arquitectura de una red neuronal recurrente genérica. [3]

Las RNN pueden configurarse como aprendizaje supervisado en tiempo discreto,donde evalúa cada vector de entrada de uno en uno. La salida (resultado) solamentedependerá de ese vector de entrada concreto. El vector de entrada activará diferentesnodos, y la suma ponderada de todas estas activaciones dará la función de salida.

También se pueden configurar en como aprendizaje por refuerzo, aunque no sele pueden aportar señales objetivas de si la salida es correcta o no, hay funciones deaptitud o recompensa que evalúan el rendimiento de la RNN, utilizando actuadoresy viendo como la red actúa con el entorno.

4http://karpathy.github.io/2015/05/21/rnn-effectiveness/

http://karpathy.github.io/2015/05/21/rnn-effectiveness/



14 Capítulo 2.

En ambas configuraciones se producen errores en las secuencias de activación,debido a las desviaciones respecto al objetivo a alcanzar, es decir, la salida no esexactamente la esperada. La suma de todos los errores producidos a lo largo delasecuencia de activación nos dará el error total.

Existen multitud de arquitecturas en las redes neuronales recurrentes. A conti-nuación, se muestra los diferentes tipos que hay:

Totalmente recurrente

Independientemente recurrente (IndRNN)

Recursivo

Hopfield

Redes Elman y redes Jordan

Estado del eco

Compresor de historia neural

Larga memoria a corto plazo

Unidad recurrente cerrada

Bidireccional

Tiempo continuo

Jerárquico

Red de perceptrón multicapa recurrente

Modelo de múltiples escalas de tiempo

Máquinas Neural Turing

Computadora neuronal diferenciable

Autómata de inserción de redes neuronales

La red que hemos utilizado en este proyecto será la Long Short-Term Memory(LSTM), por la memoria que presenta, la cual nos ha sido muy útil a la hora derecordar contextos en las frases para poder hacer mejores predicciones.

2.2. Gestión del diálogo: Redes LSTM

2.2.1. Historia y actualidad

Las redes neuronales recurrentes fueron desarrolladas a lo largo de la décadade 1980, una década después se desarrollaron las LSTM, en 1997 por Hochreitery Schmidhuber [28]. Las LSTM reciben ese nombre por la enorme memoria que

2.2. Gestión del diálogo: Redes LSTM 15

presentan en un plazo de tiempo breve. Este sistema de DL además evita el problemadel gradiente de fuga [29], que tanto sufren las redes neuronales recurrentes. Estáncompuestas por una serie de puertas recurrentes, que nos ayuda a olvidar datos queno necesitamos.

Por otro lado, pueden recordar datos importantes que ocurrieron miles de pasosantes, lo que habilita a la LSTM a aprender tareas en función de los errores quevaya acumulando. Para desarrollar y aprender su matriz de pesos, habitualmente seusa la Clasificación Temporal Conexionista (CTC) [30], con el fin de aumentar laprobabilidad en la obtención de mejores resultados.

Alrededor de 2007, las LSTM empezaron a revolucionar el reconocimiento de voz,superando todos los modelos más actuales hasta la fecha, ya que funcionan increíble-mente bien en una gran variedad de problemas. Por ejemplo, en el reconocimientode voz, modelado de lenguaje, traducción, subtítulos de imágenes, conversación, etc.

2.2.2. El problema de las dependencias a largo plazo

Las RNN tienen la capacidad de utilizar información reciente para predecir elresultado de una tarea actual. En el caso de que la información que necesitamos estámuy atrás en el tiempo, en teoría las RNN son capaces de utilizar esas “dependenciasa largo plazo”, sin embargo, en la práctica, no ocurre así. El problema fue estudiadopor Hochreiter (1991) [31] y Bengio, et al. (1994) [32], donde se explican algunas delas posibles razones para que esto ocurra. Ilustremos este problema con un ejemplo.

Figura 2.4: Representación del problema en las largas dependencias en unaRNN. [2]

Si decimos “Las nubes están en el cielo.”, es fácil para una RNN predecir lapalabra cielo, en relación a nubes. Por otro lado, si decimos “Crecí en España...hablo español con fluidez.”, para deducir el idioma español necesitamos de la palabraEspaña, pero puede estar contextualizada al principio de la conversación, en estecaso, la RNN no sería capaz de deducir la palabra español.

Por suerte, este problema se reduce en las LSTM, ya que sí pueden almacenarlos contextos a largo plazo.

16 Capítulo 2.

2.2.3. LSTMs RNN

Las “LSTMs Networks” son RNN, éstas forman parte de la arquitectura de lasRNN. Son el tipo de celdas que compone una capa de una RNN, donde se hacen loscálculos. En esta función se utilizan una memoria (celdas) donde se tienen en cuentael estado (contexto) anterior y el actual. En las celdas se decide que datos recordary cuales olvidar en la memoria. Después combinan ambos estados y la informaciónde entrada.

Todas las RNN tienen una forma de cadena con módulos de rede neuronal re-petitivos, y dentro de cada uno una sola capa tanh. Las LSTM tienen la mismaestructura de cadena, pero el módulo que se repite, es diferente, no tiene solamenteuna capa sino cuatro, interactuando unas con otras.

Figura 2.5: Arquitectura interna de una red neuronal recurrente de tipoLSTM. [2]

Figura 2.6: Notación de la red neuronal recurrente de tipo LSTM. [2]

En la figura superior, en cada celda entra por un nodo un vector desde el nodode salida de la celda anterior. El círculo rosa representa un operación, en los cuadrosamarillos se ilustran capas de aprendizaje de redes neuronales. Respecto a las líneas,las que convergen significan concatenación y las que divergen son la copia del vector.

2.2.3.1. La idea central detrás de las LSTM

El concepto más importante en las LSTM es la memoria, en la Figura 2.5 estarepresentado en la linea horizontal superior. A lo largo de esa línea se transportael estado de un nodo a otro a través de las celdas, con ligeros o ningún cambio,pudiendo agregar o eliminar información, siendo esta información regulada por unasestructuras llamadas puertas “olvidar”.

2.2. Gestión del diálogo: Redes LSTM 17

En estas puertas se permite pasar la información o se bloquea y desecha, de-pendiendo de su importancia. La puerta está formada por una capa sigmoidea, queaporta un valor entre 0 y 1, representando cuanta información dejar pasar u olvidary una operación de multiplicación, que hace efectivo ese valor en la memoria. LasLSTM tienen tres puertas como esta en cada módulo repetitivo, para proteger ycontrolar el estado de la celda.

2.2.4. Variantes en las LSTM

No todas las LSTM son iguales, de hecho hay multitud de variantes, aunquesolamente sean ligeras variaciones. Una buena comparación entre las más popularesvariantes fue estudiada por Greff, et al. (2015) [33], demostrando que son todasprácticamente iguales. Por otro lado, Jozefowicz, et al. (2015) [34] probó más dediez mil arquitecturas de RNN, encontrando algunas con un rendimiento superiora algunas LSTM en ciertas tareas. A continuación, se muestran algunas de las máspopulares:

2.2.4.1. Conexiones de mirilla

Una variante muy popular es la creada por Gers & Schmidhuber (2000) [35],donde se permite que las puertas de la LSTM puedan mirar el estado, es decir,como entrada a las capas de puerta se introduce también el estado de la celda.Pudiendo variar a su vez esta versión permitiendo q todas o algunas puertas tenganel estado como dato de entrada.

2.2.4.2. Puertas de entrada y olvidar

Otra variación es unir las puertas de entrada y olvidar, es decir, tomar la decisiónde que estados recordar y cuáles olvidar a la vez, haciendo que solamente podamosrecordar un valor si olvidamos otro.

2.2.4.3. Unidad Recurrente Cerrada (GRU)

Esta variación fue introducida por Cho, et al. (2014) [36], como en la anteriorvariante combina las puertas de entrada y olvidar en una sola llamada “puerta deactualización”, además une el estado de la celda, con el estado oculto y hace algunosotros cambios. El modelo final es más simple que una LSTM estándar, con lo quese ha vuelto bastante popular.

Ligeramente más dramática en el LSTM es la Unidad Recurrente Gated o GRU,introducida por Cho, et al. (2014). Combina las puertas de olvidar y de entrada enuna sola “puerta de actualización”. También combina el estado de la celda y el estadooculto, y realiza algunos otros cambios. El modelo resultante es más simple que losmodelos LSTM estándar, y se ha vuelto cada vez más popular.

18 Capítulo 2.

2.2.4.4. Otras variantes

Algunas otras variantes pueden ser la “profundidad cerrada” (Gated Depth) deYao, et al. (2015) [37] o un enfoque poco tradicional de como abordar las depen-dencias a largo plazo, como se muestra en el “Aparato de relojería” (Clockwork) deKoutnik, et al. (2014) [38].

2.2.5. Futuro de las LSTMs RNN

Las LSTM fueron una revolución dentro de las RNN y se cree que el siguientepaso es la “Atención” (Attention). En este nuevo modelo la idea es permitir que cadaRNN elija la información de un conjunto más grande de información. El mecanismoAtención se basa en la visión humana, cuando se mira una imagen, enfocamos ciertade la misma y el resto se percibe con la visión periférica, Atención hace básicamenteesto, mostrando una alta resolución en una parte de la imagen y una baja resoluciónen el resto, después se ajusta el punto focal a lo largo del tiempo. Por ejemplo, enel estudio de Xu, et al. (2015) [39] se hace usa una parte concreta de una imagen,para sacar la información que se utilizará para poner título a esa misma imagen.

Otros modelos muy prometedores son el de LSTM de tipo “Cuadrícula” (Grid),desarrollado por Kalchbrenner, et al. (2015) [40].

Por último los modelos generativos son también una propuesta muy interesanteen la que encaminarse, trabajos destacados son los de Gregor, et al. (2015) [41],Chung, et al. (2015) [42], o Bayer & Osendorfer (2015) [43].

2.3. Agentes conversacionales

Los agentes conversacionales (CA), también llamados sistemas de diálogo, sonactualmente una herramienta que todas las grandes empresas están incorporandopara cambiar la forma en la que sus usuarios interacción con sus servicios, comopor ejemplo Microsoft (Cortana), Facebook (M), Apple (Siri), Google (Google As-sistant), entre otras.

Esta tendencia intenta mantener conversaciones naturales lo más parecidas a lashumanas, con una estructura coherente, utilizando softwares basados en NLP y endeep learning para ello. La comunicación con ellos se puede hacer mediante texto,habla, gestos, sistemas hápticos u otros métodos de entrada y salida.

Tal y como dijo Markus M. Berg en 2014 “A Natural Dialogue System is a formof dialogue system that tries to improve usability and user satisfaction by imitatinghuman behaviour” [44]. Debido a la limitación en el diálogo y la conversación seintenta hacer que los agentes conversacionales aprendan de los diálogos de personaa persona para integrarlos a las conversaciones humano-máquina, con el fin de quelas conversaciones no sean solamente preguntas y respuestas, sino que se establezcaun diálogo. Todos los aspectos que envuelven esta idea están siendo investigados

2.4. Taxonomía de los modelos: Tipos de agentes conversacionales 19

activamente en la actualidad, pero aún faltan muchas herramientas para que muchosde esos proyectos lleguen a buen puerto.

En esta sección y la siguiente se repasarán las técnicas, situación actual y posi-bilidades de los agentes conversacionales.

2.3.1. Clasificación general

No todos los agentes conversacionales han sido creados igual, pueden tener di-ferentes niveles de complejidad en la interfaz o en su capacidad de realizar accionesdemandadas por el usuario. Vamos a hacer un repaso de como se clasifican.

Según el medio de interacción, dependen de cómo se presentan y devuelve losdatos, en forma de texto plano, con imágenes, voz o vídeo.

Según su utilidad, se tiene en cuenta el uso que le quiera dar el usuario, porejemplo, servio al cliente, automatización de tareas o informativos entre otros.

Según su tecnología, tratan diferentes estructuras en las conversaciones con elusuario, para llegar más fácilmente a la respuesta o servicio requerido.

Según su audiencia, son los que intentan realizar cualquier función que se lespida, como pueden ser Siri, Cortana, Alexa o Google Assistant.

2.4. Taxonomía de los modelos: Tipos de agentes conversa-cionales

Existen múltiples aspectos a tener en cuenta a la hora de desarrollar un agenteconversacional, en esta sección se verán los más importante. Dependiendo de lasalida que nos de el bot podremos elegir entre modelos basados en la recuperación ogenerativos, dependiendo del tipo de conversación, si es larga o corta y dependiendodel dominio de trabajo puede ser abierto o cerrado.

2.4.1. Retrieval-Based bots vs. Generative bots

Este primer tipo es el basado en la recuperación de las respuesta, este tipo es másfácil que el generativo. Usa un repositorio de respuestas ya escritas y la heurísticapara elegir la respuesta más acertada según el contexto de entrada. La heurísticapuede ser basada en reglas o la comparación de palabras que tengan un contextoimportante en la frase, o de forma más compleja, una NN que aplica ML. Estesistema devuelve una frase ya predefinida, no genera nuevo texto, lo que hace quesus respuestas sean menos precisas pero sin faltas de ortografía.

Los modelos generativos, considerablemente más complejos que los basados enla recuperación, generan nuevas respuestas desde cero no predefinidas, más parecido

20 Capítulo 2.

a una conversación humana. Están basado en técnicas de traducción automática,donde se genera nuevo texto como respuesta a partir del contexto de entrada.

El método basado en la recuperación es mucho más rígido que el generativo, nopudiendo contestar correctamente a casos no vistos en su dataset o que al menos notenga cierta relación en el tema para el que fue creado. Tampoco pueden referirseal contexto de la frase de entrada, como un nombre o una acción. Los generativossi pueden realizar hablar contextualmente, lo que les hace “más inteligentes”, dandouna mejor impresión de estar hablando on un humano, sin embargo son más sus-ceptibles de cometer errores gramaticales, especialmente en frases largas, además deser muchísimo más difíciles de entrenar.

Actualmente, los sistemas más utilizados son los basados en la recuperación,sin embargo, las investigaciones van en la dirección de los generativos, siendo laarquitectura Sequence to Sequence especialmente adecuada para generar texto. Porel momento, los modelos generativos no funcionan correctamente.

2.4.1.1. Codificador y Decodificador

Dependiendo de la función del agente conversacional, se puede usar un tipo decodificación de datos u otro. El codificador nos transformará las palabras en vectoresque puede interpretar la NN, y el decodificador nos transformará los datos de salidade la NN y los volverá a transformar en palabras que podamos entender. Por ejemplo,en la traducción de idiomas se utiliza una estructura codificador-decodificador, sinembargo, en las conversaciones podemos usar un codificador dual, haciendo mássencilla la tarea de evaluar la calidad de una conversación.

Un ejemplo de modelo de LSTM que utiliza codificador y decodificador es elSequence to Sequence (Seq2Seq), el cual nos permite traducir de un idioma a otro.

Figura 2.7: Arquitectura de una red neuronal recurrente de tipo Seq2Seq paratraducciones. [4]

Como se puede ver en la figura superior, usa celdas de tipo LSTM recurrentemen-te e unidireccionalmente. En este modelo, se necesita conocer toda la informaciónde la frase para poder hacer la traducción correctamente, ya que el significado varíabastante en función del contexto.

2.4. Taxonomía de los modelos: Tipos de agentes conversacionales 21

2.4.2. Conversaciones largas vs. cortas

A medida que una conversación se alarga, la dificultad de que un método deML sea eficaz aumenta. En las conversaciones muy cortas, como responder una solapregunta, son los casos más fáciles. Según se alarga la conversación, se necesitanrecordar más datos y contextos para aportar respuestas adecuadas, aumentándosela dificultad con el tiempo en estos casos. Por ejemplo, las conversaciones con elsoporte al cliente de una empresa, suele requerir múltiples preguntas, haciendo laconversación más larga.

2.4.3. Dominio abierto, semiabierto y cerrado

En el dominio abierto, se puede tratar cualquier tipo de tema, el usuario no tieneun objeto de conversación específico, pudiendo derivar la conversación a cualquierlugar. Las redes sociales por ejemplo, tienen un dominio abierto, pudiendo ser lostemas de cualquier ámbito. Esto provoca que se necesiten infinidad de datos paracrear respuestas, por lo que es el caso más complejo.

En el dominio semiabierto, en general, se conoce el contexto y los interlocutorespero no exactamente los temas a tratar. Es el caso de los robots sociales que seutilizan en museos o supermercados. Están preparados para interactuar de forma“general”, pero en realidad se limitan a un cierto espectro de conversaciones (aunquesea difícil definir cuáles son esos temas que domina).

En el dominio cerrado el tema de la conversación es limitado, con el fin de llegara un tema muy específico. Por ejemplo, el soporte técnico de un empresa trata unsolo campo de conocimiento, haciendo estos casos más sencillos que los abiertos. Elusuario puede salirse del tema de conversación, pero el sistema no lo dominará y noserá efectivo, aunque el usuario tampoco lo espera.

Capítulo 3

Marco Teórico

En este capítulo se van a describir y explicar los conceptos necesarios para unabuena compresión del trabajo, con el fin de comprender como más en detalle los pro-cedimientos que se han llevado a cabo en el proyecto. Primeramente se va a hablardel tipo de LSTM usado basado en recuperación y de los modelos y algoritmos quelo complementan para el word embedding y la representación de los datos; seguida-mente se hablará de la elección del algoritmo, su funcionamiento y parámetros; ypor último de las herramientas que se han usado para implementarlo, especialmentela herramienta Tensorflow.

3.1. LSTM: Modelo basado en recuperación y algoritmos

En este proyecto se ha utilizado una red neuronal recurrente de tipo LSTMcon algoritmo supervisado, más concretamente el modelo de LSTM basado en larecuperación. Este tipo de modelos utiliza un dataset con respuestas ya predefinidasque puede utilizar tanto en su entrenamiento como en una conversación, devolviendosiempre respuestas ya aprendidas previamente, a diferencia del modelo generativo,el cual puede dar respuestas nunca vistas.

3.1.0.1. Modelo

Se ha elegido un modelo basado en la recuperación por ser bastante más senci-llo de implementar. Los modelos generativos no funcionan aún correctamente en lapráctica debido a su gran libertad a la hora de generar las frases, cometiendo erroresen la gramática o respuestas sin importancia en la conversación, inconsistentes o ge-néricas, como en las primeras versiones que desarrolló, donde se repetía la respuesta“Te amo”1 a prácticamente cualquier cosa. Además, son extremadamente difíciles deoptimizar.

1https://ai.googleblog.com/2015/11/computer-respond-to-this-email.html

23

https://ai.googleblog.com/2015/11/computer-respond-to-this-email.html


24 Capítulo 3. Marco Teórico

La gran mayoría de los agentes conversacionales actuales son del tipo basadosen recuperación, o una combinación de este y el generativo. Por ejemplo, el sistemaGoogle’s Smart Reply [17] es una combinación de ambos.

3.1.0.2. Algoritmo

A la hora de elegir un tipo de algoritmo de aprendizaje supervisado para aplicaren la red, hay cuatro aspectos fundamentales que se deben tener en cuenta:

Diferencia de sesgo-varianzaLa compensación entre el sesgo y la varianza [45]. Si tenemos conjuntos de datosde entrenamiento diferentes pero válidos.Cuando entrenamos el algoritmo para estos conjuntos de datos, si ante unaentrada en particular al predecir el resultado es sistemáticamente erróneo, di-remos que está sesgado. Si por otro lado, ante un mismo dato de entrada dediferentes conjuntos de datos se predicen diferentes valores de salida, entoncestendrá una gran varianza. El error de predicción de un clasificador de apren-dizaje se relaciona con la suma del sesgo (bias) y la varianza del algoritmo deaprendizaje [46].El objetivo será encontrar un equilibrio entre ambos parámetros. Se ha debuscar un bajo sesgo que sea flexible para ajustarse a los datos, pero no dema-siado, o podría sobreajustarse (overfitting) a cada conjuntos de datos y teneralta varianza. Existen métodos para que el usuario pueda ajustar este sobre-ajustamiento, así como gráficas para orientarnos en la posible solución.

La complejidad de la función verdadera y la cantidad de datos de entrenamientoSi la función verdadera es simple, utilizaremos un algoritmo de aprendizaje “in-flexible” con alto sesgo y baja varianza, pudiendo así aprender de una pequeñacantidad de datos. Pero si la función verdadera es muy compleja, utilizaremosun algoritmo de aprendizaje “flexible” con bajo sesgo y alta varianza, haciendoque la función aprenda de una gran cantidad de datos de entrenamiento.

Dimensionalidad del espacio de entradaSi los vectores de características de entrada poseen una dimensión muy altapodría confundir al algoritmo y provocar una alta varianza, tendremos quecorregirlo para que tenga baja varianza y alto sesgo. Una forma de hacerlo eseliminando a mano algunas de las características que no sean necesarias en losdatos de entrada o aplicando algoritmos para seleccionar las características masimportantes, como por ejemplo el método de Reducción de Dimensionalidad.

Ruido en los valores de salidaEl algoritmo de aprendizaje no debe intentar encontrar una función que coin-cida exactamente con los ejemplos de entrenamiento, si estos tienen un errordemasiado alto o bajo, donde los datos de salida no son próximos a los de en-trada o se sobreajustan. En estos casos, los datos que no se ajustan a la funcióncorromperían el entrenamiento. Cuando hay cualquier tipo de ruido presente,

3.2. Dataset: Ubuntu Dialog Corpus (UDC) 25

es mejor optar por un estimador de varianza más bajo y un sesgo más alto.Antes de empezar un entrenamiento se debería evitar los conjuntos de datosruidosos.

Otros factores a considerar

− Heterogeneidad de los datos. Los vectores de características no han deincluir características de muchos tipos diferentes.

− Redundancia en los datos. Las características de entrada no deben contenerinformación redundante.

− Presencia de interacciones y no linealidades. Las funciones no tienen quehacer una contribución independiente a la salida.

Siguiendo estos aspectos, se debe elegir un grupo de algoritmos que nos puedanayudar en nuestra red y probarlos para comprobar cual es el que mejor se adapta anuestro conjuntos de datos (validación cruzada [47]). Sin embargo, ajustar el rendi-miento de un algoritmo puede consumir mucho tiempo, pudiendo ser mejor dedicartiempo en recopilar más datos datos de adicionales.

3.2. Dataset: Ubuntu Dialog Corpus (UDC)

Hemos elegido el conjunto de datos UDC [48] para entrenar nuestra red con loscontextos y respuestas de diálogo que nos ofrece, ya que es uno de los conjuntos dedatos de diálogo públicos más grandes disponibles. Además, se ha demostrado quenuestro modelo Dual Encoder aporta bastante buenos resultados con este tipo dedatasets [49]. Este dataset está en inglés, ya que la mayoría de ellos están en esteidioma, no habiendo prácticamente datasets en español que estén ya adecuados paratrabajar con ellos (no tienen un buen preprocesamiento) o no son gratuitos. Por ello,trabajaremos en inglés a la hora de entrenar la red.

El UDC se basa en los registros de chat de los canales de Ubuntu en una redInternet Relay Chat (IRC) pública. Los datos de capacitación que nos ofrece el UDCson un millón de ejemplos, una mitad positivos (etiqueta 1) y la otra mitad negati-vos (etiqueta 0). Cada ejemplo, consta de un contexto y su respectiva respuesta. Losejemplos positivos tienen las respuestas reales para contexto y los negativos tienenpara cada contexto una respuesta elegida al azar de entre todo el corpus. A conti-nuación, se puede ver en la figura como se separa el archivo en formato CSV de losdatos de entrenamiento.

26 Capítulo 3.

Figura 3.1: Disposición datos de entrenamiento del archivo en formato CSV.[5]

Además, el dataset viene preprocesado (tokenizado, bloqueado y lematizado)utilizando la herramienta Natural Language Toolkit (NLTK). Adicionalmente, estescript hace por nosotros el reemplazó de entidades como nombres, ubicaciones, orga-nizaciones, Localizador Uniforme de Recursos (URL) y rutas del sistema con tokensespeciales.

Por otra parte, el conjunto de datos ya viene separado en tres subconjuntos,entrenamiento, validación y evaluación. El subconjunto de validación y de evaluaciónestán dispuestos en un formato diferente al de entrenamiento, por cada contexto setiene una respuesta real y nueve distractores (respuestas incorrectas). El objetivodel modelo es asignar el puntaje más alto al enunciado verdadero y los más bajos alos enunciados incorrectos. En la siguiente figura se puede ver la disposición de lavalidación y evaluación dentro del archivo en formato CSV.

Figura 3.2: Disposición datos de evaluación y evaluación del archivo enformato CSV. [5]

3.3. Word embedding

Actualmente, la incrustación de palabras es un área de investigación muy in-teresante en el DL. Originalmente introducidas por Bengio [50] hace más de unadécada.

3.3. Word embedding 27

Una palabra embebida es una función parametrizada que asigna palabras enalgún idioma a vectores de alta dimensión, normalmente de dimensión entre 200a 500. Cada valor dentro del vector sirve como tabla de búsqueda dentro de unamatriz con una fila para cada palabra. Por ejemplo, en la frase “Gato sentado en eltapete” podríamos encontrar:

(“Gato”) = (0.2, -0.4, 0.7, ...)

(“tapete”) = (0.0, 0.6, -0.1, ...)

El vector se inicializa de forma aleatoria cada vez que se empieza el entrena-miento para cada palabra, con el fin de tener vectores significativos para una tarea.Alguna de las posibles tareas pueden ser predecir si una palabra es “válida” dentrode una frase dada o predecir la siguiente palabra en una frase.

Esto es muy útil desde el punto de vista de las palabras similares, pudiendopredecir sinónimos o incluso una palabra de una clase similar, como por ejemplo,“la pared es azul” a “la pared es roja”. Luego las palabras azul y rojo estarán cer-canas vectorialmente dado que tiene sentido gramaticalmente y la red habrá vistonumerosos ejemplos parecidos a ese. Un ejemplo visual es el siguiente:

Figura 3.3: Relación lineal de Word embedding. [6]

Podemos ver como relaciona palabras por género, tiempos verbales, geografía eincluso por singulares y plurales. En el caso de gatos y perros por ejemplo, el modelopuede aprovechar de lo que ha aprendido sobre ellos al procesar el corpus (base dedatos que utilizamos para entrenar la red) y catalogarlos en animales, de cuatropatas, mascotas, etc...

Existen varias herramientas que se encargan de hacer este Word Embedding. Lasmás famosas son Word To Vector (Word2Vec) y Global Vectors for Word Represen-tation (GloVe). Los dos modelos aprenden codificaciones geométricas (vectores) depalabras a partir de su información de concurrencia (con qué frecuencia aparecenjuntas en grandes corpus de texto). Cada método se utiliza para un fin diferente,Word2Vec es un modelo “predictivo” para predecir la palabra objetivo utilizandoel contexto, mientras que GloVe es un modelo “basado en recuento”, sus vectoresaprenden reduciendo la dimensionalidad en la matriz y haciendo un recuento de laconcurrencia.

28 Capítulo 3.

3.3.1. Modelo del word embedding: GloVe

En este proyecto hemos utilizado el método Stanford’s GloVe [51], el cual esen-cialmente se encarga de el recuento de la concurrencia de las palabras en nuestrocorpus (palabras x contexto) y después factoriza la matriz para reducir la dimen-sionalidad (palabras x características). Todo este proceso se hace minimizando laspérdidas por reconstrucción, es decir, tratando de encontrar las representaciones dedimensiones inferiores que pueden explicar la mayor parte de la varianza en los da-tos de alta dimensión. Los beneficios adicionales de GloVe frente a Word2Vec es quees más fácil paralelizar su implementación, siendo así más fácil entrenar un mayornúmero de datos.

3.3.2. Representación del word embedding: t-SNE y PCA

Una forma de hacernos una idea de como funciona el método de Word Embed-ding es visualizarlo en el espacio con t-Distributed Stochastic Neighbor Embedding(t-SNE) o PCA, unas técnica sofisticada para la visualización de datos de altas di-mensiones. Este tipo de “mapa” de palabras nos dice que, de forma intuitiva, laspalabras similares están representadas unas cerca de otras.

3.3.2.1. t-Distributed Stochastic Neighbor Embedding (t-SNE)

El método t-SNE [52] es un algoritmo de ML para la visualización. Esta técnicareduce la dimensión de forma no lineal, ofreciéndonos la posibilidad de ver en dos otres dimensiones datos de altas dimensiones. Esta reducción se consigue mediante lamodelación de las altas dimensiones en un punto bidimensional o tridimensional, deforma que objetos similares se modelan por puntos cercanos y objetos diferentes semodelan por puntos distantes con alta probabilidad. Una ilustración del resultadoque obtendríamos con este proceso es la siguiente figura, donde se ve como el métodot-SNE ha agrupado en dos dimensiones un grupo de número y otro de trabajos.

Figura 3.4: Visualización t-SNE de palabras embebidas. Izquierda: Regiónnúmeros; Derecha: Región de empleos. [7].

3.3. Word embedding 29

De forma más refinada, si se etiqueta previamente cada ejemplo por coloresde forma manual, podemos ver en la figura siguiente la representación de como sejuntan los datos por relaciones semánticas en una densa nube, apareciendo diferentesclusters para cada tipo de dato y separados por colores.

Figura 3.5: Visualización t-SNE del espacio de palabras semánticas. [8]

3.3.2.2. Análisis de Componentes Principales (PCA)

El PCA es una técnica utilizada para enfatizar la variación y poner de manifiestofuertes patrones de un conjunto de datos. A menudo se utiliza para hacer que losdatos sean fáciles de explorar y visualizar. El método PCA es útil para eliminardimensiones. En este método se normalizan los datos y se proyectan en un vectorpara reducir su dimensión, buscando la recta que da como resultado las menoresdistancias normales entre el punto y la recta a calcular. Hay muchas posibilidadespara seleccionar la línea recta. Veamos dos de esas posibilidades:

Figura 3.6: Visualización PCA. Los datos normalizados y proyectados despuésde PCA, no perpendicularmente. [9]

30 Capítulo 3.

Figura 3.7: Visualización PCA. Los datos normalizados y proyectados despuésde PCA, perpendicularmente. [9]

Claramente, la segunda opción de línea recta es mejor porque:

El error de proyección es menor que en el primer caso.

Los puntos rojos proyectados tienen una distancia mayor en el primer caso, esdecir, tienen más varianza.

Dando como resultado la reducción de dimensión buscada, como se puede veren la siguiente figura, dónde se ha reducido a una nube de dos dimensiones.

Figura 3.8: Visualización PCA. Los datos normalizados y proyectados despuésde PCA en 2D. [10]

La representación puede ser en 2D o 3D. Los ejes no significan nada físico, soncombinaciones de características llamadas “componentes principales” que se eligenpara dar a un eje un mayor variación. La representación en 3D es más útil que en2D, ya que es más fácil para ver a través de una nube de datos, además se puedenproyectar los datos en 2D mediante una transformación, simplemente encontrandoun ángulo de perspectiva que nos ayude a aclarar la visión de la representación.

3.3.2.3. Comparación t-SNE vs PCA

Como podemos ver en la siguiente imagen, ambos métodos clasifican los datosde forma muy parecida, agrupándolos por sus contextos, características, etc... perolos representan de formas diferentes. Dependiendo de las necesidades del usuarioserá un método más útil que el otro.

3.4. Fundamentos teóricos del modelo Dual Encoder LSTM 31

Figura 3.9: Visualización PCA vs. t-SNE. Agrupamiento en 2 dimensionesusando t-SNE vs PCA. [11]

Más adelante utilizaremos ambos métodos en este proyecto, para ver con másdetalle los resultados obtenidos por el agente conversacional y comprenderlos enmayor profundidad.

3.4. Fundamentos teóricos del modelo Dual Encoder LSTM

3.4.1. Funcionamiento del modelo

Pasemos a hablar un poco más en detalle del modelo del agente conversacional,este recibe un gran número de datos en forma de texto (un millón de datos deentrada desde la base de datos UDC en nuestro caso) y hace un embebido de cadapalabras en un vector usando el sistema de word embedding (asociación de palabraa vectores de números) Stanford’s GloVe, con el fin de poder ver la relevancia de lapalabra en la frase, comúnmente hablando, captura el significado del contexto y dela respuesta.

Seguidamente estos vectores entran a un modelo de aprendizaje profundo com-puesto de una red neuronal llamado Dual Encoder LSTM. Este modelo es entrenadocon todos los vectores, comparando los contextos de entrada con las posibles res-puestas a esos contextos en particular, obteniendo como dato de salida la predicciónde dicho contexto, es decir, la respuesta que la red cree más adecuada a esa frase deentrada.

32 Capítulo 3.

Por último, mediremos la calidad de esa predicción y será presentado en forma deporcentaje. La finalidad es evaluar las predicciones de salida e intentar hacer que elagente conversacional aprenda a conversar como lo harían las personas, desarrollandopor probabilidad la respuesta más acertada según la frase introducida por el usuario.

3.4.2. Arquitectura del modelo

El modelo seleccionado de aprendizaje profundo que vamos a utilizar en esteproyecto es la red Dual Encoder LSTM. Previamente, se ha de aclarar que existenbastantes redes que podríamos haber escogido para este proyecto en particular y nonecesariamente esta es la mejor. Se pueden probar en este problema numerosas redesdiferentes e incluso nuevas arquitecturas, ya que este es un campo de investigaciónmuy activo. Por ejemplo, el modelo Sequence to Sequence (Seq2Seq) utilizado entraducción podría funcionar muy bien en esta tarea en particular.

La razón por la que se ha optado por el Dual Encoder es porque se ha demostradoque tiene un muy buen rendimiento con el conjunto de datos que se ha escogido.Lo cual nos dice que sabemos que podemos esperar un correcto funcionamiento ennuestra implementación.

La red neuronal Dual Encoder LSTM tiene el siguiente aspecto:

Figura 3.10: Arquitectura interna de una LSTM de tipo Dual Encoder. [5]

Su funcionamiento sigue los siguientes pasos:

1. Tanto el contexto (datos de entrada del usuario) como el texto de respuesta(datos de entrada que corresponde a la respuesta a dicha entrada del usua-rio) están divididos por palabras, y cada palabra está integrada en un vector.El Word Embedding de las palabras en vectores se hace usando el método


Stanford’s GloVe y se ajustan durante el entrenamiento (en este proyecto utili-zaremos este método pero de forma general no es estrictamente necesario y noestá representado en la imagen).

2. Tanto el contexto embebido como la respuesta se alimentan en la misma RedNeuronal Recurrente, palabra por palabra. La RNN genera una representaciónvectorial que, en términos generales, captura el “significado” del contexto y larespuesta (c y r en la imagen respectivamente). Podemos elegir el tamaño deestos vectores, en nuestro modelo hemos elegido una dimensión de 256.

3. Multiplicamos la traspuesta de c por una matriz M para “predecir” una res-puesta r′. Si c es un vector de dimensión 256, entonces M es una matriz dedimensión 256 x 256, y el resultado es otro vector de dimensión 256, que po-demos interpretar como una respuesta generada por la red. La matriz M se iráaprendiendo durante el entrenamiento de la red.

4. Medimos la similitud de la respuesta predicha r′ y la respuesta real r tomandoel producto punto por punto de estos dos vectores. El producto de estos dosvectores nos dará una hipótesis, si este es grande, significa que los vectoresson similares y que la respuesta debe recibir una puntuación de similitud alta.Luego aplicamos una función sigmoidea sobre este producto para convertir esapuntuación en una probabilidad. La hipótesis depende de la sigmoidea, la cualda un valor entre 0 y 1.

Para entrenar la red, también necesitamos una función de pérdida (costo). Uti-lizaremos la Pérdida de Entropía Cruzada Binaria, común entre los problemas declasificación. Llamaremos y a nuestra variable verdadera para un par de respues-tas de contexto. Esto puede ser 1 (respuesta verdadera) u 0 (respuesta incorrecta).Por otro lado, llamemos a nuestra probabilidad predicha y′ (producto de r′ y r, lahipótesis). Luego, la Pérdida de Entropía Cruzada se calcula como:

L = −y ln(y′)− (1− y) ln(1− y′) (3.1)

La idea detrás de esta fórmula es simple: Si y = 1 usaremos la parte de laecuación L = −ln(y′), que penaliza una predicción muy lejos de 1, y si y = 0 nosquedamos con L = −ln(1 − y′), lo que penaliza una predicción muy lejos de 0.La predicción de respuesta final que devuelva la red ante un contexto de entradadado, será la que tenga menor pérdida (probabilidad más alta), más llanamente, larespuesta ante un contexto que sea más parecida a otros pares de contexto-respuestaya vistos durante el entrenamiento.

Un poco más formalmente, la entrada a un modelo basado en recuperación esun contexto c (la conversación hasta este punto) y una potencial respuesta r. Losresultados del modelo es una probabilidad para la respuesta. Para encontrar unabuena respuesta, se calcula la probabilidad para múltiples respuestas y se elige laque tenga la probabilidad más alta.

34 Capítulo 3.

3.4.3. Parámetros de la red

La red neuronal está regida por una serie de parámetros, con los que pode-mos controlar diferentes factores de la misma como la velocidad de aprendizaje, lacantidad de datos para entrenar, etc.

Estos son los parámetros más importantes en una modelo Dual Encoder LSTM:

Tamaño del batch: Número de ejemplos usados en cada paso del descensodel gradiente.

Dimensión de la célula de la RNN: Número de neuronas de la red.

Tasa de aprendizaje: Parámetro que se encarga de variar los pesos de lasneuronas en cada batch (lote).

Steps:, Número de veces que se hace uso de la red neuronal.

Épocas: Número de veces que se utilizan todos los ejemplos el dataset al com-pleto.

Tamaño del vocabulario: Número de elementos que cogemos del vector don-de se guardan las palabra más repetidas del dataset, es decir, busca la palabrasrepetidas y crea una lista en orden descendente.

Dimensión del word embedding: Tamaño del vector del word embedding,siendo este el número de relaciones que tiene cada palabra.

Máxima longitud del contexto: Número máximo de tokens (instancia deun tipo en un texto dado) en un contexto.

Máxima longitud de la respuesta: Número máximo de tokens en una res-puesta.

Optimizador: Método que calcula las tasas de aprendizaje adaptativo paracada parámetro.

Pérdidas: Diferencia entre la salida real y la calculada, es el error de la red.

3.4.4. Entrenamiento de la red: Conceptos generales

Las redes neuronales han de ser entrenadas con grandes cantidades de datos paraque “aprendan” a obtener los resultados óptimos ante problemas nunca vistos por lared. Al inicio inicializaremos los datos de forma aleatoria con el fin de no conseguirsiempre los mismo resultados en cada entrenamiento. En cada entrenamiento seutilizan un número de ejemplos, el cual viene determinado por el parámetro batch(lote) y el conjunto de todos los ejemplos del dataset se llama época. Aplicando lossiguientes métodos se irán ajustando automáticamente los pesos con el fin de llegara unas pérdidas mínimas.


3.4.4.1. Descenso del gradiente

El descenso del gradiente se trata de un algoritmo para optimizar de forma ite-rativa la función de costo hasta llegar a su mínimo (local o global). En las redesneuronales se utiliza para minimizar el error, variando los pesos de forma propor-cional la derivada del error con respecto al peso.

En las NN las neuronas se deben activar para un tipo concreto de entrada. Paraque esto ocurra, hay que entrenarlas haciendo que sus pesos varíen, es decir, dandomás importancia a unos nodos que a otros con el fin de obtener un sistema que seadecue a nuestra función, dándonos los resultados más reales posibles (el mínimoerror). Esto se consigue aplicando los dos siguientes métodos alternativamente:

1. Propagación hacia adelanteEn esta propagación las entradas de la red neuronal pasan de los nodos ini-ciales a las capas ocultas de la misma produciendo su activación y finalmenteobteniendo una hipótesis de salida, con el fin de calcular el costo entre la saliday la entrada.

2. Propagación hacia atrásEn este tipo de propagación se retrocede desde el costo de la función paracalcular el gradiente de los parámetros. Se consigue haciendo el proceso inversoa la propagación hacia adelante, recorriendo la red desde los nodos finales enorden inverso, haciendo la derivada de la salida con respecto a la salida de cadanodo anterior, es decir, la derivada del error con respecto al valor de cada pesoen la capa oculta.

En la propagación hacia delante se observa “como de bien” se comporta la red,viendo si la salida es la buscada a través del calculo del error final. En la propagaciónhacia atrás se intenta minimizar ese error. Ambos métodos son imprescindibles,haciendo primero la propagación hacia adelante para llegar al calculo del error ydespués utilizando el segundo método, propagación hacia atrás, para minimizarloactualizando los valores de ponderación con el método del descenso del gradiente (seexplicará a continuación). Estos pasos son cíclicos, utilizándolos alternativamentehasta llegar a los valores mínimos del error.

La matemática detrás de todo esto es bastante extensa, así que solo hablaremosde la fórmula que resume todo, para hacernos una idea global del método. La fórmulaGeneral del Descenso del Gradiente es la siguiente:

wi+1 = wi − α∇f(wi) (3.2)

Siendo wi+1 el peso actualizado del siguiente nodo, wi el peso del nodo actual, αla tasa de aprendizaje, ∇f(wi) es la dirección de propagación de la función, la cualqueremos que vaya hacia el mínimo global.

Los valores calculados en esta ecuación los sustituiremos en la ecuación de laPérdida de Entropía Cruzada 3.1 en el cálculo de la variable de la hipótesis y′.

36 Capítulo 3.

Consiguiendo así un nuevo error, sabiendo así si vamos en la buena dirección sieste se ha minimizado. En la siguiente figura se puede ver como el gradiente vavariando los pesos en hacia los mínimos de la función, siendo θ0 = wi, θ1 = wi+1, yJ(θ0, θ1) = L (3.1).

Figura 3.11: Visualización gráfica del Descenso del Gradiente. [12]

3.4.4.2. Tasa de aprendizaje

Hay que destacar el papel que tiene en esta ecuación la tasa de aprendizaje,ya que, controla cuán grandes son los steps (pasos) del Descenso del Gradiente. Enotras palabras, nos dice como de rápido o lento se avanza hacia los pesos óptimos encada step. Se ha establecer una tasa de aprendizaje ni muy rápida ni muy lenta parallegar al mínimo local. Esto es debido a que si α (tasa de aprendizaje) es muy grande,es posible no alcanzar el mínimo local y quedarse alrededor de él o incluso hacerque se aleje, divergiendo en la función y no minimizando el error. Si la velocidad deα es un valor muy pequeño, se alcanzará el mínimo local pero tardará demasiadotiempo. Luego la mejor opción es encontrar un valor de compromiso entre ambasposibilidades. En la siguiente imagen se ilustran ambas opciones:

Figura 3.12: Variación de la tasa de aprendizaje.


A la izquierda se ve como una tasa de aprendizaje alta hace diverger la funciónconvexa del Descenso del Gradiente. A la derecha se observa como una baja tasa deaprendizaje alcanza finalmente un mínimo local, pero invierte demasiado tiempo enllegar, ya que los pasos son muy pequeños.

3.4.4.3. Batchs (lotes) en el descenso de gradiente

El tamaño de lotes define el número de ejemplos que se propagarán a través dela red. Si por ejemplo, tenemos 1050 muestras y establecemos el tamaño del batchen 100, se entrenará la red con los ejemplos del 1 al 100 (considerándose esto unstep), después con los ejemplos de 101 al 200 y así sucesivamente hasta el númerode steps que hayamos escogido o de épocas.

La mayor ventaja de este procedimiento es, un menor uso de memoria en cadaentrenamiento al utilizar menos muestras en cada uno. Como desventaja está elhecho de que si los batchs son demasiado pequeños se llega antes a valores cercanosal mínimo local pero la estimación del gradiente es menor, haciendo que fluctúe ladirección del gradiente a diferencia de lotes mayores, en los cuales la dirección esmás directa hacia el mínimo local.

Normalmente las redes se entrenan con mini-batchs, como valor de compromisoentre la velocidad y la precisión de la estimación del gradiente, debido a que sedeben actualizar los pesos de cada nodo después de cada propagación. En el ejem-plo superior se usan 10 batchs de 100 ejemplos y uno de 50 ejemplos, es decir, seactualizan los pesos 11 veces en total. Si hubiéramos usado todos los ejemplos enun solo entrenamiento, solo se habría hecho una actualización de los pesos para losparámetros de red determinados.

Dependiendo del tamaño del batch, existen varios métodos:

− Descenso del Gradiente Estocástico (SGD)

Es un método que entrena la red y actualiza los valores con cada ejemplo de en-trada, haciendo que se llegue muy rápidamente a valores cercanos al mínimo yun detalle mayor de la evolución al actualizar constantemente, pero dependien-do del problema esto puede no ser útil al no llegar a converger completamentedebido al ruido, haciendo que la tasa de error salte de un punto a otro en lugarde disminuir lentamente, además de ser más costoso computacionalmente.

− Descenso del gradiente de mini-batchs

Este método es una combinación entre el Descenso de Gradiente por Batchs yel SGD, simplemente dividiendo el conjunto de datos en pequeños batchs (entre50 y 256) y realiza una actualización de los parámetros por cada batch. Es unrelación de equilibrio entre la robustez del SGD y la eficiencia del descenso delgradiente discontinuo. Es el tipo más común de descenso de gradiente dentrodel aprendizaje profundo.

38 Capítulo 3.

3.4.4.4. Overfitting (sobreajuste)

Este es un problema que afecta a las redes neuronales, donde si tenemos de-masiadas características, la hipótesis obtenida se ajustara muy bien a los datos deentrenamiento, pero en nuevos ejemplos que queramos predecir, la hipótesis fallará.De forma parecida ocurriría si la red está poco ajustada (subajuste) a la función deaprendizaje, devolviendo datos incorrectos ante datos nunca vistos por la red. Hayque encontrar un punto de compromiso entre el subajuste y el sobreajuste, pudiendoajustarse a cualquier información de entrenamiento que se le proporcione a la red.Posibles soluciones a este problema suelen ser:

Para un problema de regresión lineal

− Conseguir más ejemplos de entrenamiento, corregir alta varianza.− Probar con conjuntos de características más pequeños, corregir alta varian-

za.− Probar añadiendo nuevas características, corregir alto sesgo.− Probar añadiendo características polinómicas, corregir alto sesgo.− Probar a disminuir α (tasa de aprendizaje), corregir alto sesgo.− Probar a incrementar α (tasa de aprendizaje), corregir alta varianza.

Para redes neuronales

− En redes neuronales pequeñas, con una sola capa oculta y con pocas uni-dades, es más propenso a aparecer el problema de bajo ajuste, aunque nonecesitan un gran gasto computacional.

− En redes neuronales más grandes, con más capas ocultas y más unidades,es más propenso a aparecer el problema de sobre ajuste. Suponen tambiénun gasto computacional más alto. Sin embargo, el sobre ajuste se puedeintentar corregir usando regularización.

3.4.4.5. Adam optimizer: Descenso del gradiente estocástico y optimización global

El uso de métodos de optimización del Descenso del Gradiente es debido alproblema del overfitting (sobreajuste). Esta optimización ofrece ventajas a la horade entrenar una red, como una mayor velocidad en comparación al Descenso delGradiente o no tener que fijar manualmente la tasa de aprendizaje α. Sin embargo,también tiene sus desventajas, como algoritmos de mayor complejidad o la necesidadde librerías externas para implementarlos en el código de programación, ya que sonmuy complejos de desarrollar.

La Estimación de Momento Adaptativo (Adam) [53] es una extensión del SGD,con una adaptación para aplicaciones de aprendizaje profundo en procesamiento dellenguaje natural. Las características más destacadas de este método son:

Computacionalmente eficiente.


Pocos requisitos de memoria.

Invariante a reescalado diagonal de los gradientes.

Muy adecuado para problemas que son grandes en términos de datos y/o pa-rámetros.

Apropiado para objetivos no estacionarios.

Apropiado para problemas con gradientes muy ruidosos o escasos.

Los hiperparámetros tienen una interpretación intuitiva y generalmente requie-ren poca afinación.

El SGD mantiene la tasa de aprendizaje igual para todas las actualizacionesde pesos, mientras que Adam varía esta tasa a medida que se va desarrollandoel entrenamiento. Más específicamente, calcula un promedio móvil exponencial delgradiente y el gradiente cuadrado, y los parámetros dos parámetros β0 y β1 controlanlas tasas de disminución de estos promedios móviles. Más comúnmente hablando,el SGD se puede ver como una esfera rodando por una pendiente, mientras queAdam se comporta como una esfera pesada con fricción, la cual tiene diferentesaceleraciones en función de la inclinación de la pendiente.

3.4.5. Función de puntuación de las predicciones: Recall@k

Por último, nos queda hablar sobre el sistema que utilizaremos en este proyec-to para evaluar la calidad de las predicciones que haremos usando nuestra modeloLSTM. La métrica que usaremos se llama recall@k, esta métrica nos permite elegirlas mejores respuestas k (cantidad de respuestas que elegimos) de las 10 respues-tas posibles (1 verdadero y 9 distractores). Las posibles respuestas son elegidas alazar desde el dataset (etiquetadas las respuestas acertadas como 1 e incorrectascomo 0). Se eligen solamente 10 posibles respuestas para que sea más económicocomputacionalmente.

La métrica funciona así, si entre las respuestas k está la respuesta verdadera delas posibles, entonces se marca el ejemplo como correcto. Una k elevada significaque es fácil que sea correcta y viceversa. Si tenemos 10 posibles respuestas y esta-blecemos k = 10, la probabilidad de acertar es del 100%, si seleccionamos k = 1, laprobabilidad será del 10%.

Veamos un ejemplo sencillo para ver más detalladamente como funciona y verel rendimiento que cabe esperar. Tenemos el vector de puntuaciones en orden de-creciente [0,3,1,2,5,6,4,7,8,9] (cada número representa una etiqueta a una respuestaante un mismo contexto de entrada), la respuesta correspondiente al elemento 0 delvector, obtuvo la puntuación más alta y la respuesta del elemento 9, la más baja.Hay que tener en cuenta que el elemento 0 del vector es la respuestas correcta y losotros 9 elementos son los posibles distractores, como ya se explicó en la sección 3.2sobre el UDC. Si establecemos k = 1 la probabilidad que devuelve esta métrica seríade aproximadamente el 10%, para k = 2 y así sucesivamente hasta k = 10 con el100%.

40 Capítulo 3.

Para el caso de k = 2 los contextos con más probabilidad de ser correctos paraque la métrica devuelva un 20% deben ser los contextos con las etiquetas 0 y 3.

En el UDC, esta aleatoriedad solo se haría en el caso del entrenamiento; en lavalidación y evaluación, las respuestas ya está preseleccionadas en la tabla que nosfacilita dicho dataset, siendo los resultados sustancialmente mejores que los basadosen la aleatoriedad.

3.4.5.1. Term Frequency–Inverse Document Frequency (tf-idf)

Existen otras opciones, además de la basada en la aleatoriedad, para la predic-ción de la respuesta. Por ejemplo existe el tf-idf o TFIDF, el cual mide la importan-cia de una palabra en un documento en relación con todo el corpus. Este métodose encarga de encontrar contextos y respuestas con palabras similares, siendo másprobable que ese par contexto-respuesta sea más correcto. Sin embargo, este modelotambién dista de ser perfecto, ya que, no necesariamente un contexto debe ser si-milar a una respuesta para ser correcta. Por otro lado, tf-idf ignora el orden de laspalabras, lo cual, intuitivamente podemos ver que es de especial importancia.

En cualquier caso, en nuestro proyecto utilizaremos una red neuronal para laspredicciones, en la cual se obtendrán resultados considerablemente mejores que enlos modelos mencionados.

3.5. Herramientas y metodología

Todo el proyecto está escrito en el lenguaje de programación Python, ya quedado su alto nivel resulta mucho más fácil e intuitiva la construcción del agenteconversacional, así como la implementación y entendimiento de los diferentes pará-metros.

3.5.1. Sistema operativo

3.5.1.1. Linux

Figura 3.13: Tux, logotipo de Linux.

Linux es un Sistema Operativo (SO) de software libre y código abierto. Con-cretamente se ha utilizado la distribución Ubuntu 16.04 LTS (Long Term Support),

3.5. Herramientas y metodología 41

siendo está la última versión estable disponible hasta el momento. Se ha utilizadoeste SO por la mayor facilidad a la hora de ejecutar la herramienta TensorFlow, enla que se basa este proyecto. Además, existen múltiples librerías de fácil implemen-tación muy necesarias para el desarrollo del código.

3.5.2. Gestor de entornos

3.5.2.1. Anaconda

Figura 3.14: Logotipo de Anaconda.

Anaconda es un sistema de gestión de paquetes de código abierto y gestióndel entorno que se ejecuta en Windows, macOS y Linux. También puede instalar,ejecutar y actualizar paquetes rápidamente y con sus dependencias. Por otro lado,ofrece gran facilidad para crear, guardar, cargar, cambiar y gestionar fácilmenteentre entornos de forma local. Haciendo uso de los entornos que ofrece se puedenprobar diferentes versiones de un programa, pudiendo personalizar cada entorno deforma personalizada. Además, facilita la instalación de paquetes en función de lasnecesidades de cada programa en cada entorno, sin tener que borrar las versionesanteriores.

3.5.3. Control de versiones

3.5.3.1. GitHub

Figura 3.15: Logotipo de GitHub.

GitHub es una plataforma que nos permite alojar el un gran número de archivosde código fuente de nuestro proyecto de forma eficiente, además de manejar todaslas herramientas de control de versiones, bugs, testing, etc... como las que ofrece Git.Se eligió esta herramienta por los conocimientos previos sobre la misma durante losestudios del grado.

42 Capítulo 3.

3.5.3.2. Bitbucket

Figura 3.16: Logotipo de Bitbucket.

Bitbucket es un servicio de alojamiento de repositorio de control de versionesbasado en web (similar a GitHub). Nos permite guardar código fuente y proyectosde desarrollo que utilizan sistemas de control de revisiones Git. Bitbucket ofrece unnúmero ilimitado de repositorios privados para cuentas gratuitas.

3.5.4. Lenguaje de programación

3.5.4.1. Python

Figura 3.17: Logotipo de Python.

Python es un lenguaje de programación de alto nivel interpretado para progra-mación de propósito general. Se ha elegido este lenguaje por su legibilidad del código,su simpleza a la hora de programar, su administración dinámica de la memoria y sucompatibilidad con las bibliotecas necesarias.

3.5.5. Entorno de Desarrollo Integrado (IDE)

3.5.5.1. Pycharm IDE

Figura 3.18: Logotipo de Pycharm IDE.

PyCharm es un Entorno de Desarrollo Integrado (IDE) muy utilizado en progra-mación usando el lenguaje Python. Además, tiene versiones soportadas para Win-


dows, macOS y Linux. Sus mayores ventajas son el análisis de código, la incorpora-ción de un depurador gráfico, un probador de unidades integrado y la integración consistemas de Sistemas de Control de Versiones (VCS). Como añadido, nos permiteleer los Jupyter Notebook, de los cuales hablaremos más adelante.

3.5.5.2. Visual Studio Code

Figura 3.19: Logotipo de Visual Studio Code.

Como alternativa se estudió el IDE llamado Visual Studio Code, ejecutable tan-to sistemas para operativos Windows como Linux. Soporta múltiples lenguajes deprogramación entre los cuales está Python. Nos da la posibilidad de poder conec-tar diferentes estaciones para crear aplicaciones interconectadas desde el Front-Endhasta el Back-End. Las características más útiles de este sistema son la posibilidadde usar múltiples monitores y la comodidad de poder mover las ventanas de trabajoa través de la interfaz.

3.5.5.3. Gedit

Figura 3.20: Logotipo de Gedit.

Por otro lado aunque no es un IDE, se ha hecho uso también del editor de textopredeterminado del entorno de escritorio GNU Network Object Model Environment(GNOME), siendo un software gratuito y de código abierto. Tiene una InterfazGráfica del Usuario (GUI) (Interfaz gráfica del usuario) muy simple y es muy sencillade usar. Además incluye algunas herramientas para la edición de código fuente.

44 Capítulo 3.

3.5.6. Biblioteca

3.5.6.1. Tensorflow

Figura 3.21: Logotipo de TensorFlow.

Es una biblioteca de software de código abierto para la programación de flujo dedatos en una amplia gama de tareas de forma autónoma. Es una biblioteca mate-mática simbólica, y también se utiliza para aplicaciones de aprendizaje automático,como redes neuronales. Se usa tanto para investigación como para producción, queademás tiene múltiples librerías (se verán más adelante) y herramientas como Ten-sorBoard. Dentro de sus principales virtudes está el alto rendimiento que ofrece ala hora de desplegar sistemas de aprendizaje automático, ejecutándolos en procesa-dores Unidad Central de Procesamiento (CPU), Unidad de Procesamiento Gráfico(GPU) o Unidad de procesamiento de Tensor (TPU).

En cuanto a su usabilidad, ofrece diferentes Interfaz de Programación de Apli-cacioness (APIs) de alto nivel, con el fin de facilitar el desarrollo y los modelos,además, nos permite controlar la herramienta a bajo nivel también. Todo esto lahace muy adecuada para el uso en el mundo de la investigación, sobretodo en lainvención y desarrollo de nuevos modelos, en los campos del aprendizaje automáticoy las redes neuronales profundas

3.5.6.2. TensorBoard

Los gráficos de computación de TensorFlow son potentes pero complicados. Parala visualización del aprendizaje de nuestra red neuronal profunda masiva utilizare-mos un conjunto de aplicaciones web. Con el fin de, inspeccionar y comprender loque ocurre dentro de las ejecuciones de nuestra red, a través de, sencillas gráficase histogramas que nos ofrece esta herramienta, nos será posible la comprensión detodos los datos más complejos y confusos de nuestro modelo. Esta herramienta nosfacilitará la comprensión, depuración y optimización de nuestro código de maneralocal a través de nuestro navegador.

3.5.7. Librerías

Para nuestra implementación usaremos una combinación de numpy, pandas,Tensorflow y TFLearn (una combinación de funciones de conveniencia de alto nivelpara Tensorflow).


3.5.7.1. Numpy

Figura 3.22: Logotipo de Numpy.

Esta es una librería de ámbito científico para el lenguaje Python. Como ventajastiene un objeto de dimensión N, herramientas para integrar C/C++, facilidades paralas matemáticas en álgebra lineal, transformada de Fourier y números aleatorios. Porotro lado tiene la capacidad de datos genéricos multidimensionales y definir datosarbitrarios, haciendo esta librería perfecta para usar con bases de datos.

3.5.7.2. Pandas

Figura 3.23: Logotipo de Pandas.

Se trata de una biblioteca de análisis de datos para el lenguaje de programaciónPython, siendo una biblioteca de código abierto. Proporciona estructuras de datosy herramientas de análisis de datos de alto rendimiento, destacando por su facilidada la hora de usarla.

3.5.7.3. TFLearn

Figura 3.24: Logotipo de TFLearn.

Esta biblioteca de ML modular con API de nivel superior para TensorFlow, to-talmente compatible con ella. Nos será de especial utilidad a la hora de programarcon TensorFlow por las facilidades y agilidad que da a la hora de hacer operacionesmuy complejas de redes neuronales profundas en unas pocas líneas. TFLearn constade reguladores, optimizadores, métricas y soporte de múltiples entradas y salidas.

46 Capítulo 3.

Otra función muy útil es la visualización fácil de gráficos con detalle pesos, degra-dados, activaciones, etc. Por último es compatible con gran parte de las técnicas deaprendizaje profundo, entre las que está incluida las LSTM, de nuestro interés paraeste proyecto.

3.5.8. Administrador de archivos

3.5.8.1. Jupyter Notebook

Archivos Notebook de Jupyter.

Figura 3.25: Logotipo de Jupyter.

Jupyter sirve para “desarrollar software de fuente abierta, estándares abiertosy servicios para informática interactiva en docenas de lenguajes de programación”.Es una aplicación web para crear y compartir documentos que contengan códigos,ecuaciones, visualizaciones y textos narrativos en vivo, y también, simulaciones nu-méricas y modelado estadístico (figuras, tablas, etc.); todo ello de forma limpia yvisualización de los datos y aprendizaje automático. Soporta más de 40 lenguajesentre los que se destacan los lenguajes Python, R, Julia y Scala. Es especialmen-te útil en laboratorios de investigación por su capacidad de poder usar los mismoNotebook múltiples usuarios.

3.5.8.2. Google Colab

Archivos Notebook de Colab en Drive.

Figura 3.26: Logotipo de Google Colab.

Como alternativa se estudió Google Colab (de uso gratuito), el cual nos ayuda,de forma fácil, a aprender y utilizar TensorFlow. Es un proyecto reciente para lainvestigación del aprendizaje automático. Es un entorno de Jupyter Notebook queno requiere configuración y se ejecuta completamente en la nube, facilitando la posi-bilidad de compartir los documentos con menor esfuerzo. Permite ejecutar código en


Python, dando la opción de crear formularios para parametrizar código o incorporarbibliotecas de forma rápida. Finalmente, es de especial interés la aceleración hard-ware, permitiendo ejecutar los cuadernos de Colab en la CPU, GPU u otro hardwarelocal.

Capítulo 4

Desarrollo del proyecto

En este capítulo, se va a explicar la implementación del modelo del agente con-versacional basado en la recuperación (utilizando TensorFlow), a través del modeloDual Encoder LSTM para la generación de respuesta en diálogos. Los modelos basa-dos en la recuperación se alimentan de un dataset (en nuestro caso UDC), mientrasque los modelos generativos crean respuestas que nunca antes han visto. En términosgenerales, un modelo basado en la recuperación tiene por entrada un contexto c (laconversación hasta ese momento) y una respuesta potencial r. Los resultados quenos devuelve el modelo que vamos a utilizar es un puntaje para cada respuesta. Conel fin de encontrar la mejor respuesta posible, se calcula el puntaje para múltiplesrespuestas y se elige la que tenga el valor más elevado.

4.1. Archivos y ficheros

El proyecto está compuesto de los siguientes archivos, como se muestra en lafigura 4.1, todos ellos escritos desarrollados en el lenguaje de programación Python:

Figura 4.1: Distribución directorios y archivos del proyecto.

49

50 Capítulo 4. Desarrollo del proyecto

A continuación, se describen brevemente cada uno de los archivos:

udc_hparams.py, se definen todas las variables del modelo, asignándoles unvalor por defecto a cada una.

udc_inputs.py, se elige el modo de trabajo del modelo (entrenamiento o eva-luación) y se escoge el tipo de entrada de datos en consecuencia.

udc_metrics.py, se establece el bucle para la aplicación de la métrica recall@k.

udc_model.py, se crea el modelo para el cálculo de las pérdidas y las probabi-lidades en función del modo de trabajo.

udc_train.py, se establecen las variables para llevar a cabo el entrenamiento.

udc_test.py, se establecen las variables para llevar a cabo la evaluación.

udc_predict.py, se calculan las las predicciones y sus salidas por pantalla delterminal.

data, fichero compuesto de los archivos que conforman los datos del UDC y elmapa del vocabulario.

scripts/prepare_date.py, se preparan los datos del UDC para usarlos en Ten-sorFlow.

models/_init_.py, se inicializan los paquetes de Python.

models/helpers.py, se aplican el modelo GloVe.

models/dual_encoder.py, se cogen los word embedding del modelo GloVe y eldiseño de la RNN.

4.2. Preprocesamiento de los datos

Los datos utilizados desde el UDC vienen en formato CSV, pudiendo traba-jar con este tipo de archivo, pero como vamos a utilizar TensorFlow, lo mejor estransformarlos a un formato patentado de TensorFlow. El beneficio de hacer esto esintroducir los tensores directamente en TensorFlow, desde los archivos de entrada,y permitir que haga el mezclado de datos, procesamiento por lotes y el control de lacola de entrada.

4.3. Función de entrada 51

En el preprocesamiento se crea un vocabulario, donde a cada palabra del UDCse le asigna un número entero. Dichos números son almacenados en archivos de tipoTFRecord (train.tfrecords, validation.tfrecords y test.tfrecords) en lugar de guardarlas cadenas de palabras, siendo más fácil operar con estos enteros. Por otro lado,la correspondencia entre palabra y número de todo el vocabulario se guarda en unarchivo tipo txt. Después, estos enteros serán los que usaremos para aplicar el modeloGloVe. Como añadido, guardaremos y usaremos este vocabulario para mapear cadapalabra y poder reasignar a cada número entero su palabra correspondiente.

Cada ejemplo con el formato patentado de TensorFlow se distribuye en los si-guientes campos, todos ya descritos en la sección 3.2:

contexto: secuencia de identificadores en los datos de entrada, es decir, repre-senta las palabras dentro de cada cadena de palabras en la entrada al modelo.

context_len: la longitud de la secuencia de palabras en el contexto anterior.

utterance: secuencia de identificadores de palabras en la respuesta.

utterance_len: la longitud de la respuesta.

etiqueta: clasificación de los datos de entrenamiento en etiquetas positivos (eti-queta 1) y negativos (etiqueta 0).

distractor_[N ]: secuencia de identificadores de los distractores de las respuestasen los datos de validación y evaluación. N varía desde 0 a 8.

distractor_[N ]_len: la longitud de los distractores de las respuestas en losdatos de validación y evaluación. N varía desde 0 a 8.

4.3. Función de entrada

Ahora debemos crear un función de entrada para poder utilizar TensorFlow enel entrenamiento y la validación. En esta función de entrada nos interesa que nosdevuelva de forma repetitiva el batch de los datos de entrada, pero al tener dostipos de formatos de entrada, se han creado dos funciones diferentes, una para cadatipo de datos. Esta función nos devolverá el batch de características y las etiquetascorrespondientes a los datos. El código que hemos utilizado en el proyecto es elsiguiente:1 import tensorflow as tf23 def get_feature_columns(mode):4 # Codigo de obtencion de caracteristicas5 return set(feature_columns)67 def create_input_fn(mode , input_files , batch_size , num_epochs):8 def input_fn ():9 # Codigo de la funcion

10 return feature_map , target11 return input_fn

Código 4.1: Creación de la función de entrada en Python

52 Capítulo 4.

El feature_map contiene el batch de características, donde se guardan todoslos datos necesarios. En target se guardan las etiquetas (labels) para dichos da-tos. El código completo está en el archivo udc_inputs.py, accesible a través de losrepositorio en el Apéndice A.

En un alto nivel, la función hace los siguientes pasos:

Crea la definición de una función que obtenga los campos necesarios para elarchivo.

Lee los datos en los archivos de entrada con la función tf.TFRecordReader.

Analiza los datos teniendo en cuenta la definición de las características.

Obtiene las etiquetas del entrenamiento.

Devuelve los múltiples batchs y las etiquetas de entrenamiento.

4.4. Creando el modelo

Ahora nos encargaremos de escribir el código para el codificador dual LSTM denuestra NN , aplicando la fórmula de la “Pérdida de Entropía Cruzada” (3.1) vistaen el la sección “Arquitectura del modelo” 3.4.2. Debido a los diferentes tipos dedatos de entrada se ha de crear una función que actúe diferente para cada uno delos tipos. Esta función se encarga de conseguir los datos en el formato adecuado. Acontinuación, el código explicado con comentarios para un mayor entendimiento.1 def dual_encoder_model(2 hparams ,3 mode ,4 context ,5 context_len ,6 utterance ,7 utterance_len ,8 targets):9

10 # Inicializacion aleatori de los embeddings o preentrenada si estadisponible

11 embeddings_W = get_embeddings(hparams)1213 # Embebido de los contextos y las respuestas14 context_embedded = tf.nn.embedding_lookup(15 embeddings_W , context , name="embed_context")16 utterance_embedded = tf.nn.embedding_lookup(17 embeddings_W , utterance , name="embed_utterance")1819 # Construccion de la \gls{rnn}20 with tf.variable_scope("rnn") as vs:21 # Utilizadmos una celula \gls{ltm}22 cell = tf.nn.rnn_cell.LSTMCell(23 hparams.rnn_dim ,24 forget_bias =2.0,25 use_peepholes=True ,26 state_is_tuple=True)2728 # Pasamos el contexto y la respuesta a la \gls{rnn}29 rnn_outputs , rnn_states = tf.nn.dynamic_rnn(30 cell ,31 tf.concat(0, [context_embedded , utterance_embedded ]),

4.5. Entrenamiento, validación y evaluación del modelo 53

32 sequence_length=tf.concat(0, [context_len , utterance_len ]),33 dtype=tf.float32)34 encoding_context , encoding_utterance = tf.split(0, 2, rnn_states.h)3536 with tf.variable_scope("prediction") as vs:37 M = tf.get_variable("M",38 shape =[ hparams.rnn_dim , hparams.rnn_dim],39 initializer=tf.truncated_normal_initializer ())4041 # "Prediccion" de una respuesta: c * M42 generated_response = tf.matmul(encoding_context , M)43 generated_response = tf.expand_dims(generated_response , 2)44 encoding_utterance = tf.expand_dims(encoding_utterance , 2)4546 # Producto punto entre la respuesta generada y la actual: (c * M) * r47 logits = tf.batch_matmul(generated_response , encoding_utterance , True)48 logits = tf.squeeze(logits , [2])4950 # Aplicacion de la sigmoidea para convertir logits a probabilidades51 probs = tf.sigmoid(logits)5253 # Calculo de la Perdida de Entropia Cruzada Binaria54 losses = tf.nn.sigmoid_cross_entropy_with_logits(logits , tf.to_float(

targets))5556 # Media de las Perdidas entre todos los batchs de los ejemplos57 mean_loss = tf.reduce_mean(losses , name="mean_loss")58 return probs , mean_loss

Código 4.2: Creación del modelo de codificador dual LSTM en Python

La función create_model_fn descrita en el archivo udc_model, coge el argu-mento de la función model_impl, la cual recibe en nuestro caso una red neuronaldel codificador dual LSTM, dual_encoder_model (pero podría ser de otro tipo). Elparámetro forget_bias olvida la parte del contexto menos relevante, configurándosecuanto más alto el valor, más relevante tiene que ser el contexto para que la red lomantenga. El código completo está en dual_encoder.py, accesible a través de losrepositorio en el Apéndice A.

4.5. Entrenamiento, validación y evaluación del modelo

Después de escribir el código real de la red neuronal, se crea el código repetitivopara entrenar, validar y evaluar el modelo. Este código será implementado en elarchivo udc_train.py, en el cual se crea el modelo completo de la red neuronal quevamos utilizar, así como sus parámetros hparams 1.1 def main(unused_argv):2 hparams = udc_hparams.create_hparams ()34 model_fn = udc_model.create_model_fn(5 hparams ,6 model_impl=dual_encoder_model)78 estimator = tf.contrib.learn.Estimator(9 model_fn=model_fn ,

10 model_dir=MODEL_DIR ,11 config=tf.contrib.learn.RunConfig ())12

1Los hparams son objetos personalizados que contienen hiperparámetros de nuestro modelo, pasándoselo almodelo al instanciarlo. Los hparams están definidos en hparams.py.

54 Capítulo 4.

13 input_fn_train = udc_inputs.create_input_fn(14 mode=tf.contrib.learn.ModeKeys.TRAIN ,15 input_files =[ TRAIN_FILE],16 batch_size=hparams.batch_size ,17 num_epochs=FLAGS.num_epochs)1819 input_fn_eval = udc_inputs.create_input_fn(20 mode=tf.contrib.learn.ModeKeys.EVAL ,21 input_files =[ VALIDATION_FILE],22 batch_size=hparams.eval_batch_size ,23 num_epochs =1)2425 eval_metrics = udc_metrics.create_evaluation_metrics ()2627 eval_monitor = tf.contrib.learn.monitors.ValidationMonitor(28 input_fn=input_fn_eval ,29 eval_steps =1,30 every_n_steps=FLAGS.eval_every ,31 metrics=eval_metrics)3233 estimator.fit(input_fn=input_fn_train , steps=None , monitors =[ eval_monitor ])

Código 4.3: Creación del entrenamiento, validación y evaluación delmodelo

La función model_fn nos dará las predicciones hechas por la red, tiene comoatributos los batchs, las etiquetas y el modo de funcionamiento (entrenamiento,validación o evaluación), explicados en la sección anterior 4.4. Así, podemos usaresta función como propósito general para entrenar el modelo.

Por otro lado, se crean unos estimadores para nuestro model_fn, dos funcionesde entrada para los datos de entrenamiento y evaluación, un diccionario para las mé-tricas de evaluación y un monitor. Este monitor evalúa el modelo cada cierto númerode pasos durante el entrenamiento, y declaramos estos pasos en FLAGS.eval_every2 y se lo pasamos al atributo every_n_steps. Una vez declarado todo esto, podemosentrenar nuestro modelo. El entrenamiento se ejecutará indefinidamente e iremos ha-ciendo checkpoints (puntos de control) de los datos automáticamente, a través deluso de TensorFlow, la cual guarda los datos en el archivo MODEL_DIR, permi-tiéndonos parar el proceso cuando queramos sin riesgo a perder los datos generados.Hay otras opciones que nos ofrece TensorFlow para parar la ejecución del código,como por ejemplo, hacer que se detenga en un número de steps predefinido o utili-zando la detección anticipada, haciendo que el entrenamiento pare cuando la métricade evaluación deje de mejorar (sobreajustar).

A continuación, se muestra un ejemplo, después de entrenar durante aproxima-damente 20,000 pasos los resultados que obtenemos por pantalla:

INFO:tensorflow:step = 19901 , loss = 0.43859953INFO:tensorflow:global_step/sec: 0.536721INFO:tensorflow:step = 20001 , loss = 0.44491133INFO:tensorflow:global_step/sec: 0.545422INFO:tensorflow:step = 20101 , loss = 0.29069793INFO:tensorflow:global_step/sec: 0.533171INFO:tensorflow:step = 20201 , loss = 0.494533INFO:tensorflow:global_step/sec: 0.543782INFO:tensorflow:Loss final step: 0.494533.

Código 4.4: Ejemplo de salida por terminal de un entrenamiento y surespectiva evaluación.

2Los FLAGS sirven para pasar parámetros al programa, a través de, la línea de comandos del terminal.

4.6. Métrica de evaluación: Recall@k 55

Como se puede ver, podemos ir viendo step a step las pérdidas (loss) que sevan calculando, además el global_step/sec nos dice un valor de referencia de lavelocidad a la que se ha ido calculando dicho rango de steps. Además, las pérdidasvan fluctuando, posiblemente por un sobreajuste. Los datos de los entrenamientosserán presentados mediante tablas en el capítulo siguiente.

Utilizando la herramienta TensorBoard, podemos ver los resultados del entre-namiento de forma gráfica, siendo así bastante más sencilla la interpretación de losdatos. La figura 4.2 muestra dicha gráfica:

Figura 4.2: Gráfica que muestra las pérdidas respecto de los steps a lo largodel entrenamiento.

En la gráfica podemos ver la evolución que han tenido las pérdidas, durante elentrenamiento del modelo. En el eje de ordenadas, se representan las pérdidas y enel eje abscisas la evolución de los steps. Se puede comprobar como las pérdidas hanido disminuyendo según se avanzaba el entrenamiento.

4.6. Métrica de evaluación: Recall@k

Para la implementación de la métrica recall@k utilizaremos la herramienta Ten-sorFlow, la cual ya tiene esta métrica incorporada, facilitándonos mucho la labor.Para utilizar esta métrica debemos crear un diccionario que devuelva la predicciónde la métrica y su etiqueta para cada k seleccionado.1 def create_evaluation_metrics ():2 eval_metrics = {}3 for k in [1, 2, 5, 10]:4 eval_metrics["recall_at_ %d" % k] = MetricSpec(metric_fn=functools.partial(5 tf.contrib.metrics.streaming_sparse_recall_at_k ,6 k=k))7 return eval_metrics

Código 4.5: Creación de la métrica de evaluación del modelo

Como solamente necesitamos dos argumentos en la función metric_fn, se hautilizado functools.partial, permitiéndonos utilizar solamente 2 de los 3 argumentosque hay disponibles.

56 Capítulo 4.

En este punto es conveniente aclarar cómo es exactamente el formato que es-tamos utilizando. En el entrenamiento se predice la probabilidad de que la parejacontexto-respuesta sea correcta. Por otro lado, durante la evaluación, además de estapredicción, se puntúa la respuesta y los 9 distractores y se elige el mejor de todosellos. Esto nos da un vector con 10 puntuaciones, donde cada puntuación correspon-de a la respuesta y los 9 distractores respectivamente, siendo siempre la respuestacorrecta el elemento 0 del vector. Cada respuesta se puntúa de forma independiente,con lo que la suma de todas las probabilidades no tiene que sumar 1. Esto últimose explicó en más detalle en la sección “Función de puntuación de las predicciones:Recall@k” 3.4.5.

Veamos un ejemplo correspondiente al entrenamiento de sección anterior:

INFO:tensorflow:Saving evaluation summary step 19751: loss =0.4483778 ,recall_at_1 =0.5625 , recall_at_2 =0.8125 , recall_at_5 =1.0, recall_at_10 =1.0INFO:tensorflow:Validation (step 19829): global_step =19751 , loss =0.4483778 ,recall_at_1 =0.5625 , recall_at_2 =0.8125 , recall_at_5 =1.0, recall_at_10 =1.0...INFO:tensorflow:Saving evaluation summary step 20001: loss =0.4419869 ,recall_at_1 =0.5, recall_at_2 =0.875 , recall_at_5 =1.0, recall_at_10 =1.0INFO:tensorflow:Validation (step 20080): global_step =20001 , loss =0.4419869 ,recall_at_1 =0.5, recall_at_2 =0.875 , recall_at_5 =1.0, recall_at_10 =1.0

Código 4.6: Ejemplo de salida por terminal de un entrenamiento y surespectiva evaluación.

Se muestra la evaluación de la red hasta ese momento, mostrando los resultadosde recall@k para los distintos k que hemos estipulado. También se nos muestra laspérdidas y el step global para que el que hace dicho cálculo. Los datos de las métricasde evaluación serán presentados mediante tablas en el capítulo siguiente.

Una vez más, con la herramienta TensorBoard, pero en este caso, se muestranlos resultados de la evaluación en la figura 4.3:

Figura 4.3: Gráfica que muestra el recall@1 respecto de los steps a lo largo delentrenamiento.

En esta ocasión, podemos ver la evolución de la probabilidad de acierto de re-call@1 durante el entrenamiento del modelo. En el eje de ordenadas está la probabi-lidad y en el de abscisas el número de step. En este caso, vemos como la probabilidadde acierto de la métrica de evaluación va aumentando su porcentaje de acierto.

4.7. Predicciones: Evaluar el modelo 57

4.7. Predicciones: Evaluar el modelo

Una vez entrenado nuestro modelo, procedemos a evaluarlo utilizando los check-points que hemos ido guardando durante el entrenamiento y pasándoselos al archivoudc_test.py. Este archivo ejecuta las métricas de evaluación de recall@k, pero enlugar de utilizar los datos de entrenamiento, en la evaluación utilizaremos datosnunca vistos por el modelo que acabamos de entrenar. Durante la predicción se haañadido al código una parte donde el usuario puede introducir sus datos para serevaluados por el modelo entrenado.

Vamos a mostrar el código relacionado al primer ejemplo:

1 test_df = pd.read_csv("./data/test.csv")2 elementId = randint(0, 10000)3 INPUT_CONTEXT = test_df.Context[elementId]4 POTENTIAL_RESPONSES = test_df.iloc[elementId ,1:]. values5 ...6 if __name__ == "__main__":7 hparams = udc_hparams.create_hparams ()8 model_fn = udc_model.create_model_fn(hparams , model_impl=dual_encoder_model)9 estimator = tf.contrib.learn.Estimator(model_fn=model_fn , model_dir=FLAGS.

model_dir)1011 print(colored(’[␣␣␣␣␣Context]’, on_color=’on_blue ’,color="white"),"{}".

format(INPUT_CONTEXT))12 print(’\n’)1314 for r in POTENTIAL_RESPONSES:15 prob = estimator.predict(input_fn=lambda: get_features(INPUT_CONTEXT , r))16 results = next(prob)17 if answerresults == results:18 print(colored(’[␣␣␣␣␣␣Answer]’, on_color=’on_green ’), "{}:␣{:g}".format(

r, next(prob)[0]))19 else:20 print(colored(’[␣␣␣␣␣␣Answer]’, on_color=’on_red ’), "{}:␣{:g}".format(r,

next(prob)[0]))

Código 4.7: Creación de la predicción del modelo

En este código, se puede ver como inicialmente se le asigna a INPUT_CONTEXTel contexto del ejemplo y a POTENTIAL_RESPONSES las 10 posibles respues-tas desde el archivo test.CSV. Después de definir los parámetros, pasamos al main,donde se recorre el vector POTENTIAL_RESPONSES, a través de, la variabler. Seguidamente, se van haciendo estimaciones con las predicciones calculadas entrer e INPUT_CONTEXT . Para finalmente imprimir cada resultado por pantalla.El código completo está en udc_predict.py, accesible a través de los repositorio enel Apéndice A.

Una vez entrenado nuestro modelo, procedemos a evaluarlo utilizando los check-points que hemos ido guardando durante el entrenamiento y pasándoselos al archivoudc_test.py. Este archivo ejecuta las métricas de evaluación de recall@k, pero enlugar de utilizar los datos de entrenamiento, en la evaluación utilizaremos datosnunca vistos por el modelo que acabamos de entrenar. Durante la predicción se haañadido al código una parte donde el usuario puede introducir sus datos para serevaluados por el modelo entrenado.

58 Capítulo 4.

La figura 4.4, es una predicción de como evalúa la red de los ejemplos anteriores,calculando las probabilidades para la respuesta y sus 9 posibles distractores:

Figura 4.4: Predicción de un ejemplo del UDC, de la respuesta y los 9distractores a una respuesta concreta.

En la figura 4.5, se muestra una segunda captura de pantalla, siendo la con-tinuación que aparece en el terminal una vez acabada la predicción de la figura4.4:

Figura 4.5: Predicción de un ejemplo introducido por el usuario.

4.8. Grafo del modelo 59

Primeramente, se nos muestra en la figura 4.4 el contexto a evaluar en azul.Seguidamente, se ve la respuesta correcta (como ya dijimos en la sección 4.6 esla primera respuesta), y después los 9 distractores que nos ofrece el UDC. Comopodemos ver, efectivamente la respuesta correcta (elemento 0) es la que mayor pro-babilidad ha obtenido, por ello está marcada en verde.

En la parte inferior podemos ver el tiempo que ha tardado la red en encontrarla respuesta correcta entre las 10 posibles.

En la segunda figura 4.5 de la predicción, la red nos pide insertar un contextoque nosotros queramos y después la respuesta a dicho contexto. La red evaluará laprobabilidad de que esa respuesta sea correcta respecto al contexto introducido. Sehan probado varias respuestas para un mismo contexto.

Como se puede ver en este segundo ejemplo, le hemos introducido un contextoy varias posibles respuestas a dicho contexto. Ha evaluado de forma correcta lasrespuestas, dando un mayor valor a las lógicas y uno menor a las que no tienensentido, aunque lo optimo habría sido un valor bastante más bajo a las erróneas.

4.8. Grafo del modelo

Para entender mejor el modelo, la herramienta TensorBoard nos ofrece unosgrafos bastante potentes para comprender los complicados entrenamientos de lasredes que se diseñan en TensorFLow.

Las redes neuronales tienen muchísimos nodos, con estos grafos se delimitan losnodos y se presentan de forma jerárquica. Los nodos son agrupados por nombre y asu vez, en cada nodo se agrupan diferentes atributos, como por ejemplo, las capasde la red y sus atributos correspondientes.

Los grafos tienen dos tipos de dependencias, los de datos y los de control. Lasdependencias de control usan líneas de puntos, mientras que las dependencias dedatos muestran el flujo de tensores entre dos operaciones y se muestran como flechassólidas (opacas). El grosor de cada flecha indica el tamaño total del tensor, siendocada flecha etiquetada con su respectiva dimensión.

Finalmente, una vista estructural de los nodos nos indica el nivel de cada uno. Sidos nodos tienen el mismo nivel, aparecen del mismo color; mientras que, los nodoscon una estructura única (no se repite en otros nodos), aparecen en gris.

En las figuras 4.6 y 4.7 se pueden ver, un primer grafo que representa la red neu-ronal programada en este proyecto y un segundo grafo que nos muestra la evaluaciónde la red.

En el primer grafo podemos ver, el nodo “rnn”, el cual representa la red neu-ronal, dentro están las células LSTM y las diferentes capas con sus atributos (ta-sa de aprendizaje, pesos, sesgo,...), todo junto conforma el modelo Dual EncoderLSTM . Este nodo “rnn” está conectado al nodo “OptimizeLoss”, donde se realiza

60 Capítulo 4.

el descenso del gradiente para el aprendizaje de los parámetros y el cálculo de laspérdidas (loss), utilizando el método Adam. El otro gran nodo conectado a estos esel “word_embedding”, donde se aplica la herramienta GloVe. Por último, el nodode “predicciones” está conectado a los nodos donde se calculan los parámetros de lared, ya que necesita ser alimentado de todos ellos para calcular las probabilidadesde cada respuesta.

Cabe destacar el nodo “save”, que se guarda todos los datos que se han idocalculando cada cierto número de steps indicado por el usuario.

En el segundo grafo, además de ver los parámetros del primero, podemos vercomo aplica la métrica recall@k para los distintos valores de k, a través, del nodo“predicciones”.

Además, los grafos nos dejan entrever otros datos como el batch, la media (mean)o los escalares, obtenidos desde el los checkpoints, imprescindibles para el cálculodel resto de parámetros.

Los grafos hasta ahora descritos son los representados en las figuras 4.6 y 4.7:

Figura 4.6: Grafo que muestra el flujo de datos del modelo durante elentrenamiento.

614.8. Grafo del modelo

Figura 4.7: Grafo que muestra el flujo de datos del modelo durante la evaluación.

Capítulo 5

Resultados y discusión

En este capítulo, se analizan los resultados obtenidos tras haber entrenado elmodelo Dual Encoder LSTM estudiado y adaptado para este proyecto, aplicandodiferentes parámetros. Los parámetros con los que se realizaron pruebas son losindicados en la sección 3.4.3, siendo estos: tamaño del batch, dimensión de la célulade la RNN, tasa de aprendizaje, steps, épocas, tamaño del vocabulario, dimensión delword embedding, máxima longitud del contexto, máxima longitud de la respuesta,optimizado y las pérdidas.

Vamos a ver los beneficios y los problemas que presenta cada entrenamiento,viendo las gráficas y representaciones. También, se verá la validación y test pa-ra conjuntos de datos entrenado con el modelo. A su vez, se analizarán los datosconseguidos al aplicar la métrica recall@k (sección 3.4.5) sobre los resultados, paracomprobar las predicciones obtenidas para los diferentes parámetros aplicados. Fi-nalmente, se hará una discusión de los resultados obtenidos para cada conjunto deparámetros del modelo.

5.1. Resultados

En esta sección se presentan los diferentes entrenamientos (Train) en una ta-bla donde se muestran los parámetros que se han ido modificando para cada unode los entrenamientos, así como el tiempo que se tarda con cada composición deparámetros en entrenar el modelo. Los parámetros durante los entrenamientos hansido variados y ajustados, considerando los resultados que se iban obteniendo en losentrenamientos precedentes, con el fin de ir convergiendo en una red lo más eficienteposible.

Debido al gran número de datos y resultados a explicar y comparar, además dela tabla mencionada, hay configuraciones de parámetros que no han sido expuestosen ella dado que son iguales para todos los entrenamientos, pero son relevantes parael estudio. Las configuraciones más relevantes son los siguientes: Los datos en losentrenamientos han sido guardados cada 25 steps para obtener unas gráficas másdetalladas. Durante los entrenamientos, cada 250 steps se hacía un checkpoint (pun-

63

64 Capítulo 5. Resultados y discusión

to de guardado) y la validación la red se hacía sobre este, por lo que los datos derecall@k que se mostrarán más adelante han sido recopilados cada 250 steps. Lamáxima longitud de cada contexto ha sido de 160 caracteres y la máxima longitudde respuesta de 80 caracteres. Por último, se suelen acabar los entrenamientos es-tableciendo un número total de épocas (conjunto total de ejemplos en el core), sinembargo, este se estableció en infinito y se finalizaron los entrenamientos por númerototal de steps alcanzados.

A continuación, se muestra en la siguiente tabla las pruebas y los resultadosobtenidos:

Grupo Train BatchSize

BatchSize Eval

RNNDim

Learn.Rate

Embed.Dim

Vocab.Size

TotalSteps

TotalTime

1 128 16 128 0.001 100 91620 3201 1h 40mín2 128 16 128 0.001 100 91620 5201 2h 45mín13 128 16 128 0.001 100 91620 5201 2h 45mín4 128 16 128 0.001 100 91620 5201 2h 45mín2 5 128 16 256 0.001 100 91620 5201 5h 30mín6 128 16 128 0.0001 100 91620 5201 2h 30mín3 7 128 16 128 0.01 100 91620 5201 2h 50mín8 128 16 128 0.001 150 91620 5201 3h4 9 128 16 128 0.001 75 91620 5201 2h 20mín10 128 16 128 0.001 100 97620 5201 2h 40mín11 128 16 128 0.001 120 97620 5201 2h 45mín512 128 16 128 0.001 75 97620 5201 2h 40mín13 256 32 128 0.001 100 91620 5201 4h 15mín6 14 256 32 256 0.001 100 91620 5201 10h 10mín15 64 8 128 0.001 100 91620 5201 1h 20mín16 64 8 256 0.001 100 91620 5201 2h 45mín717 64 8 512 0.001 100 91620 5201 8h 15mín18 1 1 32 0.001 100 91620 5201 13mín8 19 1 1 128 0.001 100 91620 5201 20mín20 128 16 128 0.001 100 91620 20201 10h 30mín9 21 128 16 256 0.001 100 91620 20201 20h 50mín

Tabla 5.1: Tabla de los parámetros de entrenamiento.

Pasemos a nombrar brevemente cada columna, para su mejor comprensión:

Columna 1 (Grupos): Agrupamiento de los entrenamientos según la cercaníade los parámetros.

Columna 2 (Train): Número de cada entrenamiento.

Columna 3 (Batch Size): Tamaño del lote de ejemplos durante el entrenamiento.

Columna 4 (Batch Size Eval): Tamaño del lote de ejemplos en la evaluación.

Columna 5 (RNN Dim): Dimensión de la célula de la (RNN).

Columna 6 (Learn. Rate): Es la tasa de aprendizaje.

5.2. Entrenamiento, validación y test 65

Columna 7 (Embed. Dim): Dimensión de la matriz del Word Embedding.

Columna 8 (Vocab Size): Tamaño del vector de vocabulario.

Columna 9 (Total Steps): Número total de steps a alcanzar para que se acabeel entrenamiento.

Columna 10 (Total Time): Tiempo total que ha tardado la red en completar elentrenamiento.

La tabla está organizada horizontalmente por parámetros y verticalmente losentrenamientos. También están agrupados los entrenamientos por similitud de datosvariados, es decir, agrupando entrenamientos con igual configuración excepto por unúnico parámetro cambiado.

Esta división en grupos nos permite hacer un análisis de los datos más cómodoy eficiente, siendo estos de cada entrenamiento por separado, la visualizando lasgráficas obtenidas en TensorBoard y de cada grupo de entrenamiento en conjunto.

5.2. Entrenamiento, validación y test

En esta sección, se van a analizar los diferentes entrenamientos dentro de un mis-mo grupo. Los análisis se harán basándonos en las gráficas sacadas de la herramientaTensorBoard para cada entrenamiento individual. Hay dos tipos de gráficas:

Las gráficas en color naranja, muestran la evolución de las pérdidas enfrentadasa los steps durante los entrenamientos.

Las gráficas de color azul, muestran la evolución del porcentaje de acierto dela métrica de evaluación recall@k respecto a los steps.

En las gráficas se puede ver en una línea más clarita el valor real de los datos,y en un primer plano, en un color más oscuro los datos suavizados (smoothing)por la técnica de alisamiento exponencial, en la cual se suavizan los datos de seriesde tiempo usando la función de ventana exponencial (teniendo en cuenta los datosanteriores). Este smoothing se ha ajustado a un valor de 0.6, teniendo en cuenta unarelación de compromiso entre la clara visión de la posible convergencia o divergenciaen la totalidad de gráfica y la varianza de los datos a lo largo de la evolución de lagráfica.

5.2.1. Grupo 1: Train 1, 2 y 3

Este primer grupo de entrenamientos no es muy relevante para nuestros estudio,ya que, solamente se utilizó para ajustar los parámetros de la red y comprobar elcorrecto funcionamiento de la misma durante entrenamientos largos. Con lo que losdatos obtenidos en este grupo no son relevantes.

66 Capítulo 5.

El Train 1 fue el el primer entrenamiento exitoso de la red tras ajustar el código ylas herramientas, ajustando el número de steps totales en 3201 y parámetros internoscomo el número de steps necesarios para realizar la métrica de evaluación recall@k(eval_every) cada 1250 steps, ya que los datos recopilados durante la evaluacióneran insuficientes para apreciar el correcto funcionamiento de la misma.

Al realizar el Train 2 se estableció el valor de eval_every en 501 steps y una du-ración del entrenamiento de 5201 steps, siendo considerablemente superior al Train1. De esta manera, se comprobó que entrenamientos superiores a 2h eran posiblesen nuestro modelo, además de ver que el valor de eval_every se podía ajustar aúnmás. El Train 3 se hizo para terminar de determinar la variable eval_every, conun resultado final de 251, el cual permanecerá constante a lo largo de los siguientesentrenamientos del modelo.

5.2.2. Grupo 2: Train 4 y 5

El Train 4 en términos generales es el mismo que el Train 3, pero habiendoajustado parámetros internos de TensorFlow sobre los checkpoints. Este grupo deentrenamientos nos aportan datos relevantes a cerca de la red. A continuación, mos-tramos las gráficas de los entrenamientos:

(a) Pérdidas Train 4. (b) Pérdidas Train 5.

Figura 5.1: Pérdidas en los entrenamientos 4 y 5.

En las gráficas 5.1 se pueden ver las respuestas ante dos valores diferentes dela dimensionalidad de la RNN, un valor de 128 a la izquierda 5.1a y de 256 a laderecha 5.1b. A mayor valor empieza a estabilizarse mucho antes (debido a quetiene el doble de neuronas) la red para ajustar los pesos en cada step, convergiendomás rápidamente al inicio, pero a partir de cierto valor le cuesta más converger, sinembargo, su varianza es mucho menor en todo momento.

Por otro lado, la figura 5.1b ha tardado el doble en llegar a un mismo valoraproximado de pérdidas. Teniendo en cuenta estos datos, nos quedamos con el pa-rámetro de 128, dado que es el que ha llegado al mismo valor de pérdidas en menortiempo.


Veamos la evolución de las métricas de evaluación:

(a) Recall@1. (b) Recall@2. (c) Recall@5.

Figura 5.2: Recall@k en el Train 4.



En estas gráficas podemos ver una menor varianza durante el Train 4 y un por-centaje de acierto superior durante todo el entrenamiento, aunque se puede apreciarcomo los valores se van aproximando en ambos entrenamientos hacia el final. Estoes debido a que el Train 4 converge de una forma constante, por lo que su porcentajede acierto crece de forma más constante que en el Train 5.

Respecto a la varianza en el Train 5, deberían ser datos más estables debido a queel entrenamiento tiene poca varianza a partir de cierto step, pero este entrenamientoes considerablemente largo y el recall@k no se hace sobre la media, sino sobre el valorinstantáneo, siendo estos dispares aunque con baja varianza. Si repitiéramos el Train5, nos daría una gráficas distintas por ser tan largo el entrenamiento, estabilizándosemuchos más allá de los 5201 steps que tenemos configurados.

Finalmente se muestra el resultado a la métrica recall@10:

Figura 5.4: Pérdidas Recall@10 para todos los entrenamientos.

68 Capítulo 5.

Lógicamente, al tener 10 ejemplos y tomar como correctas las 10 respuestas, laprobabilidad de acierto es 100% siempre, luego la gráfica resultante es una rectaplana en el valor 1.0.

La gráfica 5.4 es común para todos los entrenamientos realizados, ya que, elUDC siempre usa 10 ejemplos para el documento CSV de validación y test. Por lotanto, esta gráfica se omite en los siguientes entrenamientos, para no ser repetitivosni redundantes.


En este tercer grupo se ha variado la tasa de aprendizaje, para observar comocambiarán los resultados sobre nuestro modelo. Como se puede ver en la figura 5.5,cuanto menor es el valor de la tasa de aprendizaje, se tendrán menos oscilaciones ymás rápido converge, no llegando al mínimo global y siendo más propenso a quedarseen mínimo local. Se puede apreciar en la figura 5.5a, donde no sigue progresando elaprendizaje, viéndose prácticamente una recta. Como es de esperar en la figura 5.5bocurre todo lo contrario, al haber aumentado la tasa de aprendizaje.

Siendo nuestro objetivo llegar al mínimo global, y tener una varianza menosbrusca que la vista en la figura 5.5b, dejaremos el valor como en el grupo de entre-namiento anterior, en 0.001.

Los tiempos en completarse el aprendizaje no se han tenido en cuenta, debidoa que no varían mucho al modificar la tasa de aprendizaje, con lo cual es un dato atener en cuenta en el análisis de este grupo.



Ahora vamos a ver los efectos de la variación de la tasa de aprendizaje sobrela métrica de evaluación. Los datos analizados en este párrafo se pueden ver en lassiguientes gráficas:






Como cabía esperar, los resultados en las figuras 5.6, a pesar de la varianza,siempre giran en torno al mismo porcentaje de acierto, ya que la red está estancadaen un mínimo local. En las figuras 5.7 se ve como va aumentando el porcentaje deacierto a medida que se avanza en los steps, pero siendo su varianza aún así mayorque el visto en el Train 5, por lo tanto, nos quedaremos con el Train 5.


En este grupo de entrenamiento se varió la dimensión del vector donde se guar-dan los word embedding, es decir, el número de relaciones que se hacen de unapalabra respecto a otras dentro del UDC.

En el Train 8 se aumenta el valor a 150, y en el Train 9 se disminuye a 75. Comose puede ver en la figura 5.8, no hubo grandes diferencias al variar este parámetroen el aspecto de la convergencia de las pérdidas, además, se puede apreciar una zonaplana entre los 1000 y los 2000 steps, resultado contrario a nuestros intereses.

Desde el punto de vista de la duración del entrenamiento, al tener que realizarun mayor número de relaciones, el tiempo si varia considerablemente. En el Train 8el tiempo es mayor, luego se descarta por esto mismo. Por otro lado, en el Train 9el tiempo fue menor pero, como ya se ha comentado en la figura 5.8b, aparece esazona plana indeseada.

70 Capítulo 5.



En las métricas de evaluación para estos entrenamientos, como se ve en lasfiguras 5.9 y 5.10 los porcentajes de acierto son mayores cuanto más alto es el vectordel word embedding para cada respectivo recall@k, pero en ambos se dispara lainestabilidad durante todo el entrenamiento, lo que hace la red menos controlable.





5.2.5. Grupo 5: Train 10, 11 y 12

Tras las pruebas del grupo anterior, se relaciona el word embedding con el ta-maño del vocabulario, al estar ambos parámetros estrechamente ligados entre ellos,debido a las relaciones que se crean dentro del word embedding hechas sobre laspalabras del vocabulario guardado en el parámetro vocab_size.


Primeramente, se realiza una prueba en solitario en el Train 10 subiendo eltamaño del vocabulario para ver como afecta al modelo. Como se ve en la figura5.11a hay una descenso pronunciado al inicio de las pérdidas y la varianza del sistemaen general aumentó, pero sigue siendo estable, luego se puede variar este dato sinesperar grandes distorsiones.

No se hizo la prueba con un valor del vocab_size menor, ya que, no tiene sentidobuscar un menor número de palabras en el vocabulario por que la red tendría unvocabulario más pobre del que aprender, resultando en un modelo final con conoci-mientos menores que en los entrenamientos anteriores.

Lógicamente, dada la relación directamente proporcional entre el vocab_size y elembedding_size, se han de subir los valores de ambos parámetros simultáneamente.Teniendo en cuenta esto, se llevó a cabo la prueba del Train 11, incrementandoligeramente ambos valores en el primero.

Como caso especial, se quiso comprobar en el Train 12 que ocurriría al decremen-tar el parámetro embedding_size y mantener alto el parámetro vocab_size. Comose ven en las gráficas 5.11b y 5.11c la zona inicial donde se produce el descensode las pérdidas provocada por el aumento del tamaño del vocabulario se mantiene.El aumento de la varianza durante el entrenamiento, como vimos en el análisis delgrupo 5.2.4, también permanece junto a la zona plana provocada por un decrementodel valor del parámetro embedding_size.

Se puede concluir que simplemente se provoca una fusión entre los resultadosde ambos experimentos por separado, no ofreciendo ningún aliciente al combinarlosentre ellos.

(a) PérdidasTrain 10.

(b) PérdidasTrain 11.

(c) PérdidasTrain 11.

Figura 5.11: Pérdidas en los entrenamientos 10, 11 y 12.

Respecto a las métricas de evaluación de cada entrenamiento, ninguna de ellasofrece datos relevantes que mejoren los vistos anteriormente, luego no hay necesidadde destacar nada de estos resultados. A continuación, se muestran las gráficas:

72 Capítulo 5.







5.2.6. Grupo 6: Train 13 y 14

El último parámetro que aún no hemos cambiado es el tamaño del batch. Elbatch es el número de ejemplos que vamos a utilizar en cada step para entrenar lared, una vez usados todos ellos se procede a actualizar los pesos de las neuronas.Luego este parámetro es decisivo en el funcionamiento del modelo. A lo largo deeste grupo y los dos siguientes se prueban diferentes configuraciones para estudiarsus resultados sobre nuestro modelo.

En este primer grupo 6, se han duplicado los valores del tamaño del batch,tanto en el entrenamiento como en la evaluación. Como vemos en las figuras 5.15 losresultados son superiores que en los del grupo 2 (sección 5.2.2), teniendo una mayorconvergencia, es decir, llegando a unas pérdidas inferiores.




A su vez, en las figuras 5.16 y 5.17 también se puede comprobar como los por-centaje de acierto han sido superiores en todos los casos.





El inconveniente del aumento de este parámetro recae en el gran incrementoque sufre el tiempo de entrenamientos, llegando incluso a doblarse para un mismonúmero de steps, en consecuencia de tener que utilizar el doble de ejemplos por cadastep durante el entrenamiento.

74 Capítulo 5.

5.2.7. Grupo 7: Train 15, 16 y 17

Ahora analizamos el caso contrario al del grupo anterior, dividiendo entre dos elvalor del batch. Dado que los entrenamientos ahora son más cortos, a causa de quese utilizan la mitad de ejemplos por step, los entrenamientos tienen una duraciónmenor, por lo que se prueba con una dimensión de la RNN de 512, superior a lasque hemos visto en los grupos anteriores. El motivo ha sido el intentar compensar elincremento del tiempo que supone aumentar la dimensión de la RNN con respectoa la disminución del tiempo correspondiente a la reducción del valor del batch.

En las figuras 5.18a y 5.19 se puede comprobar como ocurre lo contrario al casodel grupo anterior, ya que se han llegado a unas pérdidas superiores pero se hatardado la mitad de tiempo en llegar. Además se observa una tendencia al inicio abajar rápidamente en el eje de ordenadas, empezando a converger a partir del valor0.7.

Aunque este factor pueda parecer favorable para el entrenamiento, si no se tienecuidado podría caerse en un mínimo local y estancarse el aprendizaje en ese punto.Esta circunstancia ocurre en el Train 16, representados en las figuras 5.18b y 5.20,donde claramente se ve como el sistema no progresa y no mejoran los datos tras esesalto inicial.

En el Train 17, a pesar de tener un mayor número de neuronas que los otros dosentrenamientos, esto no ha sido suficiente como para que la red evite los mínimoslocales, siendo más evidente en este caso, al haberse estancado en el valor de 1, siendoeste un error altísimo. Como aliciente, el tiempo tardado en realizar el entrenamientocompleto se ejecuta en un tiempo superior a las 8 horas, con lo que una dimensiónde 512 es absolutamente desaconsejable para este modelo.

(a) PérdidasTrain 15.

(b) PérdidasTrain 16.

(c) PérdidasTrain 17.

Figura 5.18: Pérdidas en los entrenamientos 15, 16 y 17.

En todas las figuras relacionadas con la métrica de evaluación de este grupo,también podemos ver como sus valores son muy inferiores a los de los grupos ante-riores, como se muestra a continuación:








5.2.8. Grupo 8: Train 18 y 19

Por último, se prueba un método, llamado Descenso del Gradiente Estocásti-co(del cual hemos hablado en la sección 3.4.4.5). Para aplicarlo a nuestro modelo,se ajusta el tamaño del batch a 1, utilizando tan solo un ejemplo por cada step.Con este método se llega muy rápidamente a un mínimo local o global, es decir, aunas pérdidas muy bajas. Por otro lado, una vez llegado allí no se siguen reducien-do las pérdidas, ya que, no se comparan varios en ejemplos en cada step, luego elaprendizaje se estanca, girando alrededor del mínimo encontrado sin aproximarse ael.

76 Capítulo 5.

Se han utilizado dimensiones de las RNN menores ya que se tratan de ejemplosindividuales, y no son necesarias grandes cantidades de neuronas para aprender decada ejemplo.

Como vemos en las figuras 5.22, desde el inicio se llega a un mínimo local y,no solamente no se progresa, sino que la varianza es altísima, indicando que se estámoviendo cerca de el todo el tiempo, saltando de un punto a otro, hasta el final delentrenamiento.



En cuanto las gráficas mostradas para la métrica de evaluación en ambos entre-namientos 5.23 y 5.24, se puede ver que al no tener una evolución progresiva en losentrenamientos, los resultados obtenidos no aportan ninguna información útil.






5.2.9. Grupo 9: Train 20 y 21

Tras el estudio de la variación de cada uno de los parámetros de la red y lasrespuestas del modelo ante estos cambios, se ha concluido que los Train 4 y 5 sonlos que mejor cumplen la relación de compromiso entre la estabilidad del modelo, laconvergencia de las pérdidas, la varianza durante la evolución de la red y tiempo deentrenamiento. Por este motivo, se han llevado a cabo entrenamientos mucho máslargos de esas dos pruebas, dejando que la red entrenara durante 20201 steps, enlugar de 5201 como en los anteriores, con el fin de ver y analizar la evolución delsistema en ambos casos.

En el Train 20 en la figura 5.25, de manera general, se ve como la gráfica empiezacon unas pérdidas altas, al iniciarse de forma aleatoria estos datos, y decrece rápida-mente hasta irse estabilizando en la parte final, indicándonos una buena velocidadde convergencia del sistema. Además, se puede ver como se han alcanzando unaspérdidas medias hacia el final del entrenamiento por debajo de 0.4, a diferencia de lafigura 5.1a donde no se pasaba de 5.5 aproximadamente. Al permitir que el sistemaentrene durante cuatro veces más de steps, el sistema tiene tiempo de convergerbastante más, llegando a verse en los steps finales la estabilidad del sistema, lo cualindica que las pérdidas se empiezan a estancar y por mucho más horas que se deje elsistema entrenar no van a descender las pérdidas mucho más. Más detalladamente,el sistema está próximo al mínimo global del sistema, siendo este punto el objetivofinal del descenso del gradiente llevado a cabo en los entrenamientos. Veamos lafigura en cuestión:

Figura 5.25: Pérdidas Train 20.

Finalmente, se analiza el tiempo de entrenamiento, habiendo este aumentadoconsecuentemente al número de steps incrementados, indicando que la velocidaddel entrenamiento ha sido constante. El aumento de la varianza hacia el final delentrenamiento es consecuencia de la aproximación al mínimo global, buscando elalgoritmo acotarlo durante su aproximación, pero sin llegar a diverger.

En las métricas de evaluación mostradas en las figuras 5.26, se puede ver co-mo han mejorado considerablemente los porcentajes de acierto, evolucionando laspuntuaciones de forma constate y llegando a una estabilidad final. En la figura 5.26podemos comprobar estas afirmaciones:

78 Capítulo 5.



Sin embargo, no se han podido reproducir puntuaciones tan altas a los obtenidosen el documento original [48], quizá el preprocesamiento de datos adicionales o laoptimización de hiperparámetros pueden aumentar un poco más los puntajes. En lasiguiente tabla se representa la comparación de valores medios para ambas redes:

Métrica LSTMTFG (%)

LSTMPAPER (%)

Recall@1 49.1 60.4Recall@2 72.2 74.5Recall@5 91.6 92.6Recall@10 10 10

Tabla 5.2: Tabla de resultados recall@k .

En cuanto al Train 21, podemos ver en la figura 5.27 y 5.28 como los resultadosson ligeramente mejores en comparación a los del Train 20, como era de esperar,debido a que al tener un mayor número de neuronas su aprendizaje es superior encada step.

Sin embargo, los resultados no son lo suficientemente significativos en relación altiempo de casi 21 horas que ha tardado la red en completar los 20201 steps. La reddel Train 20 habría obtenido resultados más concluyentes y estables en ese mismotiempo, aunque habría necesitado el doble de steps.

Figura 5.27: Pérdidas Train 21.

5.3. Resultados con PCA y t-SNE 79



Finalmente, considerando la relación de compromiso anteriormente comentadaal principio de esta sección, entre estabilidad, convergencia, varianza y tiempo deentrenamiento, la configuración óptima para este modelo será la del Train 20.

5.3. Resultados con PCA y t-SNE

Vamos a realizar los dos métodos explicados en la sección 3.3.2. El objetivo escoger un conjunto de datos de una alta dimensión y transformarlos en puntos pararepresentarlos en un espacio de una dimensión inferior, 2D o 3D. Recordemos queel vocabulario con el que trabajamos proviene del UDC, y estos métodos solamenteserá aplicado a las 91620 palabras que hemos predefinido para el grupo 5.2.2 en elparámetro vocab_size en la tabla 5.1.

5.3.1. Representación en PCA

Como podemos ver en la figura 5.29, se ha reducido de una dimensión de 100,a una dimensión de 3. El método PCA ha unido los datos de la red en una formaovalada, con dos puntos de mayor densidad en sus extremos. Estos puntos de mayordensidad nos indican un mayor número de datos de un tipo. Además se han coloreadocon 51 colores diferentes, indicando cada uno de estos colores un campo diferente.

Figura 5.29: Representación PCA en 3D mostrando las agrupaciones porcolores de cada punto.

80 Capítulo 5.

En la figura 5.30, podemos resaltar algunas de las palabras de nuestro vocabu-lario. Este sistema trabaja con los valores numéricos que habíamos preasignado acada palabra en el word embedding, con lo que previamente se ha vuelto a etiquetarcada número del vocabulario con la palabra que le correspondería.

Figura 5.30: Representación PCA en 3D mostrando las palabras de cadapunto.

En los puntos de mayor densidad de puntos, se atisban algunos grupos de pala-bras, en el de la derecha palabras relacionadas con el campo de la informática y enel de la izquierda, palabras como nombres y verbos más del ámbito cotidiano.

5.3.2. Representación en t-SNE

Esta técnica puede crear “mapas”, en las dimensiones que más nos convenga,para su estudio a partir de cientos o miles de dimensiones.

Previamente a mostrar los resultados para este método, se han de aclarar dostecnicismos. El primero es el hecho de que este método no es lineal y se adaptaa los datos subyacentes, es decir, puede realizar diferentes transformaciones de losdatos en diferentes regiones. Fuera de la vista del usuario, el algoritmo realiza todotipo de ajustes para ordenar sus visualizaciones. Además, la técnica ofrece ligerasvariaciones residuales en las soluciones, a pesar de ser los mismos valores, debido altipo de procesamiento.

La segunda característica a aclarar es la perplejidad, que dice cómo equilibrar laatención entre los aspectos locales y globales de sus datos. De manera más simple,este parámetro es una estimación del número de vecinos cercanos que tiene cadapunto. Una baja perplejidad nos muestra datos locales, viendo en más detalle lasrelaciones de palabras. Una alta perplejidad, muestra aspectos globales de la red,observando como se relacionan los clusters entre sí.


El método t-SNE expande clusters densos y contrae los menos poblados, luegola relación entre tamaños relativos de parcelas tanto locales y como globales, y su“distancia” no son datos significativos.

Una vez explicado todo lo anterior, ya podemos hablar de los resultados obteni-dos. Cada uno de los siguientes resultados se capturaron tras más de 2000 iteraciones,cuando se observó una estabilidad del sistema. Se utiliza una tasa de aprendizaje de10 y una perplejidad de 76, siendo este el valor que nos recomendaba la herramien-ta TensorBoard para nuestra cantidad de datos, no pudiéndose saber el valor másadecuado de perplejidad de forma teórica. Veamos los resultados primero en 2D:

Figura 5.31: Representación t-SNE en 2D con perplejidad 76.

En la figura 5.31 se puede ver una forma ovalada con dos nodos interiores demayor densidad, mostrando las agrupaciones por colores de cada punto. De estanube de puntos no se puede sacar información de las etiquetas de colores, pues estántodos mezclados sin relación aparente. En cuanto a la forma de la nube, si se deduceque los clusters centrales de mayor densidad, efectivamente son ambos un conjuntode datos verdaderamente denso, debido a que el t-SNE tiende a expandir los puntosde gran densidad, representándose en la nube que rodea a los clusters centrales.


82 Capítulo 5.

En la figura anterior se muestra las palabras de cada punto, no pudiendo encon-trar ninguna relación entre ellas, ya que tiene 91620, habría que inspeccionar muydetalladamente para ver como la red ha aprendido a relacionarlas entre ellas.

En las figura 5.33 se representa la figura 5.31 pero en 3D. Se puede interpretar laestabilidad del sistema por la forma esférica y la distribución uniforme, con espaciosaproximadamente iguales entre los puntos.


Como curiosidad también se han añadido las palabras más superficiales de la reden esta visión, no pudiendo encontrar de nuevo ninguna relación. A continuación, lafigura referida:


Ahora se muestra la representación de la misma red, pero cambiando la perple-jidad, para estudiar otros posibles resultados.

Se opta en primera instancia por una perplejidad de 100, debido a la gran can-tidad de vocabulario, con el fin de ver las relaciones más globales entre clusters. Acontinuación, la representación obtenido aplicando t-SNE:



La forma resultante nos dice bastante información, existen dos claros clusters,teniendo uno de ellos una nube de datos a su alrededor y ambos unidos por una colade datos. Las líneas están ligeramente curvadas hacia afuera en el diagrama en laparte de la cola. La razón es que como de costumbre este método tiende a expandirlas regiones de datos más densas, luego la nube de datos y el cluster al que rodeason los puntos de mayor densidad, a pesar de que ambos clusters tengan el mismotamaño, está falsamente representado. Por otro lado, dado que el centro de la nubetiene espacio vacío a su alrededor, esto es también un indicador de que el algoritmomagnifica la representación.


En la figura 5.36 se muestran las palabras más superficiales de la representaciónvista en la figura 5.35. Una vez más, se ve un cluster con palabras relacionadas conla informática al final de la cola, al igual que sucede en el diagrama del PCA, en lafigura 5.30. No estando muy clara la representación del otro cluster.

Los resultados para una perplejidad de 38, es decir, algo inferior para la quenos recomendaba la herramienta TensorBoard, nos aporta una información bastante

84 Capítulo 5.

parecida a la vista para una perplejidad de 100. Se han visto los mismos patronesy, por lo tanto, no se hacen suposiciones nuevas.

A continuación, la figura para la perplejidad de 38:


Por último se ha aplicado t-SNE con una perplejidad de 5. Los datos aportadosson interesantes desde las primeras iteraciones hasta su estabilidad final, más alláde las 2000 iteraciones.

En las figuras 5.38 y 5.39 se pueden ver unas hileras iniciales, donde se relacionanlas palabras de ámbito informático antes mencionadas.

Figura 5.38: Representación t-SNE en 3D con perplejidad 5, iteración 700.


Más detalladamente la zona central, mostrando las palabras en cada punto:


En las siguientes iteraciones, tras pasar por varias formas, se muestran hasta tresdiferentes clusters de palabras bien definidos, deduciendo que uno de estos clustersesta oculto en las anteriores representaciones, al ser probablemente bastante menosdenso que los otros dos. Lo podemos ver en la siguiente representación:


Finalmente, después de más de 2000 iteraciones se obtienen diferentes resultadosen bastantes ocasiones, casi todos muy parecidos a los mostrados en las figuras 5.35para una perplejidad de 100 y la figura 5.37 para una perplejidad de 38.

86 Capítulo 5.

5.4. Predicciones: Evaluar el modelo

Como parte final de nuestro modelo se explican los resultados obtenidos trasrealizar predicciones de texto con nuestro modelo ya entrenado. Además, se analizanlos resultados que ya se mostraron en la sección 4.7, con el fin de entenderlos en mayorprofundidad.

Veamos de nuevo la evaluación hecha con nuestra red y otro ejemplo más:

Figura 5.41: Predicción de una respuesta ante un contexto aleatorio del UDC.


Como podemos ver, utilizando la red de grupo 9 5.2.9, se ha conseguido queprediga correctamente la solución al contexto de entrada de entre las 10 posibles

5.4. Predicciones: Evaluar el modelo 87

respuestas en los dos ejemplos, utilizando la métrica recall@1. No olvidemos que laprobabilidad de acertar en la respuesta es de tan solo el 50%, como vimos en lagráfica 5.26a, es decir, que no siempre acertará en su elección, como se muestra enla siguiente imagen:


En este ejemplo se le ha dado un valor bastante alto a la solución correcta(primera respuesta), pero no ha sido la más alta de todas las puntuaciones asignadasal resto de respuestas. Si miramos detenidamente cada solución, vemos que todaslas puntuaciones son superiores a esta, lo que nos indica que el error ha estado alpuntuar la primera respuesta de manera muy baja.

Recordemos que hay una segunda parte de predicciones, donde la red puntúalas respuestas introducidas por el usuario a un contexto también introducidos porel usuario. Volvamos a ver el ejemplo mostrado en la sección 4.7.

Figura 5.44: Predicción de una respuesta ante un contexto introducido por elusuario.

88 Capítulo 5.

Se puede observar que puntúa de forma correcta las respuestas 2 y 4, conside-rándose estas las correctas aunque de manera algo inferior. También puntúa conporcentajes demasiado altos a las respuestas incorrectas, siendo estas la 1 y la 3.Debería haber puntuado más alto a las respuestas correctas y más bajo a las inco-rrectas. Se ha de destacar que no hay fallos en la ortografía, entando la red preparadapara leer las palabras ya procesadas, es decir, habiéndolas aplicado unos sencilloscambios. Por esto se han introducido los textos de manera especial.

5.5. Discusión

Tras los resultados expuestos en este capítulo, una vez parametrizada la red yentrenada durante un largo periodo de tiempo, se demuestra que la red diseñadafunciona a un alto rendimiento, similar al del artículo original [48] en el que estábasado.

Los datos expuestos a través de TensorBoard, tanto gráficamente como aplican-do técnicas de reducción de la dimensión, así como las evaluaciones hechas con lamétrica recall@k y las predicciones vistas por pantalla, han devuelto los resultadosesperados, demostrando el buen funcionamiento del entrenamiento llevado sobre elmodelo Dual Encoder LSTM. El grupo 5.2.2 se ha considerado finalmente el grupocon mejores resultados, por lo que se vuelve a ejecutar durante un tiempo cuatroveces mayor en el grupo 5.2.9,considerando este el grupo de referencia. Tras haberanalizado en detalle todos los resultados de los entrenamiento en cada grupo, seobservan las siguientes características entre cada grupo y el de referencia:

Al aumentar el número de neuronas en la red (5.2.3), se puede comprobar comoel tiempo se elevaba enormemente y la función convergía más lentamente, perosiempre de forma estable y constante, garantizando no caer en un mínimo local.

Al variar la tasa de aprendizaje (5.2.3), se influye en la velocidad de aprendizajepero, fuera de cierto rango, provocando altas varianzas o el estancamiento enun mínimo local, situaciones totalmente indeseadas.

Cuando se cambió la dimensión del word embedding (5.2.4), el aprendizajenecesita mucho más tiempo si lo aumentamos, al tener que revisar más relacio-nes entre vectores o la red puede ser demasiado pobre, como consecuencia dereducir el número de relaciones entre palabras.

Al modificar el tamaño del vocabulario a la vez que la dimensión del wordembedding (5.2.5) debido a que están estrechamente entrelazados, se observala unión de los efectos provocados por el cambio del word embedding sumadosa una mayor varianza, a causa de reducir el vocabulario, pero siempre de formaestable.

Al cambiar el tamaño del batch a la alza, se consigue una mayor convergencia,es decir, llegamos a una pérdidas inferiores, pero el tiempo de entrenamientoaumenta considerablemente.

5.5. Discusión 89

Al variar el tamaño del batch a la baja, el tiempo de entrenamiento disminuyepero por contra se llegan a unas pérdidas mucho peores que en el caso de refe-rencia, pudiendo caer incluso en un mínimo local, si no se ajusta este parámetrocuidadosamente.

Al ajustar el valor del batch a 1, el tiempo de entrenamiento se reduce másque en ningún caso y se llegan a valores de pérdidas muy bajos al principio delentrenamiento, pero su inconveniente es que no se llegará al mínimo global, seestancará en un mínimo local o alrededor del mínimo global.

Después de analizar la red del grupo 5.2.9 utilizando las técnicas de reducciónde la dimensionalidad PCA y t-SNE, se puede determinar como la red ha podidoaprender a crear agrupaciones de palabras, las cuales utiliza para encontrar lasrespuestas más probables a cada contexto de entrada y así poder conversar con elusuario.

Al comparar los métodos PCA y t-SNE, las representaciones finales que nosmuestran ambas técnicas son muy parecidas, con mismo número de nodos, dispersióny densidad de la nube alrededor de los nodos muy similar y forma global ovalada dela figura muy parecidos entre ambos. Siendo más determinista la técnica t-SNE, porla libertada que ofrece a ajustar su perplejidad y poder observar en cada iteraciónla evolución del aprendizaje, ofreciéndonos así una mayor información que el PCA.

Por último, dadas las probabilidades vistas en las gráficas de recall@1 (5.26a),método aplicado en las predicciones hechas por la red y vistas en las figuras 5.41,5.42 y 5.43, se han obtenido unos resultados congruentes en las predicciones querealizaba la red. Las probabilidades asignadas por recall@1 a las predicciones hechaspor la red han sido dentro de los márgenes esperados. Sin embargo, los resultadosvistos en 5.44, cuando el usuario introducía el contexto y las respuestas, la métricarecall@1 asignaba unos valores por debajo de los esperados.

Capítulo 6

Gestión del proyecto

En este capítulo se describe la gestión del proyecto: ciclo de vida, planificacióny presupuesto. Se analiza cada sección con un Estructura de Descomposición delTrabajo (EDT), un Diagrama de Gantt y tablas de presupuesto, respectivamen-te. Consiguiendo así, un análisis completo de los factores más importantes tantotemporales como económicos del proyecto.

6.1. Ciclo de vida

El proyecto ha sido divido en 6 grupos de tareas (del 0 al 5), cada una con susrespectivas subtareas para una óptima organización. Se ha desarrollado una EDT conel fin de organizar y definir el alcance total y tener una descomposición jerárquica,orientada al cumplimiento de los objetivos propuestos al inicio del proyecto.

Los grupos que encabezan el EDT son los siguientes:

1. Planificación y gestión.

2. Estudios previos.

3. Diseño del programa.

4. Desarrollo y mejora del programa.

5. Implementación y ajustes.

6. Ensayos del modelo.

91

Capítulo 6. Gestión del proyecto92

Figura 6.1: Estructura de descomposición del trabajo.

6.2. Planificación 93

6.2. Planificación

6.2.1. Planificación temporal

Después del desarrollo del EDT, se procede a elaborar la planificación temporalde las tareas que nos ocupan durante el proyecto. Se ha elaborado un Diagrama deGantt, donde se le asigna a cada tarea y subtarea un tiempo estimado de la duraciónde la misma.

Con el Diagrama de Gantt se planifican y programan las tareas a lo largo deun período determinado, en nuestro caso, 6 meses (desde el inicio en Marzo de 2018hasta el fin del proyecto en Agosto de 2018). Gracias a la fácil y cómoda visualizaciónde las tareas que se realizan, nos da la posibilidad de llevar un seguimiento y controldel progreso de cada etapa.

6.2.2. Planificación inicial

Los primeros tres meses se han dedicado al estudio de las RNN y la familiariza-ción del lenguaje de programación Python, así como de las herramientas a utilizar.Se necesitan tres meses para el estudio, ya que la curva de aprendizaje en un temasin conocimientos previos, como son las RNN, es lenta y costosa.

6.2.3. Planificación final

En los siguientes dos meses, se han realizado múltiples tareas al mismo tiempo,ya que unas dependen de otras, como el análisis de cada entrenamiento una vezfinalizado y el consiguiente reajuste de los parámetros de la red.

Por último, en el mes final se dedicó todo el tiempo a la redacción de estedocumento.

Capítulo 6. Gestión del proyecto94

GRUPO 0. PLANIFICACIÓN Y GESTIÓN

0.1 Planificación del proyecto

0.2 Elaboaración del presupuesto

0.3 Control del proyecto

0.4 Redacción del trabajo final de grado

GRUPO 1. ESTUDIOS PREVIOS

1.1 Estudios de machine learning

1.2 Estudio de redes neuronales

1.3 Estudio del NLP

1.4 Estudio de agentes conversacionales

1.5 Estudio del modelo LSTM

GRUPO 2. DISEÑO DEL PROGRAMA

2.1 Selección de herramientas de software

2.2 Familliarización con el lenguaje de programación python

2.3 Familliarización con las herramientas de software

2.4 Análisis del modelo Dual Encoder LSTM

GRUPO 3. DESARROLLO Y MEJORA DEL PROGRAMA

3.1 Creación de la estructura del programa principal

3.2 Integración de los ficheros básicos del programa

3.3 Implementación del código a la red neuronal

3.4 Desarrollo de la métrica de evaluación del entrenamiento

3.5 Desarrollo de funciones auxiliares

GRUPO 4. IMPLEMENTACIÓN Y AJUSTES

4.1 Entrenamiento del modelo

4.2 Validación del modelo

4.3 Comprobación gráfica de los ajustes del modelo

4.4 Reajuste de los parámetros del modelo

4.5 Entrenamiento del modelo reajustado durante mayor tiempo

GRUPO 5. ENSAYO DEL MODELO

5.1 Ensayos de validación del modelo

5.2 Uso de la interfaz para las predicciones

5.3 Uso de la métrica de evaluación sobre el modelo

5.4 Verificación del correcto funcionamiento del modelo

ago-18

Perido de tiempoActividades y grupos de actividades del proyecto

mar-18 abr-18 may-18 jun-18 jul-18

Figura 6.2: Estructura de descomposición del proyecto.

6.3. Presupuesto 95

6.3. Presupuesto

Para el cálculo del presupuesto se ha realizado un análisis de los costes aproxi-mados que supone el proyecto. Se han separado en costes directos (mano de obra ymaterias primas) y costes indirectos (categorizados directamente como otros costes).Finalmente se calculará el total.

En los siguientes apartados se explica y desglosa detalladamente la procedenciade cada coste relacionado con el proyecto.

6.3.1. Personal

Por una parte, los costes directos engloban el gasto de personal, entendiendocomo gastos de personal al tutor del proyecto (Ingeniero Senior), el investigador queasesoró el proyecto desde el Centro de Automática y Robótica (CAR) (IngenieroSenior) y al alumno (Ingeniero junior).

Para un alumno graduado en Ingeniería Electrónica Industrial y Automática seestablece un coste de 450 AC por mes. Para el tutor, se estiman 30 horas mensuales,siendo el sueldo por mes de 1.750 AC.

Tipo Coste (AC) Duración TotalCostes Directos

Ingeniero Senior 1.750 2 3.500Ingeniero Senior 1.750 6 10.500Ingeniero Junior 950 6 5.700

TOTAL 19.700

Tabla 6.1: Presupuesto del personal.

6.3.2. Material

En cuanto al hardware se ha utilizado un portátil HP ProBook-6470b con pro-cesador Intel i5 con CPU de 2,60 GHz y 8 GB de memoria RAM, con un valor de300 AC.

Se han añadido otros conceptos, teniendo en cuenta materiales extra que senecesitan para el desarrollo de algunas partes del proyecto, como puede ser el usode la red eléctrica por valor de 210 AC, la impresora por 175 AC o Internet con uncoste de 350 AC.

Se ha tenido en cuenta el coeficiente de amortización anual aplicable a produc-tos electrónicos según el Boletín Oficial del Estado (BOE) para el Impuesto sobresociedades [54] con un valor del 20%, obteniendo un coste de 80 AC.

96 Capítulo 6.

Tipo Coste (AC) Amortización (%) TotalCostes Indirectos

Hardware 300 20 60Red eléctrica 210 20 42

Impresora 175 20 35Internet 350 20 70

TOTAL 207

Tabla 6.2: Presupuesto del material.

Respecto al software, los frameworks y herramientas utilizados han sido de có-digo libre para abaratar costes. El programa usado para la redacción de la memoriaha sido TeXstudio, siendo este un programa de código libre que usa LaTeX.

6.3.3. Resumen de costes

Para terminar, se ha hecho la suma de todos los conceptos aplicables, siendoestos recopilados en la siguiente tabla:

Tipo Coste (AC)Costes Directos 19.700Costes Indirectos 207

TOTAL 19.907

Tabla 6.3: Presupuesto total.

Capítulo 7

Conclusiones y líneas futuras

Una vez finalizado el proyecto, en este último capítulo se van a hacer las con-clusiones finales atendiendo a todo lo desarrollado, implementado y entrenado enrelación al modelo Dual Encoder LSTM. También se hablará de los posibles desa-rrollos futuros que abre la elaboración de este proyecto.

7.1. Conclusión

Durante el desarrollo de este proyecto se han tenido en cuenta todas las investi-gaciones de vanguardia, dónde estamos en la actualidad y como de bien funcionanlos modelos. Un modelo de dominio abierto basado en recuperación como el desarro-llado en este proyecto, no es posible que pueda funcionar perfectamente, dado queno puede tener todas las respuestas para cubrir todas los contextos existentes. Parapoder tratar cualquier escenario posible es necesario un modelo generativo de domi-nio abierto, considerado más del campo de la Inteligencia General Artificial (AGI).Cuanto más largas sean las conversaciones, más importancia tendrá el contexto ymás complejo será el problema.

En una entrevista reciente, Andrew Ng 1, lo explica bien:

La mayor parte del valor del aprendizaje profundo hoy en día es en dominiosestrechos en los que puede obtener una gran cantidad de datos. Aquí hay un ejemplode algo que no puede hacer: tener una conversación significativa. Hay demos, y siseleccionas la conversación, parece que está teniendo una conversación significativa,pero si realmente la intentas tú mismo, rápidamente se descarrila.

Actualmente solamente se puede trabajar de manera automatizada en los do-minios más cerrados, por ejemplo, una interfaz de un chat para llamar a un Uber.Cualquier intento de automatización de un dominio abierto, en cuanto se alarguela conversación, el agente conversacional se perderá y dejará de ser funcional. Porotro lado, los modelos generativos cometen grandes gramaticales, produciendo gran

1https://www.seattletimes.com/business/baidu-research-chief-andrew-ng-fixed-on-self-taught-computers-self-driving-cars/

97

https://www.seattletimes.com/business/baidu-research-chief-andrew-ng-fixed-on-self-taught-computers-self-driving-cars/



98 Capítulo 7. Conclusiones y líneas futuras

rechazo en los usuarios. Por esto los modelos basado en la recuperación, que es-tán libres de errores gramaticales y respuestas ofensivas, son actualmente los másutilizados.

Para que un modelo generativo sea factible, las empresas necesitan una enormecantidad de datos y el uso de otras técnicas para que el agente conversacional no sesalga de sus raíles como ocurrió con Tay de Microsoft 2.

Una posible adaptaciones es el uso de otro tipo de modelo neuronal en nuestraimplementación, como por ejemplo podría ser el Seq2Seq, el cual debería funcio-nar correctamente, quizá aportándonos buenos resultados también. Por otro lado,se podría ampliar el proyecto, aunque de forma más compleja, realizando la imple-mentación de un agente conversacional generativo de dominio abierto, siendo estauna posible evolución de este proyecto.

7.2. Líneas futuras

En el desarrollo futuro de este proyecto, se ha intentado en todo momento estu-diar y adaptar el modelo Dual Encoder LSTM aplicado a un agente conversacional,de forma que pueda ser ampliable en un futuro, además de ser fiable en sus predic-ciones. En esta sección se desarrollarán posibles campos para la mejora o ampliaciónde este proyecto.

7.2.1. Desafíos comunes

Hay diferentes desafíos que aún no están superados a la hora de la construcciónde un agente conversacional, la mayoría de los cuales son actualmente campos deinvestigación muy activos.

7.2.1.1. Incorporando contexto

Para poder crear respuestas más ricas, los modelos necesitan integrar tanto elcontexto lingüístico como el contexto físico. El contexto lingüístico, al igual que laspersonas pueden hacer un seguimiento de la conversación según se va desarrollandoe intercambiando información. Las conversaciones se pueden integrar en un vector,pero realizarlo al nivel que lo hace un humano o incluso superior, es un auténticodesafío. Existen algunas investigaciones en curso que van en esa dirección como puedeser la “Construcción de sistemas de diálogo de extremo a extremo utilizando modelosgenerativos de redes neuronales jerárquicas” [55] y “Atención con intención de unmodelo de conversación en red neuronal” [56]. Por último, también es necesaria laincorporación de datos contextuales, como el día y la hora, la ubicación o informaciónbásica sobre el usuario.

2http://www.businessinsider.com/microsoft-deletes-racist-genocidal-tweets-from-ai-chatbot-tay-2016-3

http://www.businessinsider.com/microsoft-deletes-racist-genocidal-tweets-from-ai-chatbot-tay-2016-3



7.2. Líneas futuras 99

7.2.1.2. Personalidad coherente

Un agente conversacional tiene que producir respuestas semánticamente idénti-cas a los contextos de entrada. Esta tarea es muy complicada, ya que hace falta unconocimiento preciso del lenguaje. Normalmente, los sistemas generan respuestasplausibles, pero no semánticamente correctas, debido a que están entrenadas congrandes cantidades de datos de múltiples usuarios diferentes. Existen estudios quevan en la dirección de modelar una personalidad, como “Un modelo de conversa-ción neuronal basado en la persona” [57]. En la figura siguiente se puede ver esteproblema:

Figura 7.1: Respuestas incoherentes de un modelo conversacional. [4]

7.2.1.3. Evaluación de modelos

El método de evaluación ideal sería con un factor humano comprobando cadafrase si es correcta y de ayuda o no, pero esto sería terriblemente caro, ademásde que muchas veces no hay un objetivo fijo por parte del usuario, como ocurreen los modelos de dominio abierto. Durante este proyecto hemos usado la métricade evaluación recall@k, pero existen más tipos como BLEU, el cual se encarga deevaluar traducciones automáticas, basando se en la coincidencia de texto, ya que lasrespuestas sensatas pueden tener palabras o frases completamente diferentes. En elartículo “Cómo no evaluar su sistema de diálogo: Un estudio empírico de las medidasde evaluación no supervisadas para la generación de respuestas al diálogo” [58], seestudió como ninguna de las métricas de evaluación actuales se correlacionan con eljuicio humano, luego este sería un buen punto de estudio en el futuro.

7.2.1.4. Intención y diversidad

Uno de los problemas más comunes en los agentes conversacionales, es que tien-den a repetir respuestas genéricas como “¡Eso es genial!” o “No sé”, funcionan comorespuestas para muchos contextos de entrada diferentes. Las versiones más inicialesdel programa “Google’s Smart Reply” tendían a responder con "Te amo" 3 a prác-ticamente cualquier tipo de contexto. Hay estudios que tratan de cambiarlo, comoen “Una función objetivo que promueve la diversidad para los modelos de conversa-ción neuronal” [59]. Este problema es consecuencia tanto de los datos con los queentrenamos a los modelos, como de los algoritmos usados. Sin embargo, los humanostenemos una intención a la hora de producir una respuesta ante un contexto especí-fico de entrada, y debido a que los agentes conversacionales no tienen esta intención(y en particular los sistemas de dominio abierto), carecen de este tipo de diversidad.

3https://ai.googleblog.com/2015/11/computer-respond-to-this-email.html



Apéndice A

Anexo documentación

En este apéndice se exponen los documentos necesarios para la elaboración delproyecto. Todos estos archivos son accesibles desde los enlaces siguientes a dos re-positorios diferentes:

GitHub:

https://github.com/Mario-RC/chatbot-retrieval/tree/Mario-RC

Bitbucket

https://bitbucket.org/MarioRC280/tfg-estudio-y-analisis-de-las-aquitecturas-de-redes-neuronales/src/master/

101

https://github.com/Mario-RC/chatbot-retrieval/tree/Mario-RC



Apéndice B

Anexo cursos

En este apéndice se presentan los cursos que se han realizado para la obtenciónde los conocimientos previos a la realización del proyecto.

Los siguientes cursos se realizaron en los tres primeros meses del proyecto, con elfin de conseguir una fuerte base conocimientos tanto en ML, DL, RNN y TensorFlow.Se realizaron los siguientes cursos:

Machine Learning - Coursera Course (February - March 2018)

Neural Networks for Machine Learning - Coursera Course (Marzo 2018 - Abril2018)

Deep Learning with TensorFlow - IBM Cognitive Class (Abril 2018 - Mayo2018)

103

Apéndice C

Entorno socio-económico

El proyecto no busca un impacto inmediato de beneficios económicos. Principal-mente se enfoca en el estudio e implementación de un agente conversacional, comotambién en la investigación de herramientas y soluciones que permitan obtener co-nocimientos que podrían recaer en una futura explotación económica.

Se han estudiado los posibles problemas que surgen en la implementación deun modelo Dual Encoder con células LSTM en una RNN, extrayendo ideas de suconfiguración y mejora. Esto podría ser explotado por ingenieros expertos en agen-tes conversacionales, en una segunda fase de investigación en la que se estudie lasmaneras de aplicarlo a las redes actuales.

Como ejemplo práctico podría usarse en un entorno cerrado, donde el usuarionecesite ayuda sobre una tarea en particular, por ejemplo, en una página web, quese dedique a un producto en concreto y se deban solventar dudas simples en tiemporeal del contenido. Los principales beneficiarios de este servicio serían los usuarios,ya que, podrían disponer del contenido y resolver sus dudas de forma inmediata ysin interrupciones, mejorando la experiencia enormemente.

Existen otras disciplinas que necesitan soporte de un agente conversacional,como puede ser en el ámbito de la publicidad, introduciendo este modelo en unrobot de asistencia social. Otro buen ejemplo es en el campo de la sanidad, dondeun mismo agente social podría ayudar con las citas de los pacientes o las indicacionesadecuadas para encontrar una consultad dentro de un hospital. Se ha de enfatizarfinalmente las necesidades de disponer de unas técnicas de programación efectivas,donde la red no puede equivocarse ni fallar, siendo el ámbito de la salud un campoespecialmente delicado con los usuarios.

Para la correcta implementación de este modelo en la sociedad, sería necesarioel desarrollo de una interfaz adecuada para la interacción con el usuario. La interfazpodría desarrollarse para ordenadores o dispositivos móviles, con el fin de tener unacceso más sencillo y cómodo. Este trabajo es fácilmente realizado por un ingenierojunior con conocimientos en programación, pudiendo crear una aplicación atractivapara el usuario, que tan solo permita el intercambio de un mensaje a la vez, debidoa que nuestro modelo se basa en la recuperación y no tiene memoria a largo plazo.

105

Acrónimos

Adam Estimación de Momento Adaptativo

ANN Red Neuronal Artificial

API Interfaz de Programación de Aplicaciones

ASR Reconocimiento Automático de Voz

CNN Redes Neuronales Convolucionales

CPU Unidad Central de Procesamiento

CTC Clasificación Temporal Conexionista

DBN Redes de Creencias Profundas

DL Aprendizaje Profundo

DNN Redes Neuronales Profundas

GloVe Global Vectors for Word Representation

GNOME GNU Network Object Model Environment

GPU Unidad de Procesamiento Gráfico

GRU Unidad Recurrente Cerrada

GUI Interfaz Gráfica del Usuario

IDE Entorno de Desarrollo Integrado

IRC Internet Relay Chat

LSTM Long Short-Term Memory

LTS Long Term Support

ML Machine Learning

NLP Procesamiento del Lenguaje Natural

107

108 Acrónimos

NLTK Natural Language Toolkit

NN Redes Neuronales

PCA Análisis de Componentes Principales

RNN Redes Neuronales Recurrentes

Seq2Seq Sequence to Sequence

SGD Descenso del Gradiente Estocástico

SO Sistema Operativo

t-SNE t-Distributed Stochastic Neighbor Embedding

tf-idf Term Frequency–Inverse Document Frequency

TPU Unidad de procesamiento de Tensor

UDC Ubuntu Dialog Corpus

URL Localizador Uniforme de Recursos

VCS Sistemas de Control de Versiones

Word2Vec Word To Vector

Bibliografía

[1] B. Fletcher, “AI for Bank Robbers,” https://verneglobal.com/blog/ai-for-bank-robbers.

[2] C. Olah, “Understanding LSTM networks,” http://colah.github.io/posts/2015-08-Understanding-LSTMs/.

[3] “Figure 5 : A recurrent neural network and the unfolding in time of thecomputation involved in its forward computation.,” https://www.nature.com/articles/nature14539/figures/5.

[4] D. Britz, “Deep Learning for Chatbots, Part 1 – Introduction,”http://www.wildml.com/2016/04/deep-learning-for-chatbots-part-1-introduction/.

[5] D. Britz, “Deep Learning for Chatbots, Part 2 – Implementing a Retrieval-BasedModel in Tensorflow,” http://www.wildml.com/2016/07/deep-learning-for-chatbots-2-retrieval-based-model-tensorflow/.

[6] “Vector Representations of Words,” https://www.tensorflow.org/tutorials/representation/word2vec.

[7] J. Turian, L. Ratinov, and Y. Bengio, “Word Representations: A Simple andGeneral Method for Semi-supervised Learning,” pp. 384–394, 2010.

[8] R. Socher, M. Ganjoo, C. D. Manning, and A. Y. Ng, “Zero-shot LearningThrough Cross-modal Transfer,” pp. 935–943, 2013.

[9] R. Kumar, “Understanding Principal Component Analysis,” https://medium.com/@aptrishu/understanding-principle-component-analysis-e32be0253ef0.

[10] J. Johnson, “Principal Component Analysis,” https://shapeofdata.wordpress.com/2013/04/09/principle-component-analysis/.

[11] “Clusters in 2D with t-SNE VS PCA,” https://www.kaggle.com/puyokw/clustering-in-2-dimension-using-tsne/code.

[12] A. Ng, “Machine Learning,” https://www.coursera.org/browse/data-science/machine-learning.

[13] L. Shao, S. Gouws, D. Britz, A. Goldie, B. Strope, and R. Kurzweil, “Gene-rating Long and Diverse Responses with Neural Conversation Models,” CoRR,vol. abs/1701.03185, 2017.

109

https://verneglobal.com/blog/ai-for-bank-robbers

https://verneglobal.com/blog/ai-for-bank-robbers

http://colah.github.io/posts/2015-08-Understanding-LSTMs/

http://colah.github.io/posts/2015-08-Understanding-LSTMs/

https://www.nature.com/articles/nature14539/figures/5

https://www.nature.com/articles/nature14539/figures/5

http://www.wildml.com/2016/04/deep-learning-for-chatbots-part-1-introduction/

http://www.wildml.com/2016/04/deep-learning-for-chatbots-part-1-introduction/

http://www.wildml.com/2016/07/deep-learning-for-chatbots-2-retrieval-based-model-tensorflow/

http://www.wildml.com/2016/07/deep-learning-for-chatbots-2-retrieval-based-model-tensorflow/

https://www.tensorflow.org/tutorials/representation/word2vec

https://www.tensorflow.org/tutorials/representation/word2vec

https://medium.com/@aptrishu/understanding-principle-component-analysis-e32be0253ef0



https://shapeofdata.wordpress.com/2013/04/09/principle-component-analysis/

https://shapeofdata.wordpress.com/2013/04/09/principle-component-analysis/

https://www.kaggle.com/puyokw/clustering-in-2-dimension-using-tsne/code

https://www.kaggle.com/puyokw/clustering-in-2-dimension-using-tsne/code

https://www.coursera.org/browse/data-science/machine-learning

https://www.coursera.org/browse/data-science/machine-learning

110 Bibliografía

[14] T. Brants and G. Inc, “Natural Language Processing in Information Retrieval,”pp. 1–13, 2004.

[15] A. M. Turing, “Computing Machinery and Intelligence,” Mind, vol. 59, no. 236,pp. 433–460, 1950.

[16] W. J. Hutchins, L. Dostert, and P. Garvin, “The Georgetown-I.B.M. experi-ment,” pp. 124–135, 1954.

[17] A. Kannan, K. Kurach, S. Ravi, T. Kaufmann, A. Tomkins, B. Miklos, G. Co-rrado, L. Lukács, M. Ganea, P. Young, and V. Ramavajjala, “Smart Reply:Automated Response Suggestion for Email,” CoRR, vol. abs/1606.04870, 2016.

[18] Y. Wu, M. Schuster, Z. Chen, Q. V. Le, M. Norouzi, et al., “Google’s NeuralMachine Translation System: Bridging the Gap between Human and MachineTranslation,” CoRR, vol. abs/1609.08144, 2016.

[19] S. T. Roweis and L. K. Saul, “Nonlinear Dimensionality Reduction by LocallyLinear Embedding,” Science, vol. 290, no. 5500, pp. 2323–2326, 2000.

[20] T. Mikolov, M. Karafiát, L. Burget, J. Cernocký, and S. Khudanpur, “Recurrentneural network based language model.,” pp. 1045–1048, 2010.

[21] T. Mikolov, S. Kombrink, L. Burget, J. Cernocký, and S. Khudanpur, “Exten-sions of recurrent neural network language model.,” pp. 5528–5531, 2011.

[22] I. Sutskever, J. Martens, and G. Hinton, “Generating Text with Recurrent Neu-ral Networks,” pp. 1017–1024, 2011.

[23] S. Liu, N. Yang, M. Li, and M. Zhou, “A Recursive Recurrent Neural Networkfor Statistical Machine Translation,” pp. 1491–1500, 2014.

[24] I. Sutskever, O. Vinyals, and Q. V. Le, “Sequence to Sequence Learning withNeural Networks,” pp. 3104–3112, 2014.

[25] M. Auli, M. Galley, C. Quirk, and G. Zweig, “Joint Language and TranslationModeling with Recurrent Neural Networks,” pp. 1044–1054, October 2013.

[26] A. Graves and N. Jaitly, “Towards End-to-end Speech Recognition with Recu-rrent Neural Networks,” pp. II–1764–II–1772, 2014.

[27] A. Karpathy and L. Fei-Fei, “Deep Visual-Semantic Alignments for GeneratingImage Descriptions,” IEEE Trans. Pattern Anal. Mach. Intell., vol. 39, pp. 664–676, Apr. 2017.

[28] S. Hochreiter and J. Schmidhuber, “Long Short-Term Memory,” Neural Com-put., vol. 9, pp. 1735–1780, Nov. 1997.

[29] S. Hochreiter, “The Vanishing Gradient Problem During Learning RecurrentNeural Nets and Problem Solutions,” Int. J. Uncertain. Fuzziness Knowl.-BasedSyst., vol. 6, pp. 107–116, Apr. 1998.

[30] A. Graves, S. Fernández, F. Gomez, and J. Schmidhuber, “Connectionist Tem-poral Classification: Labelling Unsegmented Sequence Data with RecurrentNeural Networks,” pp. 369–376, 2006.

Bibliografía 111

[31] S. Hochreiter, “Untersuchungen zu dynamischen neuronalen Netzen. Diplomathesis, Institut für Informatik, Lehrstuhl Prof. Brauer, Technische UniversitätMünchen,” 1991.

[32] Y. Bengio, P. Simard, and P. Frasconi, “Learning Long-term Dependencies withGradient Descent is Difficult,” Trans. Neur. Netw., vol. 5, pp. 157–166, Mar.1994.

[33] K. Greff, R. K. Srivastava, J. Koutník, B. R. Steunebrink, and J. Schmidhuber,“LSTM: A Search Space Odyssey,” CoRR, vol. abs/1503.04069, 2015.

[34] R. Jozefowicz, W. Zaremba, and I. Sutskever, “An Empirical Exploration ofRecurrent Network Architectures,” pp. 2342–2350, 2015.

[35] F. A. Gers and J. Schmidhuber, “Recurrent Nets That Time and Count,” 2000.

[36] K. Cho, B. van Merriënboer, Ç. Gülçehre, D. Bahdanau, F. Bougares, H. Sch-wenk, and Y. Bengio, “Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation,” pp. 1724–1734, Oct. 2014.

[37] K. Yao, T. Cohn, K. Vylomova, K. Duh, and C. Dyer, “Depth-Gated LSTM,”CoRR, vol. abs/1508.03790, 2015.

[38] J. Koutník, K. Greff, F. J. Gomez, and J. Schmidhuber, “A Clockwork RNN,”CoRR, vol. abs/1402.3511, 2014.

[39] K. Xu, J. Ba, R. Kiros, K. Cho, A. C. Courville, R. Salakhutdinov, R. S. Zemel,and Y. Bengio, “Show, Attend and Tell: Neural Image Caption Generation withVisual Attention,” CoRR, vol. abs/1502.03044, 2015.

[40] N. Kalchbrenner, I. Danihelka, and A. Graves, “Grid Long Short-Term Me-mory,” CoRR, vol. abs/1507.01526, 2015.

[41] K. Gregor, I. Danihelka, A. Graves, and D. Wierstra, “DRAW: A RecurrentNeural Network For Image Generation,” CoRR, vol. abs/1502.04623, 2015.

[42] J. Chung, K. Kastner, L. Dinh, K. Goel, A. C. Courville, and Y. Bengio, “ARecurrent Latent Variable Model for Sequential Data,” pp. 2980–2988, 2015.

[43] J. Bayer and C. Osendorfer, “DRAW: A learning stochastic recurrent networks,”CoRR, vol. abs/1411.7610, 2015.

[44] M. M. Berg, “Modelling of natural dialogues in the context of speech-basedinformation and control systems,” 2014.

[45] S. Geman, E. Bienenstock, and R. Doursat, “Neural Networks and the Bias/-Variance Dilemma,” Neural Comput., vol. 4, pp. 1–58, Jan. 1992.

[46] G. M. James, “Variance and Bias for General Loss Functions,” Machine Lear-ning, vol. 51, pp. 115–135, May 2003.

[47] R. Kohavi, “A Study of Cross-validation and Bootstrap for Accuracy Estimationand Model Selection,” pp. 1137–1143, 1995.

112 Bibliografía

[48] R. Lowe, N. Pow, I. Serban, and J. Pineau, “The Ubuntu Dialogue Corpus:A Large Dataset for Research in Unstructured Multi-Turn Dialogue Systems,”CoRR, vol. abs/1506.08909, 2015.

[49] R. Kadlec, M. Schmid, and J. Kleindienst, “Improved Deep Learning Baselinesfor Ubuntu Corpus Dialogs,” CoRR, vol. abs/1510.03753, 2015.

[50] Y. Bengio, R. Ducharme, and P. Vincent, “A Neural Probabilistic LanguageModel,” 2001.

[51] J. Pennington, R. Socher, and C. D. Manning, “GloVe: Global Vectors for WordRepresentation,” pp. 1532–1543, 2014.

[52] L. van der Maaten and G. Hinton, “Visualizing Data using t-SNE,” Journal ofMachine Learning Research, vol. 9, pp. 2579–2605, 2008.

[53] D. P. Kingma and J. Ba, “Adam: A Method for Stochastic Optimization,”CoRR, vol. abs/1412.6980, 2014.

[54] A. E. B. O. del Estado, “Impuesto sobre Sociedades. Boletín Oficial del Estado.,”

[55] I. V. Serban, A. Sordoni, Y. Bengio, A. C. Courville, and J. Pineau, “Hierarchi-cal Neural Network Generative Models for Movie Dialogues,” CoRR, vol. ab-s/1507.04808, 2015.

[56] K. Yao, G. Zweig, and B. Peng, “Attention with Intention for a Neural NetworkConversation Model,” CoRR, vol. abs/1510.08565, 2015.

[57] J. Li, M. Galley, C. Brockett, J. Gao, and B. Dolan, “A Persona-Based NeuralConversation Model,” CoRR, vol. abs/1603.06155, 2016.

[58] C. Liu, R. Lowe, I. V. Serban, M. Noseworthy, L. Charlin, and J. Pineau, “HowNOT To Evaluate Your Dialogue System: An Empirical Study of Unsuper-vised Evaluation Metrics for Dialogue Response Generation,” CoRR, vol. ab-s/1603.08023, 2016.

[59] J. Li, M. Galley, C. Brockett, J. Gao, and B. Dolan, “A Diversity-Promoting Ob-jective Function for Neural Conversation Models,” CoRR, vol. abs/1510.03055,2015.

UNIVERSIDAD POLITÉCNICA DE MADRID ESCUELA TÉCNICA SUPERIOR DE...

Documents

Transcript of UNIVERSIDAD POLITÉCNICA DE MADRID ESCUELA TÉCNICA SUPERIOR DE...