Experimentación y comparativa de diferentes modelos de redes neuronales artificiales para el procesamiento del lenguaje natural

EXPERIMENTACIÓN Y COMPARATIVA DE DIFERENTES MODELOS DE REDES NEURONALES ARTIFICIALES PARA EL PROCESAMIENTO DEL LENGUAJE NATURAL Autor: Gabriel Jiménez Perera Tutor: Cayetano Guerra Artal TRABAJO DE FIN DE GRADO – GRADO EN INGENIERÍA INFORMÁTICA Julio 2017 1 [Página intencionadamente dejada en blanco] 2 AGRADECIMIENTOS Me gustaría empezar esta memoria agradeciendo la colaboración de todas aquellas personas que se han visto implicadas directa o indirectamente en este proyecto. Empezando por mi tutor, Cayetano Guerra Artal, quien, junto con Francisco Mario Hernández Tejera, me ha acompañado, aconsejado y ayudado en todo lo posible, ofreciendo todo su apoyo en cualquier cosa que le pedía. No me puedo olvidar de todos aquellos profesores que me han dado su consejo y que siempre estaban dispuestos a escucharme y responder mis inquietudes, como Margarita Díaz Roca, Octavio Mayor González o José Daniel Hernández Sosa. También tengo que reconocer el mérito de todos aquellos profesores que me han permitido llegar hasta aquí, enseñándome contenidos y valores en diferente medida. Además de los estrictamente académico, también agradezco enormemente el apoyo de mis amigos, compañeros y compañeros convertidos en amigos, con los que he compartido una etapa muy importante y valiosa de mi vida que, sin ellos, no habría sido tan satisfactoria. De una manera especial, debo reconocer el mérito de Alberto Casado Garfia, por ayudarme en las prácticas de varias asignaturas y de Laura del Pino Díaz, por su repositorio y consejo, sin los cuáles mi camino no habría sido tan directo. Finalmente, tengo que agradecer el apoyo de mi familia, que han sido mi pilar fundamental en la vida y me han permitido estudiar, facilitándome todo tipo de medios para lograr esta meta. 3 [Página intencionadamente dejada en blanco] 4 RESUMEN El procesamiento del lenguaje natural ha sido tradicionalmente una tarea compleja y poco trivial en el diseño de algoritmos. Gracias a la inteligencia artificial, se han logrado grandes progresos en este entorno y número de modelos que hacen frente a estos problemas normalmente poco tratables ha ido incrementando. Este proyecto propone experimentar y comparar tres modelos de redes neuronales artificiales que han tenido bastante éxito en el procesamiento del lenguaje natural: LSTM (Long Short-Term Memory), MemN2N (modelo propuesto por Facebook) y DNC (modelo propuesto por Google). Para esta tarea, estos modelos optimizados han sido adaptados a un ámbito concreto, con el objetivo de comparar los resultados de cada uno. 5 [Página intencionadamente dejada en blanco] 6 ABSTRACT Natural language processing has traditionally been a complex, hardly-trivial task in algorithm design. Thanks to artificial intelligence, great progress has been made in this environment and the number of models that face these usually hardly treatable problems has increasingly grown. This project proposes experimenting and comparing three artificial neural network models that have had quite accomplishment in natural language processing: LSTM (Long Short-Term Memory), MemN2N (model proposed by Facebook) and DNC (model proposed by Google). For this task, these optimized models have been adapted to a concrete scope, with the objective of comparing the results of each. 7 [Página intencionadamente dejada en blanco] 8 ÍNDICE AGRADECIMIENTOS ......................................................................................................... 2 RESUMEN.......................................................................................................................... 4 ABSTRACT ......................................................................................................................... 6 ÍNDICE ............................................................................................................................... 8 1 INTRODUCCIÓN ....................................................................................................... 10 1.1 PRESENTACIÓN DEL PROBLEMA .................................................................................. 10 1.2 ESTADO ACTUAL ..................................................................................................... 10 1.3 OBJETIVOS INICIALES ............................................................................................... 11 1.4 JUSTIFICACIÓN DE LAS COMPETENCIAS ESPECÍFICAS CUBIERTAS ......................................... 12 1.5 APORTACIONES ...................................................................................................... 12 1.6 METODOLOGÍA DE TRABAJO...................................................................................... 13 1.6.1 Materiales para el desarrollo...................................................................... 13 1.6.2 Metodologías de desarrollo ........................................................................ 13 2 EXPLICACIÓN DE MATERIAL UTILIZADO ................................................................. 14 2.1 TENSORFLOW......................................................................................................... 14 2.2 BABI DATASET ........................................................................................................ 15 2.3 CODIFICACIÓN DE LAS FRASES .................................................................................... 16 2.3.1 Bag of words ............................................................................................... 16 2.3.2 Position encoding........................................................................................ 17 3 FRAMEWORKS DE REDES NEURONALES CON MEMORIA ...................................... 18 3.1 LSTM .................................................................................................................. 18 3.1.1 El problema de las dependencias a largo plazo.......................................... 19 3.1.2 Explicación del modelo................................................................................ 19 3.1.3 Justificación................................................................................................. 22 3.2 MEMN2N ............................................................................................................ 23 3.2.1 Explicación del modelo................................................................................ 23 3.2.2 Justificación................................................................................................. 25 3.3 DNC .................................................................................................................... 26 3.3.1 Explicación del modelo................................................................................ 26 3.3.2 Justificación................................................................................................. 28 4 DATASET PROPIO..................................................................................................... 29 5 METODOLOGÍA DE PRUEBAS UTILIZADO ............................................................... 31 6 RESULTADOS OBTENIDOS ....................................................................................... 32 6.1 LSTM .................................................................................................................. 32 6.2 MEMN2N ............................................................................................................ 37 15 2.2 BABI DATASET El bAbI dataset de Facebook es un conjunto de datos sintético de tareas pregunta-respuesta creado por Facebook Research (Dialogue Learning With Human-InThe-Loop (forthcoming), arXiv:1611.09823). Este conjunto de datos es de los más usados en la actualidad, ya que cada tarea abarca una habilidad específica esperable de un agente razonador genérico. Cada una de las 20 tareas consiste en 1000 ejemplos de entrenamiento y 1000 ejemplos de test. Las tareas se generan a partir de una simulación de actores y objetos interactuando en un mundo pequeño y cerrado, produciendo texto descriptivo de la escena y parejas de pregunta/respuesta. La supervisión se proporciona en forma de respuestas para cada una de las preguntas junto con la localización de los hechos requeridos para responder la pregunta. La Ilustración 2 muestra un ejemplo de las 10 primeras tareas. Ilustración 2: Explicación del bAbI dataset Por supuesto, en el dataset la información está estructurada de una forma algo menos legible, pues además contiene la información necesaria para la supervisión: los hechos de soporte requeridos para responder la pregunta (que en nuestros experimentos no usamos). En cuanto a contenido, las tareas que utilizamos de este 16 dataset son muy simples: todas las frases se encuentran en presente simple y siempre se compone de un sujeto, un verbo (que indica movimiento, coger y soltar), y un destino u objeto. Este conjunto de datos utiliza el idioma inglés en la versión utilizada, aunque también existen versiones en hindi y con las letras intercambiadas. 2.3 CODIFICACIÓN DE LAS FRASES Para poder trabajar con las frases de cualquiera de los conjuntos de datos, estas se deben trasladar a una forma vectorial. Los métodos de codificación de frases en este modelo se basan en la representación “Bag of words” (BoW). 2.3.1 BAG OF WORDS BoW toma la frase 𝑥𝑖= {𝑥𝑖1, 𝑥𝑖2,… , 𝑥𝑖𝑛}, traslada cada palabra a una representación “one hot” (un vector de tamaño igual al número de palabras en el vocabulario inicializado a 0 y con un 1 en la posición correspondiente a la palabra) y suma los vectores resultantes: 𝑚𝑖=∑𝑥𝑖𝑗𝑗. El vector de entrada 𝑢, que representa la pregunta, también se traslada como BoW: 𝑢 = ∑𝑞𝑗𝑗 . El problema que presenta esta traslación es que no se puede capturar el orden de las palabras en la frase, que puede ser importante para algunas tareas. Para ejemplificar este mecanismo, supongamos un vocabulario = {universidad, llamo, Aristóteles, columna, me, Gabriel, cactus}, que tiene tamaño 7. La representación de las palabras del vocabulario quedaría así: Palabra Representación one-hot universidad [1,0,0,0,0,0,0] llamo [0,1,0,0,0,0,0] Aristóteles [0,0,1,0,0,0,0] columna [0,0,0,1,0,0,0] me [0,0,0,0,1,0,0] Gabriel [0,0,0,0,0,1,0] cactus [0,0,0,0,0,0,1] La representación BoW de una frase (“me llamo Gabriel”) sería la suma de los vectores de las palabras que se encuentran en dicha frase: Palabra Representación me [0,0,0,0,1,0,0] llamo [0,1,0,0,0,0,0] Gabriel [0,0,0,0,0,1,0] Resultado BoW (+) [0,1,0,0,1,1,0] 17 2.3.2 POSITION ENCODING Para representar el orden de las palabras en las frases (que en nuestros experimentos no se usa), se utiliza una segunda representación que toma la siguiente forma: 𝑚𝑖=∑𝑙𝑗𝑗 · 𝑥𝑖𝑗, donde · es una multiplicación elemento a elemento. 𝑙𝑗 es un vector columna con la estructura 𝑙𝑘𝑗 =(1 − 𝑘/𝐽)− (𝑘/𝑑)(1 − 2𝑗/𝐽), asumiendo que se indexa empezando en 1 y siendo 𝐽 el número de palabras en la frase y 𝑑 la dimensión de la matriz de traslación. Esta representación, llamada “Position Encoding” (PE), hace que el orden de las palabras afecte ahora a 𝑚𝑖. La misma representación se usa para las preguntas y las entradas y salidas de memoria. La forma de este vector puede verse en la Ilustración 3. Ilustración 3: Vectores utilizados en Position Encoding En resumen, Position Encoding asigna diferentes pesos a cada palabra en cada dimensión utilizando una multiplicación elemento a elemento, consiguiendo el efecto de añadir información de situación temporal a cada palabra en cada frase. 12345678910 1 2 3 4 5 6 7 8 9 10 -1 -0.8 -0.6 -0.4 -0.2 0 0.2 0.4 0.6 0.8 k j l(k,j) 18 3 FRAMEWORKS DE REDES NEURONALES CON MEMORIA Con este nombre se referencian a las arquitecturas recientes que añaden memoria a la arquitectura clásica de red neuronal y han provocado mayor interés en la comunidad. 3.1 LSTM Las redes LSTM son un tipo de red recurrente. Las redes recurrentes tienen una analogía con el comportamiento humano: los recuerdos, los pensamientos tienen persistencia. Las redes feed-forward no están preparadas para relacionar entradas en el tiempo de una forma sencilla. Para atajar este problema, las redes recurrentes tienen bucles, por lo que entre las entradas están sus salidas del momento anterior. Este comportamiento puede verse mejor en la Ilustración 4. Ilustración 4: Las redes recurrentes contienen bucles Los bucles aportan una característica muy interesante: poder acceder a información de un momento anterior. Las redes recurrentes pueden verse como varias copias de la misma red, cada una transmitiendo una información a su sucesora. Esto puede verse en la Ilustración 5. Ilustración 5: Una red recurrente “desenrollada” La naturaleza de cadena revela que estas redes están ligadas con secuencias y listas. Son las arquitecturas indicadas para el uso de este tipo de datos. 19 3.1.1 EL PROBLEMA DE LAS DEPENDENCIAS A LARGO PLAZO Como he indicado, las redes recurrentes están pensadas para casos en los que los datos están relacionados en el tiempo. Sin embargo, esto solo se da cuando el tiempo es suficientemente corto, pues la recurrencia no es una memoria en sí y los datos pasados se pierden muy rápidamente. En la Ilustración 6: Salida relacionada con entradas pasadas se ilustra este problema, donde una salida se relaciona con una entrada alejada en el tiempo. La brecha de tiempo entre la salida y la entrada con la que se relaciona es bastante grande y los bucles de la red no son suficiente. Ilustración 6: Salida relacionada con entradas pasadas 3.1.2 EXPLICACIÓN DEL MODELO Las redes LSTM (Long Short Term Memory, Hochreiter & Schmidhuber, 1997) son un tipo especial de redes recurrentes capaces de aprender dependencias a largo plazo. Para ello, tienen cuatro redes neuronales de una sola capa interactuando de una forma específica, las líneas negras funcionan a modo de buses de información en la Ilustración 7. Ilustración 7: Una red LSTM contiene cuatro capas 20 Las redes LSTM no son tan simples como una red recurrente en las que se basan, pero la idea detrás de ellas no es tan compleja como parece. La parte más novedosa en una LSTM es el estado, destacado en la Ilustración 8. Ilustración 8: Estado de la red LSTM El estado de una red LSTM es como una cintra transportadora. Va a través de toda la cadena, con solo algunas interaccione. Es muy fácil que la información solo fluya a través del estado sin modificaciones. Las LSTM tienen la habilidad de eliminar o añadir información al estado, pero estas modificaciones están reguladas cuidadosamente por unas estructuras que actúan como puertas. El primer paso en una LSTM sería decidir qué información del estado se elimina. Esto se hace a través de una red de salida sigmoidal (con salidas entre 0 y 1) que, basándose en la entrada, decide qué información se eliminará, como muestra la Ilustración 9. Ilustración 9: Fase de olvido de la información El siguiente paso sería añadir información al estado. Para ello se parte de la información de entrada y se crea un vector candidato de información nueva, a partir de 21 una red de salida tangencial (con salidas entre -1 y 1). Por supuesto, no toda la información candidata se memoriza, por lo que se necesita de otra red de salida sigmoidal que decidirá qué información se guardará, como se muestra en la Ilustración 10. Ilustración 10: Información a añadir al estado Con los datos obtenidos anteriormente, que decidirán qué información olvidar y cuál recordar, se actualiza el estado. Para ello, se multiplica el estado por el vector obtenido en el primer caso (vector compuesto por valores entre 0 y 1), por lo que se regula qué cantidad de información pasa. Además, se añade la información obtenida en el segundo paso, compuesta por un vector candidato multiplicado por el otro vector obtenido que decidirá en qué grado se guardará, como se enseña en la Ilustración 11. Ilustración 11: Modificación del estado Finalmente, se genera la salida, que estará basada en el estado, pero de una manera filtrada. La información del estado se pasa por una red de salida tangencial y se multiplica por la salida de una red de salida sigmoidal que depende de la entrada. Este comportamiento se puede ver en la Ilustración 12. 22 Ilustración 12: Generación de la salida Con la adición del estado y las modificaciones que se le van haciendo, se pueden recordar datos durante un periodo de tiempo largo, solucionando el problema de las dependencias a largo plazo. 3.1.3 JUSTIFICACIÓN Las redes LSTM deberían tener un buen comportamiento ya que deberían poder aprender de la historia y, al hacer una pregunta sobre la misma, recoger la información necesaria para responderla. Además, existen trabajos en los que se usa para el tratamiento del habla y para predicción de textos, que son tareas relacionadas con las que se encuentran en el bAbI dataset. 23 3.2 MEMN2N La red MemN2N (Sukhbaatar, Szlam, Weston, & Fergus, 2015) está diseñada especialmente para tareas como la que representa el bAbI dataset. Su funcionamiento es relativamente sencillo y se basa en centrar el foco de atención dentro de una frase. A partir de las frases de soporte proporcionadas y una pregunta, esta red busca la frase que debe contener la respuesta y, posteriormente, la extrae para devolverla como la solución. Para el manejo del foco de atención, este modelo utiliza una función softmax como una distribución de probabilidad. Esta distribución de probabilidad le permite, a partir de una pregunta, seleccionar los datos donde se encuentra la respuesta. 3.2.1 EXPLICACIÓN DEL MODELO La red MemN2N trabaja con dos memorias, una representa el espacio de preguntas y la otra, el de respuestas. Se basan en centrar el foco de atención dentro de una frase. Este diseño está indicado para problemas como el que presenta el bAbI dataset. Ilustración 13: Detalle del funcionamiento de una red MemN2N 24 En la Ilustración 13 se muestra la estructura de esta arquitectura. Embedding son matrices por las que se multiplican las entradas para pasar los datos a los diferentes espacios. Por tanto, la codificación de las frases en este modelo se realiza de forma similar a la explicada en el punto Codificación de las frases, con la diferencia que se utilizan matrices cuyos valores se aprenden para realizar una traslación a los diferentes espacios representados como memorias. De esta forma, resultan 𝑚𝑖=∑𝐴𝑥𝑖𝑗𝑗 , 𝑐𝑖= ∑𝐶𝑥𝑖𝑗𝑗 y 𝑢 = ∑𝐵𝑞𝑗𝑗 . Además, para representar el orden de las frases dentro de una historia, se modifica el vector de memoria de la siguiente forma: 𝑚𝑖=∑𝐴𝑥𝑖𝑗 + 𝑇𝐴(𝑖) 𝑗, donde 𝑇𝐴(𝑖) es la i-ésima fila de una matriz especial 𝑇𝐴 que codifica la información temporal. La traslación de salida se realiza de la misma forma con una matriz 𝑇𝐶, de forma que 𝑐𝑖=∑𝐶𝑥𝑖𝑗 + 𝑇𝐶(𝑖) 𝑗. Tanto 𝑇𝐴 como 𝑇𝐶 son aprendidas durante el entrenamiento. También están sujetas a las mismas restricciones que 𝐴 y 𝐶. Los hechos se indexan en orden inverso, reflejando su distancia relativa de la respuesta, de forma que 𝑥𝑖 es el último hecho de la historia. En este diseño, Embedding A y Embedding C convertiría las frases de soporte a espacios de soporte y respuesta, respectivamente. La pregunta se convertiría al espacio de soporte mediante Embedding B, lo que permitiría elegir los datos que están más relacionados con la pregunta. Con esta información se crearía una distribución de probabilidades (pesos) mediante la capa Softmax. El espacio de respuestas se somete, entonces, a una suma pesada con los pesos obtenidos anteriormente. Con esta suma pesada, que contiene la información de soporte necesaria en el espacio de respuestas y la pregunta en sí, en el espacio de soporte, se realiza una suma y se multiplica por una matriz de pesos, cuyo resultado se pasa por otra capa Softmax para generar la respuesta. Por tanto, la parte fundamental del proceso es la generación de la distribución de probabilidades en la primera capa Softmax. Esta se encarga de centrar el foco de atención en la respuesta basándose en la información de soporte y la pregunta. El resto del proceso simplemente le prepara la información para que el proceso sea efectivo, pue simplemente convierten la información a un espacio determinado. Además, para el tratamiento de problemas complejos, este modelo utiliza un número de iteraciones o hops, de forma que la salida de la primera iteración es la entrada de la segunda, y así se itera hasta conseguir la última salida que sería la deseada. Este comportamiento puede verse en la Ilustración 14. 31 5 METODOLOGÍA DE PRUEBAS UTILIZADO Debido a las diferentes versiones sin retrocompatibilidad de Python y de Tensorflow, se ha adaptado el código de los tres modelos a la versión 3.5 de Python (compatible también con la versión 3.6) y 1.1 de Tensorflow. Entre las versiones 1.1 y 1.2 de Tensorflow existe una retrocompatibilidad completa en los módulos utilizados en este trabajo. Además, Tensorflow 1.2 puede compilarse con las librerías MKL, por lo que, desde que salió esta última versión (15 de junio), se procedió a su uso por ofrecer un rendimiento mayor. Una vez adaptado el código, se procedió a hacer pruebas con el mismo. Estas consistían en ejecuciones de cada modelo, adaptando los parámetros de cada uno a nuestros problemas y buscando diferencias en el comportamiento según los parámetros utilizados para decidir qué parámetros serían idóneos. Para automatizar un poco la toma de pruebas, se añadió código adicional que guardaba los resultados en formato CSV o redirigía la salida a un fichero de texto que se procesaba posteriormente. Además, se utilizaban bucles o scripts para poder tomar múltiples muestras a partir de una sola ejecución. Por otro lado, para conseguir una mayor veracidad de las pruebas, se utilizaban ejecuciones simultáneas en varios ordenadores, para evitar posibles resultados que se salieran de un margen de error. Para la obtención de gráficas, se utilizaron programas de ofimática y Tensorboard, una herramienta incluida en el entorno de Tensorflow. 32 6 RESULTADOS OBTENIDOS 6.1 LSTM El uso de esta red supone un problema: el sobreajuste; es decir, que la red se acostumbra a los datos de entrenamiento y se los memoriza, pero no aprende a generalizar, que es lo que se espera. Esto provoca que, al presentar datos nuevos, los resultados no son tan buenos como al presentar datos ya vistos; lo que obliga a utilizar técnicas de regularización. Además, esta red no está tan centrada en los problemas para los que se ha utilizado (como sí lo está MemN2N), pues es más general, y no ofrece la potencia de una memoria externa (en contraposición a DNC). Por ello, se han realizado pruebas con LSTM utilizando dropout como técnica de regularización y varias capas. En este caso, se han realizado pruebas sobre el bAbI dataset con la tarea de un hecho de soporte. La limitación a esta tarea solamente se debe a que hay muchas variantes de las redes LSTM y consideramos más relevante hacer pruebas sobre dichas variantes que sobre varias tareas diferente. Más aun teniendo en cuenta que, pese a ser entrenada con la tarea más sencilla, se obtienen los peores resultados. En primer lugar, vamos a ver cómo se comporta una red LSTM utilizando una capa y dropout al 50%, por lo que en cada fase de entrenamiento solo la mitad de las neuronas aprenderán. Durante la fase de aprendizaje, se llega a una precisión que ronda el 75% como se muestra en la Ilustración 18. A priori, estos datos son bastante relevantes, pero entonces los contrastamos con los datos de validación y obtenemos los datos de la Ilustración 19. Como se puede ver, pese a utilizar una regularización bastante severa, se produce un sobreentrenamiento demasiado elevado, pues apenas se pasa un 31% de precisión. Ilustración 18: Evolución LSTM una capa y dropout 0.5 33 Ilustración 19: Validación LSTM una capa y dropout 0.5 En segundo lugar, se intentó buscar una solución mejor añadiendo una segunda capa. Al añadir otra capa, se espera que una red pueda resolver tareas más complejas, pero necesita más tiempo de entrenamiento. En nuestro caso, se espera que añadir otra capa resuelva mejor nuestro problema si este es muy complicado para dos capas. De nuevo se produce mucho sobreentrenamiento, pero el resultado final es mejor, tal y como se puede ver comparando la Ilustración 20 con la Ilustración 21. Nótese la reducción en el número de iteraciones utilizado entre la prueba anterior (325k) y esta (200k). Ilustración 20: Evolución LSTM 2 capas y dropout 0.5 Ilustración 21: Validación LSTM 2 capas y dropout 0.5 34 En tercer lugar, se probó con 3 capas. Siguiendo con la dinámica anterior, vemos un entrenamiento con buenos resultados a priori Ilustración 22, aunque algo más bajos ya que no se llega a un número de iteraciones tan grande, pues ya se empieza a ver cómo la precisión se empieza a aumentar más lentamente y solo se pretende ver el resultado de añadir una tercera capa a la red. Sin embargo, vemos en la Ilustración 23 que el resultado de validación también es peor al añadir la tercera capa, lo cual es un resultado curioso y no esperado. Ilustración 22: Evolución LSTM 3 capas y dropout 0.5 Ilustración 23: Validación LSTM 3 capas y dropout 0.5 En cuarto lugar, y debido al resultado anterior, se hizo una última prueba añadiendo una cuarta capa. De esta forma se pretende ver si añadir capas siempre empeora el resultado o nos habíamos encontrado ante un resultado anómalo. En este caso vemos un entrenamiento bastante progresivo en la Ilustración 24. Sin embargo, la precisión en el conjunto de validación vuelve a mejorar, como se muestra en la Ilustración 25. Por lo que el resultado anterior se considera anómalo. 35 Ilustración 24: Evolución LSTM 4 capas y dropout 0.5 Ilustración 25: Validación LSTM 4 capas y dropout 0.5 Con este último resultado, vemos que el hecho de añadir capas tiende a mejorar el resultado, aunque no en todos los casos. Sin embargo, nos seguimos encontrando ante el problema del sobreentrenamiento y de la precisión, que apenas llega a rozar el 50% en el mejor de los casos. Por ello, como última prueba, se utilizó una LSTM bidireccional (que es más potente en algunos problemas). En este caso se mantuvieron las 4 capas y el dropout al 50% y se redujo levemente el número de iteraciones. Como resultado vemos que el entrenamiento vuelve a mostrar la dinámica seguida anteriormente en la Ilustración 26, pero el resultado en la validación (Ilustración 27) es peor que utilizando una LSTM normal; por lo que las LSTM bidireccionales no aportan mejoras sino que, al contrario, empeoran los resultados. 36 Ilustración 26 Evolución LSTM bidireccional 4 capas y dropout 0.5 Ilustración 27 Validación LSTM bidireccional 4 capas y dropout 0.5 37 6.2 MEMN2N Esta red ofrece los mejores resultados, lo cual era esperable ya que está diseñada especialmente para el tipo de tareas utilizado. En este modelo nos hemos centrado en modificar el número de hops utilizados en cada tarea y esto nos ha permitido mejorar los resultados más bajos. Como se puede ver en la Ilustración 28, las tareas de bAbI se resuelven con bastante facilidad en este modelo; alcanzando una precisión casi completa para las tareas 1 y 2 y mayor del 80% para la tarea 3. Sin embargo, en el dataset propio la tarea 1 es la que se resuelve con buenos resultados mientras que las tareas 2 y 3 no consiguen llegar a unos resultados aceptables, pues no pasan del 60% de precisión. Ilustración 28: Evolución de la precisión según el número de hops utilizados Esta diferencia de resultados puede deberse a que, en bAbI, la respuesta es directa y de izquierda a derecha, p.e.: “María está en el salón, ¿dónde está María?”. Mientras que, en el dataset propio, la respuesta esperada requiere de una inferencia de derecha a izquierda, p.e.: “Pedro es padre de Pablo, ¿qué es Pablo de Pedro?”. En el dataset propio se requiere buscar la frase de soporte que contenga a Pablo como objeto, a Pedro como sujeto y se deberá inferir la relación complementaria de “padre”; mientras que, en bAbI, solamente se requiere buscar el sujeto y responder con el objeto. Debido a que en las tareas 2 y 3 se requiere buscar en varios hechos de soporte, la complejidad extra se multiplica, lo que nos lleva a los resultados mostrados. 0 0,1 0,2 0,3 0,4 0,5 0,6 0,7 0,8 0,9 1 123456789 Accuracy Hops Evolución de la precisión en MemN2N para todas las tareas según el número de hops babi1 babi2 babi3 family1 family2 family3 38 En cuanto a requisitos de tiempo, las tareas del dataset bAbI requerían más tiempo para llevar a cabo todas las iteraciones. En el caso de dos hechos de soporte y 9 hops, el tiempo requerido para el entrenamiento fue de unos 17 minutos, mientras que, para el dataset propio, apenas se requirieron unos 7. Sin embargo, también se puede ver que para las tareas sencillas con, como mucho, 3 hops, ya se consiguen los mejores resultado o resultados muy aproximados a los mejores. Sin embargo, a medida que aumenta la complejidad, añadir hops mejora los resultados en cantidades apreciables pero inferiores a las deseables. 6.3 DNC Este modelo tiene una complejidad bastante mayor que los dos anteriores. Se espera que sea más flexible y aplicable a más problemas, pero carece de la especialización en un problema concreto. Debido a la complejidad de este modelo, el entrenamiento es mucho más costoso en tiempo y no ofrece unos resultados tan buenos como los dos anteriores. Como se puede ver en la Ilustración 29, para las tareas de bAbI se consiguen mejores resultados y, curiosamente, en el dataset propio las preguntas que requieren de 3 hechos de soporte ofrecen un error menor que las que requieren de un solo hecho de soporte, no hemos podido encontrar una explicación para este comportamiento. Ilustración 29: Evolución del error en DNC según el número de iteraciones 0 10 20 30 40 50 60 70 80 90 100 0100000 200000 300000 400000 500000 600000 Porcentaje de error Número de iteraciones Evolución del error en DNC para todas las tareas según el número de iteraciones bAbI 1 bAbI 2 bAbI3 family 1 family 2 family 3 39 Para el dataset propio se ha entrenado este modelo con hasta 600.000 iteraciones, ya que se buscaban mejoras a largo plazo, aunque no se llegaron a encontrar. Con bAbI no se hicieron pruebas tan exhaustivas ya que la gráfica mostraba una tendencia más uniforme y dichas ejecuciones habrían requerido de más recursos. Desgraciadamente, no se contaba con los medios necesarios para obtener más datos de este modelo. Hay que tener en cuenta que una sola ejecución de 600.000 iteraciones requería de más de 3 días para completar en entrenamiento y se hicieron 4 ejecuciones de estas, aparte de las ejecuciones más cortas. Sin embargo, con los resultados obtenidos ya podemos ver el comportamiento general de este modelo. Como se puede apreciar en la Ilustración 30, la evolución del error a corto plazo es mínima, llegando a mostrar oscilaciones y ninguna mejora. Este gráfico se corresponde con las nubes de puntos a la izquierda del gráfico anterior. Ilustración 30: Evolución del error en DNC a corto plazo Una desventaja de este modelo respecto a los demás, es el tiempo necesario para el entrenamiento y que los resultados obtenidos no han sido tan buenos como en el momento anterior, pero, por otro lado, es un modelo más general, que no está diseñado específicamente para las tareas utilizadas en este experimento, por lo que tiene un potencial mayor al poder aplicarse a otros tipos de tareas. En el entrenamiento de este modelo en la tarea del dataset propio usando 600.000 iteraciones, se necesitaron 3 días, 2 horas y 54 minutos. 0 10 20 30 40 50 60 70 80 90 100 2500 3500 4500 5500 6500 7500 8500 9500 Porcentaje de error Número de iteraciones Evolución del error en DNC para todas las tareas según el número de iteraciones bAbI 1 bAbI 2 bAbI3 family 1 family 2 family 3 40 6.4 PROPUESTA DE MEJORA Debido a los resultados obtenidos y al comportamiento mostrado, se escogió DNC para proponer una mejora. Este modelo se muestra inmaduro al compararlo con los otros modelos, ya que le falta modularidad y carece de ciertas características aplicables más fácilmente a otros modelos más sencillos, como la transferencia de conocimiento. La transferencia de conocimiento consiste en, teniendo una red para una tarea concreta, reentrenar la capa de salida para aplicarla a otra tarea. De esta forma, una gran parte del conocimiento adquirido se mantiene y solo se cambia la respuesta; haciendo que el entrenamiento sea mucho más corto y, potencialmente, la respuesta sea mejor. Desde un punto de la adaptabilidad a diferentes problemáticas, este modelo parece tener la ventaja respecto a los otros dos modelos utilizados, pero, como hemos indicado anteriormente, es un modelo todavía inmaduro, pero con unas bases muy potentes.