trabajo fin de grado procesamiento del lenguaje natural...

Graduado en Ingeniería Informática

Universidad Politécnica de Madrid

Escuela Técnica Superior deIngenieros Informáticos

TRABAJO FIN DE GRADO

Procesamiento del Lenguaje Natural para la portabilidadde conceptos entre idiomas

Autor: Olga Salas Sancho

Director: Óscar Corcho García

Codirectores: José Manuel Gómez Pérez, Ronald Denaux

MADRID, JUNIO DE 2017

AGRADECIMIENTOS

A mis amigos y a mi pareja, que me apoyan y animan cada día.

A mis padres, que siempre han confiado en mis capacidades y nunca han dudado de mí.

A mis tutores dentro de la empresa, José y Ronald. Gracias a ellos he aprendido a desen-

volverme en el entorno laboral adquiriendo nuevos conocimientos académicos, y además,

gracias a ellos ha sido posible realizar este proyecto.

II

ÍNDICE

1. Introducción 1

2. Planteamiento del problema 22.1. Trabajos previos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

2.2. Posibles soluciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2.3. Tecnologías empleadas . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

3. Desarrollo 73.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

3.2. Parámetros de entrada de los algoritmos . . . . . . . . . . . . . . . . . . 8

3.2.1. Diccionarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

3.2.2. Vectores empleados durante la investigación . . . . . . . . . . . . 8

3.2.3. Elección de los mismos . . . . . . . . . . . . . . . . . . . . . . . 9

3.2.4. Problemas encontrados . . . . . . . . . . . . . . . . . . . . . . . 10

3.3. Algoritmos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

3.3.1. Matriz de traducción . . . . . . . . . . . . . . . . . . . . . . . . 10

3.3.2. Redes neuronales . . . . . . . . . . . . . . . . . . . . . . . . . . 11

4. Experimentos 174.1. Métricas calculadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

4.1.1. Top 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

4.1.2. Traducciones encontradas . . . . . . . . . . . . . . . . . . . . . 19

4.1.3. Métrica relacionada con las distancias . . . . . . . . . . . . . . . 19

4.2. Matriz de traducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

4.3. Primeras pruebas con redes neuronales . . . . . . . . . . . . . . . . . . . 24

4.4. Comprobación del funcionamiento de las redes . . . . . . . . . . . . . . 26

4.4.1. Vectores origen aleatorios y vectores destino generados con ma-

trices de traducción aleatorias . . . . . . . . . . . . . . . . . . . 26

4.4.2. Vectores origen originales y vectores destino generados con ma-

trices de traducción aleatorias . . . . . . . . . . . . . . . . . . . 28

4.4.3. Vectores origen y destino originales . . . . . . . . . . . . . . . . 32

4.5. Optimización de las redes . . . . . . . . . . . . . . . . . . . . . . . . . . 33

4.6. Mejora del algoritmo de búsqueda de traducciones . . . . . . . . . . . . 35

4.7. Mejora de los vectores empleados para el entrenamiento . . . . . . . . . 37

III

5. Resultados y conclusiones 405.1. Implementación final del sistema . . . . . . . . . . . . . . . . . . . . . . 40

5.2. Conclusiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

6. Referencias 42

IV

ÍNDICE DE FIGURAS

1. Representación de palabras semejantes en su espacio vectorial [2] . . . . 3

2. Funcionamiento de la predicción de las arquitecturas CBOW y Skip-gram

[4] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

3. Representación de vectores en inglés y sus traducciones en español. Los

vectores en español se han rotado para visualizar la similitud entre ambos

espacios con mayor facilidad [4] . . . . . . . . . . . . . . . . . . . . . . 6

4. Código empleado para el cómputo de matrices de traducción . . . . . . . 10

5. Partes de una neurona [6] . . . . . . . . . . . . . . . . . . . . . . . . . . 12

6. Neurona artificial [8] . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

7. Arquitectura de una red neuronal multicapa [9] . . . . . . . . . . . . . . 13

8. Parámetros de entrada de la red neuronal . . . . . . . . . . . . . . . . . . 15

9. Estructura de las capas de la red en la implementación . . . . . . . . . . . 15

10. Variables clave del entrenamiento . . . . . . . . . . . . . . . . . . . . . 16

11. Proceso de la obtención de las traducciones . . . . . . . . . . . . . . . . 18

12. Dimensión de los vectores y de la matriz de traducción . . . . . . . . . . 20

13. División del espacio vectorial por Annoy [10] . . . . . . . . . . . . . . . 36

14. Promedio de las distancias entre palabras y su contexto con los vectores

antiguos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

15. Promedio de las distancias entre palabras y su contexto con los vectores

mejorados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

ÍNDICE DE TABLAS

1. Top 5 (no válido) de 1500 entradas con matrices de syncons . . . . . . . 21

2. Top 5 con matrices generadas con syncons . . . . . . . . . . . . . . . . . 22

3. Top 5 con matrices generadas con lemmas . . . . . . . . . . . . . . . . . 22

4. Top 5 con matrices generadas con syncons y lemmas . . . . . . . . . . . 22

5. Top 5 de vectores en inglés usados para generar la matriz (syncons) . . . 23

6. Top 5 de vectores en inglés usados para generar la matriz (lemmas) . . . . 23

7. Top 5 de vectores en inglés usados para generar la matriz (mixto) . . . . . 24

8. Top 5 con red neuronal de una capa . . . . . . . . . . . . . . . . . . . . 25

9. Top 5 con vectores origen aleatorios y vectores destino generados con una

matriz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

V

10. Distancias con vectores origen aleatorios y vectores destino generados

con una matriz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

11. Top 5 con vectores origen aleatorios y vectores destino generados con tres

matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

12. Distancias con vectores origen aleatorios y vectores destino generados

con tres matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

13. Top 5 con vectores origen originales y vectores destino generados con una

matriz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

14. Distancias con vectores origen originales y vectores destino generados

con una matriz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

15. Top 5 con vectores origen originales y vectores destino generados con tres

matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29


tres matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

17. Top 5 con vectores origen originales y vectores destino generados con

cincuenta matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30


cincuenta matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

19. Top 5 con vectores origen originales y vectores destino generados con 10

matrices asociadas a vectores . . . . . . . . . . . . . . . . . . . . . . . . 30


con 10 matrices asociadas a vectores . . . . . . . . . . . . . . . . . . . . 31

21. Top 5 con vectores origen originales y vectores destino generados con 25

matrices asociadas a vectores . . . . . . . . . . . . . . . . . . . . . . . . 31


con 25 matrices asociadas a vectores . . . . . . . . . . . . . . . . . . . . 31

23. Top 5 con conjuntos originales . . . . . . . . . . . . . . . . . . . . . . . 32

24. Distancias con conjuntos originales . . . . . . . . . . . . . . . . . . . . . 32

25. Resultados para las combinaciones de alpha y beta . . . . . . . . . . . . 33

26. Pruebas con la red neuronal de dos capas . . . . . . . . . . . . . . . . . . 34

27. Pruebas con la red neuronal de tres capas . . . . . . . . . . . . . . . . . 34

28. Pruebas con la red neuronal de cuatro capas . . . . . . . . . . . . . . . . 34

29. Pruebas con los vectores optimizados . . . . . . . . . . . . . . . . . . . 37

30. Ejemplo de traducción de un syncon . . . . . . . . . . . . . . . . . . . . 39

VI

Resumen

Basándonos en el estudio de Tomas Mikolov et al. sobre las representacio-

nes vectoriales de las palabras, es posible obtener traducciones entre distintos

idiomas procesando conjuntos amplios y estructurados de ejemplos reales de

cada idioma, denominados "corpus".

Dichas traducciones se pueden obtener mediante una transformación lineal

entre los corpus, al menos, en el caso ideal. Bastaría con resolver la ecuación

matricial

A ·X = B (1)

siendo A y B las representaciones de los vectores en cada idioma. X sería la

matriz de traducción resultante, que multiplicada por un vector en el idioma

A nos devolvería el vector más parecido en el idioma B. El problema prin-

cipal es que cada lengua tiene características propias que determinan el sig-

nificado de ciertas palabras mediante el contexto, generando ambigüedad en

las traducciones y provocando que el algoritmo devuelva resultados no espe-

rados. Dicha ambigüedad está directamente relacionada con la polisemia de

las palabras, puesto que palabras con distintos significados pueden no verse

representadas de igual forma en diferentes idiomas.

Por ello se pretende estudiar qué algoritmo es el mejor, qué parámetros y

tipos de vectores han de usarse y qué optimizaciones se pueden llevar a cabo

para una mejora de los resultados.

En definitiva, el objetivo de este trabajo consiste en reducir el efecto negativo

de la ambigüedad provocada por la polisemia de las palabras para encontrar

unas traducciones acordes a los resultados correctos.

Palabras clave: matriz de traducción, representaciones vectoriales de las

palabras, contexto, ambigüedad polisémica.

VII

Abstract

Based on the study made by Tomas Mikolov et al. of the vector rep-

resentations of words, it is possible to obtain translations between different

languages by processing large and structured sets of real examples of each

language, called "corpus".

Such translations can be obtained by a linear transformation between the cor-

pus, at least in the ideal case. It would be enough to solve the matrix equation

A ·X = B (2)

being A and B representations of the vectors in each language. X would be

the resulting translation matrix, and multiplied by a vector in language A, the

most similar vector in language B would be returned. The main problem is

that each language has its own characteristics that determine the meaning of

certain words through the context, generating ambiguity in the translations

and making the algorithm to return unexpected results. This ambiguity is

directly related to the polysemy of words, since words that have different

meanings may not be represented in the same way in different languages.

It is therefore intended to study which algorithm is the best, which parame-

teres and types of vectores should be used and which optimizations we should

take for making an improvement in our results.

In short, the objective of this project is to reduce the negative effect of the

ambiguity caused by the polysemy of the words to find translations according

to the correct results.

Keywords: translation matrix, vector representations of words, context,

ambiguity.

VIII

1. INTRODUCCIÓN

La comunicación consiste en el intercambio de información entre uno o varios individuos

con el fin de transmitir o recibir conceptos y significados a través de un sistema común de

normas y reglas semánticas.

Sin embargo, dicho sistema de normas y reglas no siempre es el dominado por los partici-

pantes. Existen los idiomas, distintos sistemas verbales de normas, sintaxis, vocabulario,

que pertenecen a ciertas comunidades y zonas geográficas. Por desgracia, no todos los

individuos pueden aprender o entender idiomas que difieren de su lengua madre. Es por

ello que existen las traducciones, necesarias para que el receptor pueda comprender el

significado del mensaje original.

Las traducciones permiten comunicar entre sí a los individuos de diferentes zonas geo-

gráficas sin ningún problema. Existen ciertas características propias de cada idioma que

dificultan la creación de traducciones directas, es por ello que se necesitan adaptaciones

adecuadas. Sin embargo, dichas características dificultan la automatización de traduccio-

nes con determinados algoritmos.

Estas peculiaridades presentes en cada idioma crean ambigüedad a la hora de automati-

zar traducciones con distintos tipos de algoritmos. Si representamos las palabras como

vectores, aquellas con significados similares o aquellas que provengan de la misma fa-

milia probablemente se encontrarán en zonas cercanas en el espacio vectorial. Dichas

zonas pueden denominarse "clústers". Sin embargo, las palabras que son polisémicas en

un idioma y en otro no tendrían vectores claramente diferentes y sería una tarea más com-

pleja encontrar una transformación lineal para obtener la traducción. La palabra "gato" es

un buen ejemplo para ilustrar el problema. En español, esta palabra toma distintos sig-

nificados ("animal", "herramienta utilizada en la reparación de automóviles", "persona

originaria de Madrid"), sin embargo, en inglés únicamente se refiere al animal. Esta poli-

semia añade valores al vector en español, dificultando una transformación lineal adecuada

para obtener la traducción correspondiente.

Es por ello que con este trabajo se pretende encontrar una solución para poder abordar

el problema de la polisemia y ambigüedad y así poder encontrar traducciones adecuadas

entre las representaciones vectoriales de distintos idiomas.

1

2. PLANTEAMIENTO DEL PROBLEMA

2.1. Trabajos previos

Las tecnologías referentes a “word embeddings” son relativamente nuevas. La prime-

ra mención al término se hizo en 2003 de manos de Bengio et al.1 en su estudio sobre

la creación de modelos probabilísticos del lenguaje natural, donde habla sobre la repre-

sentación vectorial de las palabras mediante modelos probabilísticos y su entrenamiento

mediante redes neuronales. Posteriormente, en 2008, Ronan Collobert et al.2 mostraron

un modelo basado en una red neuronal que demuestra las distintas utilidades sobre los

word embeddings.

Sin embargo, estos modelos probabilísticos no fueron realmente conocidos hasta que To-

mas Mikolov et al. mostraron word2vec3 y sus implementaciones en 2014. Los modelos

de espacio vectorial4 representan palabras "incrustadas" (embeddings) en espacios vec-

toriales en los que palabras semánticamente parecidas se encuentran en puntos cercanos.

Estos modelos dependen de la hipótesis distribucional que establece que palabras que

aparecen en mismos contextos comparten significados parecidos [1].

1http://www.jmlr.org/papers/volume3/bengio03a/bengio03a.pdf2http://www.jmlr.org/papers/volume12/collobert11a/collobert11a.pdf3https://arxiv.org/pdf/1310.4546.pdf4modelo algebraico que representa documentos de texto como vectores

2

Figura 1: Representación de palabras semejantes en su espacio vectorial [2]

Para estos modelos podemos encontrar dos metodologías distintas: métodos basados en

conteo y métodos predictivos. Los métodos de conteo calculan la frecuencia de coocurren-

cia de las palabras dentro de un contexto, mientras que los métodos predictivos utilizan

el contexto para predecir la palabra más acertada o viceversa (utilizan la palabra para

predecir su contexto). [3]

Word2vec emplea dos arquitecturas distintas para la creación de los embeddings, el mo-

delo CBOW y el modelo Skip-gram, basadas en los métodos predictivos previamente

descritos. La principal diferencia entre ambos modelos es que el modelo CBOW toma

el corpus como un todo, obviando las relaciones gramaticales entre las palabras, y el

modelo Skip-gram toma pequeñas partes del texto (que pueden contener preposiciones,

verbos, sustantivos) llamadas n-gramas. [4] Ambos modelos funcionan de manera dife-

rente; CBOW predice una palabra a través del contexto, mientras que Skip-gram predice

los distintos contextos a través de una palabra, como se puede ilustrar en la siguiente

figura.

3

Figura 2: Funcionamiento de la predicción de las arquitecturas CBOW y Skip-gram [4]

Word2vec, además, cuenta con diferentes métodos para el cálculo y cómputo de la si-

milaridad entre palabras. Actualmente existen varias implementaciones de esta librería

(Python, Java, Scala y C). Más allá de word2vec existen otras librerías de procesamiento

del lenguaje natural que utilizan embeddings, tales como TensorFlow5 y Gensim6.

Gracias a estas implementaciones es posible obtener una representación vectorial de las

palabras procesando distintos contextos o corpus. El problema real viene a la hora de

relacionar representaciones vectoriales de distintos idiomas. Basándonos en los estudios

de Mikolov, es posible obtener traducciones mediante el cómputo de una matriz de tra-

ducción entre ambas representaciones [4]. Este es el punto de partida de la investigación

sobre qué algoritmo será el más adecuado y sobre la optimización de los mismos.

5https://www.tensorflow.org/6https://radimrehurek.com/gensim/

4

2.2. Posibles soluciones

Tal y como se ha mencionado anteriormente, los algoritmos capaces de devolver traduc-

ciones se basan en transformaciones lineales, como la conocida "matriz de traducción",

que no es más que una transformación lineal entre dos espacios vectoriales.

Según Mikolov et al., dados dos conjuntos de vectores siendo A el conjunto de vectores

en el idioma origen (vectores a traducir) y B el conjunto de vectores en el idioma destino

(traducciones), el problema a resolver consiste en encontrar una matriz X tal que

A ·X = B (3)

o, en otras palabras, que consiga aproximar los vectores de A a B. Basándonos en lo

anterior, para encontrar la traducción de la palabra A, bastará con hallar su representación

en el idioma objetivo mediante el cómputo

B = A ·X (4)

y encontrar el vector que más se parece a B calculando la distancia coseno entre dicho

vector y el espacio de posibles traducciones. [4]

La distancia coseno es una de las muchas medidas de similitud que se pueden aplicar,

aunque no es una métrica por no cumplir varias condiciones, entre otras, la desigualdad

triangular. Esta medida de la distancia proporciona valores en el intervalo [-1,1], siendo

-1 el resultado de aplicar la medida a dos vectores radicalmente distintos (apuntan a direc-

ciones distintas) y 1 en caso de que el ángulo formado entre los vectores sea 0 o, lo que es

lo mismo, que los vectores estén orientados en la misma dirección. En varias implemen-

taciones, para facilitar el cómputo, se normaliza la salida de esta operación restando el

resultado a un 1. De esta forma el nuevo intervalo resultante sería [0,2], con 0 indicando

similitud máxima y 2 desigualdad. [5]

5

Figura 3: Representación de vectores en inglés y sus traducciones en español. Los vectores

en español se han rotado para visualizar la similitud entre ambos espacios con mayor

facilidad [4]

2.3. Tecnologías empleadas

Para la resolución del problema planteado se han empleado varias tecnologías, siendo las

más destacables el lenguaje de programación Python7 y dos librerías fundamentales:

• Tensorflow: Librería empleada para las tareas de aprendizaje automatizado que

realiza operaciones con tensores8. En este proyecto se ha utilizado para el entrena-

miento y posterior uso de modelos basados en redes neuronales.

• Annoy: Librería codificada en C++ que aumenta considerablemente la velocidad

de procesamiento de operaciones con grandes cantidades de vectores9.

Por otra parte, se han utilizado distintas librerías de Python, tales como NumPy o SciPy,

que han ayudado a resolver la tarea pero no destacan por su relevancia.

7https://www.python.org/8matriz de matrices9https://github.com/spotify/annoy

6

3. DESARROLLO

3.1. Introducción

En esta sección se pretende explicar qué algoritmos se han empleado y cómo, qué sets de

vectores se han utilizado para el entrenamiento de los modelos y cómo se han clasificado.

Antes de comenzar, es importante tener en cuenta una serie de conceptos previos sobre

los vectores empleados10.

• Sensígrafo: gran red de datos entrelazados que agrupa las relaciones semánticacs

existentes entre conceptos y palabras de un mismo idioma. Es una tecnología propia

de la empresa.

• Syncon: parte del sensígrafo que representa un concepto en el contexto de un idio-

ma determinado. Su notación está formada por el idioma al que pertenece seguido

de un hash y el número asociado al mismo11.

• Lemma: parte del sensígrafo que equivale a una palabra. Es una asociación entre

los conceptos de un idioma y su representación, por lo que dichas palabras repre-

sentan el significado de los syncons.

Un syncon puede tener asociado más de un lemma. En este caso, estamos hablando de

palabras sinónimas. Por ejemplo, el syncon que representa al concepto de "máquina con

alas propulsada por uno o varios motores" va asociado a los lemmas "avión", "avioneta",

"aeroplano", "reactor".

Por otra parte, cuando un lemma tiene asociado más de un syncon, estamos hablando

de polisemia. Esto puede ocurrir en el caso de lemmas como "banco", que puede tener

asociado distintos significados: empresa comercial que realiza operaciones financieras,

asiento, conjunto de peces de una misma especie...

Los vectores de embeddings de cada idioma contienen los embeddings asociados a los

syncons y lemmas. Para generar los vectors antes de aplicar word2vec, se tokenizan las

palabras, estos tokens se corresponden con un lemma y la mayoría de los lemmas está

asociada a un syncon, por el que se sustituyen para formar los vectores. En caso de no

10http://www.expertsystem.com/es/productos/cogito-studio/11similar a los synsets de WordNet, es un conjunto de sinónimos que crea un concepto dentro del len-

guaje

7

estar asociado a ningún syncon, el token se queda como un lemma. Es necesario saber

qué combinación de vectores es la óptima para el entrenamiento de los modelos.

3.2. Parámetros de entrada de los algoritmos

3.2.1. Diccionarios

La generación de diccionarios que almacenasen las traducciones para los vectores de cada

idioma era necesaria para futuros experimentos y para el cálculo de matrices de traduc-

ción. Se han empleado dos diccionarios distintos a lo largo del proyecto, un diccionario

de syncons y otro de lemmas.

La obtención de los diccionarios se realizó por medio de archivos que contenían los equi-

valentes de los syncons en distintos idiomas. En primer lugar, se realizó el mappeado de

los syncons mediante dos archivos, uno con los syncons en inglés y su equivalente en ita-

liano, y otro archivo que contenía los syncons en italiano y su equivalente en español. En

el archivo de inglés a italiano solo había un tercio de todos los syncons existentes. Es por

esto por lo que se necesita el algoritmo de traducción. El diccionario final era un archivo

que contenía los syncons en inglés y sus equivalentes en español. Por otra parte, se generó

un archivo de lemmas mediante un mappeado realizado por el sensígrafo.

3.2.2. Vectores empleados durante la investigación

Para la investigación se han utilizado vectores formados por syncons y lemmas. Dichos

vectores han sido generados con Swivel12, librería que retorna dos tipos de embeddings,

columna y fila (dichos embeddings representan a la palabra cuando aparece en el contexto

y cuando se quiere predecir). Dado que estos ficheros ocupan bastante espacio, se combi-

naron ambos embeddings (mediante la suma de los valores) en archivos .bin para reducir

coste computacional y espacio en disco. Se modificó brevemente la implementación de

Swivel para procesar las tokenizaciones mencionadas previamente.

Pese a que a lo largo del proyecto se han generado distintos conjuntos de vectores de

prueba con esta librería, se pueden destacar dos de estos datasets. Todos los vectores

empleados estaban ordenados por orden de frecuencia, siendo los primeros del set los

12https://github.com/tensorflow/models/tree/master/swivel

8

vectores que representan a las palabras con más frecuencia de aparición en los textos.

En primer lugar, se disponía de un set antiguo de vectores cuyos embeddings se calcularon

con dos corpus paralelos en español e inglés13. Posteriormente, durante la etapa final

del proyecto, se optimizaron dichos embeddings mediante una opción de regularización

añadida por la empresa a la librería Swivel, dando lugar al segundo dataset básico.

Aunque estos vectores contenían una gran cantidad de embeddings, no todos tenían tra-

ducción. Es por ello que fue necesario filtrar y apartar aquellos vectores que no tenían

traducción para la creación de matrices de traducción y el entrenamiento de redes neuro-

nales. Sin embargo, es estrictamente necesario que al buscar las traducciones se busquen

en todos los vectores, para no limitar el algoritmo de traducción. El proceso de filtrado se

realizó mediante ficheros fuente que contenían syncons en español e inglés y su corres-

pondiente traducción al italiano. Con estos ficheros se obtuvo el diccionario de syncons,

en el que se guardaban syncons en inglés y su correspondiente traducción al español.

Posteriormente, en etapas más avanzadas del proyecto, se crearon nuevos diccionarios

de syncons con valores más recientes, aumentando la cantidad de traducciones existentes

en los conjuntos de vectores en inglés y en español. A su vez, también se generaron

diccionarios de lemmas, pudiendo ahora probar los diferentes algoritmos no solo con

syncons, si no también con lemmas o incluso con la combinación de ambos tipos de

datos.

3.2.3. Elección de los mismos

Los vectores que se emplearon finalmente durante los experimentos fueron aquellos com-

puestos por syncons y lemmas. Esto se debe a que en un principio se creía que los lemmas

podrían añadir ambigüedad a las matrices de traducción, sin embargo se necesitaban ob-

tener unas traducciones más o menos adecuadas para ambos subconjuntos.

En los primeros experimentos realizados con ambos tipos de algoritmo (matriz de tra-

ducción y redes neuronales) se obtuvieron resultados mejores para syncons, seguidos de

syncon y lemmas, y finalmente, con peores resultados, los vectores generados a partir

de lemmas. Más tarde, en la sección de experimentos, se mostrarán las métricas que se

calcularon para comprobar el funcionamiento de cada tipo de vectores.

13https://conferences.unite.un.org/uncorpus

9

3.2.4. Problemas encontrados

Durante la generación de diccionarios se encontraron un par de problemas. No estaba

claro el sentido en el que estaban escritos los archivos que contenían los syncons.

Se pensaba que los ficheros de syncons seguían la siguiente estructura: syncon-idioma-

origen syncon-idioma-destino. De esta forma y por error, se generaron unos diccionarios

que representaban traducciones que no tenían sentido.

3.3. Algoritmos

3.3.1. Matriz de traducción

La matriz de traducción es el algoritmo de partida de la investigación. Su cómputo es

relativamente sencillo, pues basta con resolver la ecuación matricial

A ·X = B (5)

donde A es el conjunto de vectores del idioma origen, B el conjunto de vectores del idioma

destino (ambos conjuntos equivalen a matrices), y finalmente, donde X es la matriz de

traducción entre ambos idiomas.

Figura 4: Código empleado para el cómputo de matrices de traducción

Sin embargo, este algoritmo solo funciona en caso de que los vectores estén paralelizados.

Esto es que los vectores origen (y sus traducciones) que se encuentran en cada matriz

estén almacenados en los mismos índices, o lo que es lo mismo, que los vectores origen

10

y destino estén alineados dentro de sus respectivas matrices. Además, es necesario que

el cómputo de la matriz solo se lleve a cabo con aquellos vectores que tienen traducción,

como se ha mencionado en capítulos anteriores.

Pese a que los vectores fueron originados a partir del mismo corpus en sus versiones

inglesa y española, estos no estaban paralelizados puesto que el set en inglés tenía más

syncons y lemmas que aparecían en los diccionarios de traducciones.

A pesar de la paralelización de los vectores, el algoritmo de la matriz de traducción es

bastante limitado, ya que asume que la transformación entre ambos espacios es puramente

lineal. Además, dicha limitación puede observarse también en el número de parámetros

de entrada que toma la matriz (únicamente los vectores origen y destino). Los resultados

de los experimentos realizados con la matriz son bastante malos debido a la simpleza del

algoritmo. El algoritmo, por tanto, necesita optimizarse. En este caso, la optimización se

ha realizado con redes neuronales.

3.3.2. Redes neuronales

Un red neuronal, como su nombre indica, es un paradigma computacional que se basa

en la arquitectura de las neuronas humanas. En biología, una neurona es una estructura

celular que forma parte del sistema nervioso. La función principal de las neuronas consiste

en procesar información y transmitirla a sus vecinas. Constan de tres partes principales

[6]:

• Dentritas: son los canales de entrada de la neurona. Pueden recibir gran cantidad

de datos independientemente del número de dentritas.

• Soma o núcleo: parte que procesa la información recibida.

• Axón: canal de salida de la neurona. Una vez se ha procesado la información, la

envía por el axón a las neuronas vecinas.

11

Figura 5: Partes de una neurona [6]

La arquitectura de las neuronas que forman las redes neuronales se basa directamente

en las neuronas humanas. Poseen las mismas partes esenciales, con la diferencia de que

algorítmicamente la información se propaga de una neurona a otra con unos pesos deter-

minados. La regla de propagación suele ser una suma ponderada del producto escalar del

vector de entrada y el vector de pesos.

Posteriormente, se aplica una función de activación y finalmente la neurona aplica una

función de salida determinada antes de enviar la información resultante a sus vecinas. En

la figura siguiente se puede observar como la estructura algorítmica de la neurona es cuasi

idéntica a la de una neurona biológica. [7]

Figura 6: Neurona artificial [8]

12

Las redes neuronales artificiales son algoritmos utilizados para el análisis y el procesa-

miento de información basados en el funcionamiento del sistema nervioso. Compuestas

por un gran número de nodos interconectadas, el aprendizaje de la red es realmente simi-

lar al del ser humano. La información procesada por las redes neuronales se propaga de

una neurona a otra, siendo la salida de una neurona la entrada de la siguiente, en el caso de

un sistema totalmente lineal. Dichos nodos, o neuronas, suelen distribuirse en diferentes

capas que interconectan su salida con la capa siguiente.

Como puede observarse en la siguiente figura, cada nodo circular representa una neurona

artificial y cada flecha representa una conexión desde la salida de una neurona a la entrada

de otra.

Figura 7: Arquitectura de una red neuronal multicapa [9]

El algoritmo empleado es algo más complejo que el de la matriz de traducción. Primero

hay que entrenar un modelo. Para ello, la red recibe una serie de inputs, considerados

"valores" y "etiquetas". En nuestro caso, los valores que le pasamos como entrada son los

vectores origen y las etiquetas o valores de salida son los vectores del idioma de traduc-

ción. La red entonces procesa los inputs en sus distintas capas y nodos durante un número

determinado de iteraciones, midiendo el error con la distancia coseno y optimizando el

modelo en función de este. Este error se mejora con un set de validación, se multiplican

los vectores por el modelo actual y se calcula la distancia coseno entre sus respectivas

traducciones.

13

La fórmula empleada en cada capa para el cómputo de las evaluaciones es la siguiente,

hi(t) =∑

wij · xj + bi (6)

siendo h la evaluación obtenida, w la matriz de pesos en cada capa, x el vector de entrada

y b los biases de la operación, que permiten realizar un ajuste más preciso a la multipli-

cación.

Una peculiaridad de estas redes neuronales es la flexibilidad que tienen para ajustar las di-

mensiones de los inputs y los outputs. En el caso de los embeddings, tan solo se necesitaba

que las redes neuronales aceptaran como entrada y devolvieran como salida vectores fila

de 300 componentes. Las dimensiones de las capas centrales se irían ajustando a medida

que se realizaran los experimentos para comprobar la eficiencia del algoritmo.

Para la implementación se ha usado TensorFlow, como se ha indicado en capítulos ante-

riores. Se ha codificado una clase por cada red distinta empleada en función de sus capas,

y dichas clases constan de dos métodos principales:

• Train: método que recibe como parámetros de entrada los vectores origen y des-

tino para entrenar un modelo. Este modelo es similar a la matriz de traducción de

la que se ha hablado previamente.

• Test: carga el modelo anterior para procesar múltiples entradas y obtener sus tra-

ducciones. En este método se puede decidir que métrica calcular, de las que se

hablará en capítulos posteriores.

Las entradas de la red son siempre los vectores en inglés y en español, pero además, esos

vectores se particionan para crear distintos conjuntos. Estos conjuntos son los conjuntos

de entrenamiento, validación y test. El conjunto de entrenamiento es el que se usa para

entrenar la red, suele tener un mayor número de vectores que el resto. El conjunto de

validación es el que, a medida que se va realizando el entrenamiento, aplica el algoritmo

en cada iteración para comprobar que se está entrenando correctamente, y en caso de

encontrar fallos, ajustar los parámetros de aprendizaje. Finalmente, el conjunto de test

se utiliza cuando el entrenamiento está finalizado para comprobar el funcionamiento del

modelo.

14

Figura 8: Parámetros de entrada de la red neuronal

En el entrenamiento, a la primera capa le pasamos como input los vectores con los que

se desea entrenar. Posteriormente, la salida de la primera capa se pasa a la siguiente, y

así hasta terminar con todas las capas disponibles. Es necesario regularizar la salida de

cada capa para no entorpecer el entrenamiento. Al comienzo de los experimentos no se

regularizaron los resultados a las salidas de cada capa y esto trajo problemas. Cada capa

puede tener la dimensión deseada, siempre y cuando la primera capa acepte como entrada

vectores de tamaño 300.

Figura 9: Estructura de las capas de la red en la implementación

Como se puede observar en la figura anterior, con TensorFlow es necesario inicializar

espacio para los tensores que se van a emplear, también conocidos como placeholders.

Esto consiste en definir el grafo que se va a emplear. Más tarde en el entrenamiento, todos

estos placeholders pasarán a estar inicializados y a funcionar.

15

Más tarde se computa el loss entre los resultados y las "labels", en este caso los vectores

en español. El loss no es más que la diferencia entre los vectores resultantes a la salida de

la última capa y los vectores en español. Este loss es el que ayuda a la red a entrenar, pues

para aprender la red se guía en reducir las distancias entre los vectores transformados y los

vectores destino. A partir de aquí, hay varias formas de optimizar la red, como aumentar

el número de capas, aumentar la importancia que se le da al loss (mediante el parámetro

beta) o reducir o aumentar el ratio de aprendizaje. Este último paso se lleva a cabo con

optimizador que acepta dos parámetros, el alpha o ratio de aprendizaje, que no es más

que la capacidad de aprendizaje de la red, y el learning decay, que es el porcentaje que se

quiere aplicar al ratio de aprendizaje para reducirlo o aumentarlo. Al principio se requie-

re un alpha grande para aprender más rápido, y a medida que avance el entrenamiento

reducirlo para ajustar los valores.

Figura 10: Variables clave del entrenamiento

Como se observa en la figura anterior, disponemos de dos parámetros que ayudan a so-

pesar la importancia que se le dan al loss y al optimizador, beta y alpha. El optimizador

es una función de la librería de TensorFlow que permite reducir el ratio de aprendizaje,

y cuánto mayor sea alpha, mayor será la reducción del ratio de aprendizaje. Esto es útil

cuando se llevan muchas etapas en el entrenamiento y no se ve mejora en los resulta-

dos. El parámetro beta controla el peso que se le quiere dar a la regularización de los

parámetros de cada capa. Por otra parte, la función "real_loss" es una función local que

computa la distancia coseno entre las salidas de las capas y los vectores en español. Con

una combinación adecuada para ambos parámetros, se puede construir un buen modelo

que represente a la mayoría de los vectores del conjunto.

16

4. EXPERIMENTOS

Esta es la parte crucial del proyecto, pues el objetivo del mismo es medir la eficiencia

de las traducciones calculadas por los algoritmos y en caso de que los resultados sean

mediocres, mejorarlos mediante su optimización. A lo largo de todos los experimentos se

han calculado distintas métricas y generado varios ficheros auxiliares distintos.

Tal y como se ha explicado en apartados anteriores, la medida empleada para comprobar

la similitud de los vectores entre sí ha sido la distancia coseno. Para la comprobación de

la eficiencia, por otra parte, se han empleado tres métricas personalizadas.

4.1. Métricas calculadas

Para ilustrar las métricas empleadas, es necesario explicar qué medida se ha usado para

calcular la similitud entre los vectores. Dicha medida es la distancia coseno, medida em-

pleada para hallar la similitud entre vectores. Se ha utilizado para encontrar la similitud

entre la transformación del vector en el idioma origen y los vectores en el idioma destino.

La transformación del vector en el idioma origen es el vector resultante de aplicar el al-

goritmo al vector de entrada, y los vectores en el idioma destino son los vectores donde

se quiere encontrar una traducción. Siendo u y v un par de vectores de los que se quiere

obtener la similitud, el cómputo de la distancia es el siguiente,

1− u · v‖u‖ · ‖v‖ (7)

cuyo resultado se encuentra en el intervalo [0,2], siendo el 0 la máxima similitud y el 2

desigualdad.

17

Figura 11: Proceso de la obtención de las traducciones

Para medir la eficiencia y conocer el comportamiento de los algoritmos se van a considerar

las tres métricas principales que se han utilizado, el top 5, las traducciones encontradas y

una métrica referente a las distancias coseno.

Todas estas métricas se han utilizado con distinto número de muestras, siendo el más

habitual entre 100 y 500 muestras. Por ello, para tener un valor general que represente

todo el experimento, se ha realizado la media de los 100/500 resultados existentes.

4.1.1. Top 5

Métrica que evalúa la calidad de la traducción devuelta por el algoritmo, retornando como

resultado valores en el intervalo de enteros [0,5]. Para el cómputo, se calculan los cinco

vectores en español (idioma destino) más cercanos a un vector en inglés (idioma origen)

pasado por el algoritmo con la distancia coseno. Entonces se comprueba en qué posición

está la traducción dentro de estos cinco vectores devueltos.

En el mejor de los casos, la traducción verdadera se encontrará en la primera posición

(vector más cercano), siendo el resultado un 5. En caso de encontrarse en posiciones

posteriores, el top irá disminuyendo hasta devolver un 0 en caso de que la traducción ni

siquiera aparezca en dichos vectores. En versiones anteriores se calcularon también el top

3 (solo con las primeras tres traducciones) y el top 1 (solo con la primera traducción),

aunque solo se han tenido en cuenta los resultados devueltos por el top 5.

Como se ha mencionado anteriormente, se calcula la media de todos los top, siendo la

media total ideal un 5.

18

4.1.2. Traducciones encontradas

Métrica que indica si la traducción correcta se encuentra dentro de las cinco traducciones

devueltas. Devuelve un 1 si la encuentra y un 0 en caso contrario.

De nuevo, se ha calculado la media de todas las muestras procesadas para tener una visión

más general, siendo un 1 de media el valor ideal, indicando que todas las traducciones se

habrían encontrado en las cinco primeras devueltas por el algoritmo.

4.1.3. Métrica relacionada con las distancias

Esta métrica es algo más compleja de calcular. Se calculan dos valores, la pérdida (o el

loss), que es la distancia entre el vector inglés transformado y el vector de su traducción en

español, y por otra parte, la media de las distancias, que es una media de las distancias del

vector inglés transformado con las cinco traducciones devueltas por la distancia coseno.

Tanto el loss como la media de las distancias se encuentran entre los valores [0,2].

Estos dos valores permiten observar cómo el algoritmo consigue aproximar el vector

transformado a la traducción original con el loss, puesto cuanto menor sea el loss me-

jor es la optimización realizada.

Por último, para este método se ha hecho el cálculo de la media de una forma un poco

distinta. Se han calculado las medias según el top en el que se encuentran las muestras,

existiendo 5 medias diferentes. Esto se ha hecho con la finalidad de ver cómo se comporta

el algoritmo en cada caso. Finalmente se ha hecho la media de las 5 anteriores para tener

una visión genérica del comportamiento. Sin embargo, solo se va a tener en cuenta esta

última media puesto que las medias de los distintos tops no difieren demasiado.

4.2. Matriz de traducción

La primera etapa del trabajo consistió en evaluar distintas matrices de traducción, con los

distintos tops mencionados anteriormente y midiendo las traducciones encontradas para

comprobar su eficacia. Sin embargo, solo se ha tenido en cuenta el resultado del top 5

para la evaluación final.

Las matrices de traducción se generaron a partir de distinto número de vectores. Esto no

supone ningún problema puesto que solo importa que la dimensión de cada vector de

19

embeddings sea de 1x300. De esta forma, se podían generar matrices de traducción de

tamaño 300x300 siempre, sin importar el número de vectores que se emplearan. Como se

puede observar en la siguiente imagen, la matriz tendrá siempre las mismas dimensiones

independientemente del número de vectores empleados para generarla (resolviendo la

ecuación matricial mencionada en capítulos anteriores).

Figura 12: Dimensión de los vectores y de la matriz de traducción

Para la generación de la matriz se han empleado distinto número de vectores utilizando

siempre los primeros de los conjuntos y además, se han empleado conjuntos únicamente

de syncons, de lemmas y mixtos. Los vectores están ordenados por frecuencia de aparición

de la palabra a la que representan, y de está forma no incluimos ruido en la matriz, como

podría ocurrir si usamos las palabras que menos aparecen en los textos.

En la realización de los primeros experimentos hubo ciertos problemas, entre ellos, que

el top 5 devuelto por los métodos era demasiado bueno. Esto se debía a que se estaban

buscando las traducciones en un espacio mucho más pequeño (solo teniendo en cuenta

los vectores que se encuentran en los diccionarios de traducciones), por lo que se obvia-

ban muchas más opciones de búsqueda y el resultado era mejor. Sin embargo, lo que se

necesita es un método bueno que sea capaz de encontrar traducciones en todo el corpus

destino. Es por ello que todos los experimentos realizados anteriormente se calculaban

con un mayor número de muestras, porque se estaba buscando la traducción en un es-

pacio bastante más reducido. En los experimentos válidos se emplearon únicamente 500

vectores de entrada para probar el algoritmo, puesto que la búsqueda de las traducciones

en espacios amplios requiere mucho más tiempo.

En la tabla siguiente se muestran los resultados de las traducciones para 1500 syncons

20

aleatorios pasadas por matrices generadas con vectores únicamente formados por syn-

cons, habiendo buscado las traducciones entre los vectores que se encontraban en los

diccionarios de traducciones.

Número de vectores Top 5 Traducciones encontradas

1000 3.49933333333 0.437333333333

1500 4.76066666667 0.693333333

2500 4.26533333333 0.618666666667

5000 3.52133333333 0.646666666667

10000 2.916 0.654666666667

15000 2.70066666667 0.654666666667

20000 2.62066666667 0.656666666667

Tabla 1: Top 5 (no válido) de 1500 entradas con matrices de syncons

Las columna "Número de vectores" indica el tamaño de los conjuntos de vectores que se

utilizaron para hacer la matriz y el resto de columnas las métricas ya explicadas. Cada

fila de la tabla equivale a los resultados de pasar las 1500 entradas por la correspondiente

matriz (1000 vectores, 1500 vectores...). Como se puede observar, la matriz generada con

1500 vectores en inglés y en español tiene el mejor top 5 y encuentra el 69 % de las tra-

ducciones. Estos resultados son realmente buenos, pero no son válidos por lo mencionado

anteriormente.

En las siguientes tablas se muestran los resultados de los experimentos finales. Dichos

experimentos se realizaron únicamente con 500 entradas para probar las matrices, puesto

que ahora las traducciones se buscaban de forma correcta, recorriendo absolutamente to-

dos los vectores, estuvieran en el diccionario o no. La obtención de las 500 traducciones

era un proceso lento, debido a que por cada vector de entrada había que buscar en todos

los vectores del corpus en español. Cabe mencionar que para cada tipo de matriz se uti-

lizaron muestras acordes, es decir, para matrices generadas con syncons se probaron 500

embeddings de syncons, etcétera.

21


500 0.14 0.034

1500 0.894 0.226

2500 1.226 0.304

5000 1.292 0.306

10000 1.338 0.328

15000 1.338 0.314

20000 1.298 0.308

Tabla 2: Top 5 con matrices generadas con syncons


500 0.036 0.008

1500 0.488 0.126

2500 0.756 0.192

5000 1.18 0.286

10000 1.292 0.318

15000 1.29 0.314

20000 1.226 0.298

Tabla 3: Top 5 con matrices generadas con lemmas


500 0.056 0.012

1500 0.488 0.12

2500 0.798 0.2

5000 1.142 0.288

10000 1.254 0.308

15000 1.3 0.316

20000 1.328 0.322

Tabla 4: Top 5 con matrices generadas con syncons y lemmas

Con los resultados de las tablas anteriores se puede observar que la matriz de traducción

no funciona demasiado bien. En la mayoría de los casos solo encuentra el 30 % de las

traducciones. Esto puede deberse al algoritmo en sí o al set de vectores empleados.

22

En cualquier caso, tanto para matrices hechas con vectores de syncons, vectores de lem-

mas o vectores de syncons y lemmas, los resultados son ampliamente parecidos. A partir

de ahora, es necesario averiguar qué está pasando y cómo solucionarlo.

Antes de realizar la implementación con redes neuronales, se comprobó que realmente era

viable optimizar la matriz. Para ello se generaron el mismo número de matrices que en los

experimentos anteriores, pero ahora las entradas de las que hallaríamos la traducción no

serían 500 muestras aleatorias, sino los vectores en inglés con los que se computó la matriz

de traducción. Lo ideal es que este experimento retornara valores altos, puesto que la

matriz había sido generada con dichos vectores y realizar la aproximación no debería ser

una tarea tan compleja. Estos experimentos se realizaron también para syncons, lemmas

y syncons y lemmas a la vez.


500 4.928 0.988

1500 4.002 0.828

2500 3.482 0.748

5000 2.956 0.654

10000 2.552 0.554

15000 2.354 0.514

20000 2.248 0.492

Tabla 5: Top 5 de vectores en inglés usados para generar la matriz (syncons)


500 4.908 0.984

1500 3.952 0.812

2500 3.436 0.726

5000 2.754 0.596

10000 2.158 0.474

15000 1.924 0.412

Tabla 6: Top 5 de vectores en inglés usados para generar la matriz (lemmas)

23


500 4.814 0.974

1500 3.784 0.81

2500 3.212 0.712

5000 2.498 0.568

10000 2.126 0.5

15000 1.87 0.438

20000 1.72 0.396

Tabla 7: Top 5 de vectores en inglés usados para generar la matriz (mixto)

Estos resultados confirman que la matriz de traducción funciona correctamente, ya que en-

trenando con 500 vectores, esos 500 vectores se traducen correctamente en casi el 100 %

de los casos. Los resultados también muestran las limitaciones del algoritmo para genera-

lizar las traducciones y son un buen indicio de que los espacios vectoriales no se pueden

traducir con una simple transformación lineal. El siguiente paso será implementar una red

neuronal que entrenase con estos de vectores y consecuentemente ejecutar los experimen-

tos convenientes para comprobar la mejoría.

4.3. Primeras pruebas con redes neuronales

La primera tarea consistió en implementar una red neuronal de una capa. Antes de comen-

tar las pruebas que se han realizado, es importante aclarar algunos aspectos relevantes de

la implementación.

Para entrenar las redes es necesario utilizar tres conjuntos de datos diferentes. En este

caso, el 80 % de los datos de entrada se ha dedicado al entrenamiento, un 10 % se ha

empleado como conjunto de validación para comprobar la eficacia del entrenamiento en

cada iteración y el 10 % restante se ha usado como test para probar el entrenamiento final,

todo en la última iteración. Los vectores empleados para entrenar son de ambos conjuntos,

el conjunto de vectores origen (en inglés) y el conjunto de vectores destino (en español).

El entrenamiento crea un modelo que intenta aproximar los valores (vectores en inglés) a

las "etiquetas" (en este caso, los vectores en español), siendo dicho modelo la sustitución

de la matriz de traducción.

24

Se disponía de un código auxiliar en el que empleaban técnicas de entrenamientos dife-

rentes, Gradient Descent (GD) y Stochastic Gradient Descent (SGD). La diferencia entre

ambos tipos de entrenamiento es la ejecución. El GD toma todo el conjunto de entre-

namiento en cada iteración, mientras que el SGD toma una pequeña parte aleatoria del

conjunto de entrenamiento cada vez, haciendo las computaciones mucho más rápidas y

eficaces, puesto que en cada iteración solo es necesario tener en cuenta los nuevos valores

que añaden al modelo los conjuntos aleatorios correspondientes. Debido a las múltiples

ventajas del SGD, se decidió usar ese tipo de entrenamiento para la implementación y los

experimentos. En la primera versión de la implementación solo se utilizó una red neuronal

de una capa (300x300), que funcionaría más o menos como la matriz de traducción.

De nuevo, se realizaron tres tipos de entrenamientos diferentes, utilizando solo syncons,

solo lemmas, y utilizando los vectores tanto de syncons como de lemmas. Los tres mo-

delos se guardaron, cargaron y probaron de nuevo con 500 entradas seleccionadas aleato-

riamente de los vectores en inglés. El experimento devolvió los resultados que se pueden

ver en la tabla siguiente.

Tipo de token Top 5 Traducciones encontradas

Syncon-lemma 1.142 0.294

Syncon 1.218 0.292

Lemma 1.018 0.256

Tabla 8: Top 5 con red neuronal de una capa

Los resultados son bajos y bastante parecidos a los de la matriz de traducción, como

se esperaba. También se hicieron pruebas con una red neuronal de tres capas, con 500

nodos por capa, pero los resultados eran más bajos que con la nn1. Antes de optimizar la

red cambiando los parámetros (número de capas, número de nodos por capa, alfa, beta,

optimizadores...) se decidió hacer una verificación del funcionamiento de la red parecida

a la verificación previamente realizada con la matriz.

25

4.4. Comprobación del funcionamiento de las redes

Estos experimentos se realizaron con la finalidad de comprobar la mejora introducida

por las redes en comparación a la matriz de traducción y suponiendo que los espacios

vectoriales no tenían una transformación lineal, comprobar cuán no lineales podrían ser

dichas transformaciones. Para ello se han generado espacios vectoriales aleatorios y se

calcularon el top 5, las traducciones encontradas y la métrica explicada anteriormente en

relación con las distancias para tres algoritmos diferentes: la matriz de traducción, la red

neuronal de una capa y una nueva red neuronal de tres capas.

Todos los experimentos se llevaron a cabo con 500 muestras seleccionadas aleatoriamente

de los vectores origen.

4.4.1. Vectores origen aleatorios y vectores destino generados con matrices de tra-ducción aleatorias

Primero, se generaron unos vectores origen aleatorios y distintas matrices aleatorias. Para

obtener los vectores destino, basta con multiplicar cada uno de los vectores origen por una

o varias matrices de traducción. En este caso, se generaron dos tipos de vectores destino,

uno con una única matriz de traducción (transformación puramente lineal) y el otro con

tres matrices de traducción diferentes. Para este último, se escogía aleatoriamente qué

matriz usar para transformar cada vector en inglés.

Para probar los algoritmos se generaron 500 muestras aleatorias sacadas de los vectores

origen aleatorios. Los resultados fueron los siguientes.

Algoritmo Top 5 Traducciones encontradas

TM 5.0 1.0

nn1 5.0 1.0

nn3 5.0 1.0

Tabla 9: Top 5 con vectores origen aleatorios y vectores destino generados con una matriz

26

Algoritmo Pérdida (loss) Media de las distancias

TM 3.06421554797e-16 0.550060540881

nn1 0.00646819331291 0.550988372343

nn2 0.0741946882401 0.557395174019

Tabla 10: Distancias con vectores origen aleatorios y vectores destino generados con una

matriz

Como se puede observar, los resultados del top 5 son perfectos, y también los referentes a

la existencia de la traducción. Se encuentran todas las traducciones y además el algoritmo

las devuelve en la primera posición. En la tabla de las distancias tenemos dos colum-

nas. Como se ha constatado anteriormente, la pérdida indica la distancia coseno entre

el vector transformado y la traducción real. En este caso, la pérdida es prácticamente 0

(siendo el ideal 0) para los tres algoritmos, indicando que la transformación realizada es

bastante buena. Por otra parte, la media de las distancias nos indica cómo de separadas se

encuentras las traducciones obtenidas por el algoritmo respecto del vector transformado.

En realidad, cuanto más separadas estén estas distancias, más fácil será para el algorit-

mo encontrar la traducción. Sin embargo, si la separación es muy grande, podría llegar a

encontrar otro vector más cercano y predecir una traducción errónea.


TM 5.0 1.0

nn1 5.0 1.0

nn3 4.988 1.0

Tabla 11: Top 5 con vectores origen aleatorios y vectores destino generados con tres ma-

trices


TM 0.419118370197 0.676005894646

nn1 0.436321689732 0.704919977956

nn3 0.54935723751 0.700991955503

Tabla 12: Distancias con vectores origen aleatorios y vectores destino generados con tres

matrices

27

En el caso de los vectores destino generados con tres matrices, los tres algoritmos siguen

funcionando bien, según los valores del top 5 y las traducciones encontradas. Por otra par-

te, el loss aumenta, puesto que ahora que los vectores no se han transformado linealmente

y los algoritmos aproximan bastante peor el vector original. También aumenta la media

de las distancias porque los vectores devueltos por los algoritmos se parecen menos a la

transformación del original.

Sin embargo, ambos resultados son los esperados. La distribución aleatoria de los vecto-

res hace que los algoritmos funcionen correctamente, aunque algo peor en el caso de la

transformación no lineal.

4.4.2. Vectores origen originales y vectores destino generados con matrices de tra-ducción aleatorias

Esta vez, para comprobar cómo influye la linealidad en los conjuntos, se emplearon como

vectores origen los vectores en inglés originales de los que ya se disponía. Sin embargo,

para este caso se generaron bastantes más matrices, dando lugar a cuatro experimentos

distintos con sus respectivos resultados. En el primer experimento los vectores se gene-

raron con una única matriz aleatoria, como puede observarse en la siguiente tabla.


TM 5.0 1.0

nn1 5.0 1.0

nn3 4.994 1.0

Tabla 13: Top 5 con vectores origen originales y vectores destino generados con una

matriz


TM 3.05533376377e-16 0.272832202855

nn1 0.0550575072987 0.282460886936

nn3 0.106477694803 0.236024750516

Tabla 14: Distancias con vectores origen originales y vectores destino generados con una

matriz

28

Los resultados siguen siendo bastante buenos, incluso parecidos a los resultados calcu-

lados anteriormente con vectores totalmente aleatorios. A continuación, se muestran los

resultados para los vectores destino generados con tres matrices escogiéndolas al azar.


TM 4.882 0.996

nn1 4.644 0.962

nn3 4.74 0.976

Tabla 15: Top 5 con vectores origen originales y vectores destino generados con tres

matrices


TM 0.46503631875 0.497453954237

nn1 0.513131615107 0.523725768455

nn3 0.502895204206 0.513489004829

Tabla 16: Distancias con vectores origen originales y vectores destino generados tres ma-

trices

De nuevo, en este segundo experimento, los resultados son algo peores porque la peque-

ña no linealidad que se introduce al multiplicar arbitrariamente por una matriz distinta de

las tres disponibles. Empeoran tanto el porcentaje de traducciones encontradas como el

top 5 y el loss. Esto quiere decir que al algoritmo le cuesta más aproximar los vectores

en inglés al espacio de vectores en español. Además, aumenta la media de las distancias,

lo que quiere decir que los resultados distan bastante del vector transformado. Como se

ha mencionado, esto puede ayudar a encontrar la traducción al estar los vectores más

dispersos, sin embargo el porcentaje de traducciones encontradas baja.

Para comprobar cómo afecta la no linealidad y la dispersión de los vectores en el espacio

a la búsqueda de traducciones, se han realizado dos experimentos más con esta tanda de

vectores.

En el tercer experimento se han generado 50 matrices aleatorias y se ha multiplicado

cada vector del conjunto inglés por una de estas matrices, escogiéndolas siempre al azar.

Los resultados son los siguientes.

29


TM 0.348 0.096

nn1 0.186 0.056

nn3 0.384 0.102

Tabla 17: Top 5 con vectores origen originales y vectores destino generados con cincuenta

matrices


TM 0.771213205209 0.757200985934

nn1 0.763410504408 0.746825995308

nn3 0.752675745975 0.734235459825

Tabla 18: Distancias con vectores origen originales y vectores destino generados cincuen-

ta matrices

Los resultados son los esperados. La no linealidad introducida es mucho mayor en compa-

ración a experimentos anteriores, provocando que sea prácticamente imposible encontrar

traducciones.

Para el último experimento, se decidió generar los vectores destino de manera más com-

pleja. En primer lugar, se generaron 10 matrices aleatorias, y a cada una se le asignó

un vector del espacio de los vectores en inglés. Posteriormente, en lugar de multiplicar

aleatoriamente, se obtuvieron los vectores destino multiplicando por la matriz cuyo vec-

tor asociado está más cerca de cada vector origen. De esta forma se forman grupos de

vectores reduciendo la dispersión. Los resultados son los siguientes.


TM 2.204 0.48

nn1 1.992 0.426

nn3 2.774 0.606

Tabla 19: Top 5 con vectores origen originales y vectores destino generados con 10 ma-

trices asociadas a vectores

30


TM 0.540641202091 0.538964885858

nn1 0.527255010045 0.5216499263

nn3 0.387067110611 0.389161465335

Tabla 20: Distancias con vectores origen originales y vectores destino generados con 10

matrices asociadas a vectores

Estos resultados son más similares y parece que se asemejan a lo que está ocurriendo con

el conjunto de vectores originales. La dispersión es mucho menor como puede observarse

con la media de las distancias. Por ello, y finalmente, para comprobar si podemos acer-

carnos más a unos resultados reales, ahora se van a generar los vectores destino con 25

matrices, siguiendo el mismo método mencionado anteriormente.


TM 1.5 0.33

nn1 1.178 0.26

nn3 1.672 0.382

Tabla 21: Top 5 con vectores origen originales y vectores destino generados con 25 ma-

trices asociadas a vectores


TM 0.561396945889 0.554655499855

nn1 0.524270401589 0.517766666099

nn3 0.45944572349 0.453803965181

Tabla 22: Distancias con vectores origen originales y vectores destino generados con 25

matrices asociadas a vectores

31

4.4.3. Vectores origen y destino originales

Finalmente, y para contrastar con el resto de resultados, se obtuvieron las distancias, los-

ses y top 5 de matrices de traducción y redes neuronales entrenadas con los conjuntos de

vectores originales.


TM 1.496 0.374

nn1 1.27 0.312

nn3 1.448 0.348

Tabla 23: Top 5 con conjuntos originales


TM 0.482358097396 0.456539363708

nn1 0.33465367712 0.303233678491

nn3 0.351606872809 0.326922153405

Tabla 24: Distancias con conjuntos originales

Tal y como se aprecia, el caso real se asemeja bastante a los dos experimentos anteriores,

los realizados con las matrices que más se aproximan a determinados puntos en el espacio.

Con estos experimentos podemos concluir que los algoritmos funcionan como se espe-

ra y que el problema no está en ellos, sino en la dispersión de los vectores. Las redes

neuronales, al no tener un comportamiento lineal como el de la matriz de traducción, se

aproximan más a unos resultados mejores. Parece ser que los vectores se encuentran agru-

pados en clústers a lo largo del espacio, separándose más de vectores que quedan fuera de

estas agrupaciones. Esta tarea dificulta en cierta forma el cómputo de las traducciones. Por

ello, y tras comprobar que los algoritmos son optimizables, en los siguientes apartados se

comentará cómo se han obtenido las mejoras correspondientes.

32

4.5. Optimización de las redes

Para averiguar qué red es la más adecuada, se han tenido en cuenta distintos parámetros de

optimización, los cuales son el número de capas empleadas, el número de nodos en cada

capa y los parámetros alpha y beta y el learning decay. Los parámetros alpha y beta daban

distintos pesos a partes relevantes del entrenamiento. Alpha es el ratio de aprendizaje, el

learning decay permite reducir este alpha tanto como se quiera, y beta da un peso a la

regularización de cada capa.

A partir de aquí, todos los entrenamientos y posteriores experimentos se han realizado

con los vectores originales en inglés y en español, utilizando tanto syncons como lemmas.

Las 500 muestras que se han empleado para el cómputo del top 5 se han obtenido de los

vectores originales en inglés, únicamente de aquellos con traducción.

En primer lugar se decidió realizar una optimización de la red neuronal de tres capas. En

un principio no se aplicó una función de activación (relu) a los resultados de procesar

cada entrada de las capas, y por eso los resultados en un comienzo eran bastante peores,

y además, en esta primera versión no se aplicó un learning decay. El número de nodos

de las capas intermedias para estos experimentos se ha mantenido en 500. Estos son los

resultados de los experimentos con la red neuronal de tres capas.

Alpha Beta Relu Top 5 Traducciones encontradas

0.5 0.001 No 0.484 0.12

5 0.01 No 0.364 0.094

0.5 0.001 Sí 0.958 0.236

5 0.001 Sí 0.966 0.238

2.5 0.0001 Sí 1.448 0.348

Tabla 25: Resultados para las combinaciones de alpha y beta

Una vez encontrada la mejor combinación, en este caso alpha=2.5 y beta=0.0001 (y, ob-

viamente, aplicando la función de activación relu), es necesario encontrar una combina-

ción adecuada de nodos y capas. Es por eso que en las siguientes pruebas se probaron

distintas redes, cada una con distinto número de capas. También se modificó el número

de nodos en las capas interiores. A continuación se muestran las tablas con los resultados

por cada red.

33

Nodos capas intermedias Iteraciones Top 5 Traducciones encontradas

2000 1500 1.934 0.446

3000 1500 2.012 0.46

4000 1500 2.354 0.5345000 1500 2.226 0.518

Tabla 26: Pruebas con la red neuronal de dos capas


500 1000 1.448 0.348

2000 1500 2.118 0.508

5000 1000 2.096 0.492

5000 1200 2.058 0.464

3000 1200 2.056 0.468

Tabla 27: Pruebas con la red neuronal de tres capas


500 1500 1.096 0.282

1000 1000 1.312 0.324

5000 1000 1.928 0.454

3000 600 1.492 0.366

Tabla 28: Pruebas con la red neuronal de cuatro capas

Para todos estos experimentos, se han cogido capas de tamaño cuadrado. Es decir, solo se

ha especificado una dimensión para las capas internas, y la entrada y la salida de la red

siempre siendo vectores fila de tamaño 1 x 300. En el caso de redes neuronales de mayor

número de capas, el entrenamiento y el cómputo de las traducciones era excesivamente

lento, por eso no se han empleado tantas iteraciones para entrenar como en el caso de la

red neuronal de dos capas. Como puede observarse en las tablas, el modelo que devuelveun mayor número de traducciones con el mejor top es la red neuronal de dos capascon 4000 nodos. En cuanto a parámetros, este modelo cuenta con 300*4000+4000 (capa

1 + biases) y 4000*300+300 (capa 2 + biases) parámetros, mientras que la matriz de

traducción solo cuenta con 300*300.

34

Con la mejor de las redes encontrada, la siguiente tarea a realizar ha consistido en una

optimización del código para acelerar el entrenamiento de los modelos y la búsqueda de

traducciones. Para generar algunos modelos la red ha llegado a entrenar durante horas, y

la búsqueda de traducciones no se ha quedado atrás.

4.6. Mejora del algoritmo de búsqueda de traducciones

El método que devuelve las traducciones es demasiado lento debido a que por cada vector

que se le pasa como entrada tiene que recorrer el resto de vectores destino en busca de las

traducciones más cercanas, y esto es un coste de tiempo inadmisible. Para calcular cada

traducción el método se toma aproximadamente 2 segundos, con lo cuál es inviable pro-

cesar un gran número de entradas. Es por ello que es necesario emplear algún algoritmo

de búsqueda más elaborado que mejore la velocidad de procesamiento.

En este caso, se ha empleado Annoy. Annoy es una librería que aplica el algoritmo de

los k-vecinos. A rasgos generales, Annoy utiliza proyecciones aleatorias para construir

un árbol, y en cada nodo intermedio elige un hiperplano aleatorio, diviendo el espacio

en el que se encuentra en dos subespacios. Este hiperplano se elige tomando muestras de

dos puntos del subconjunto y tomando el hiperplano equidistante de ellos. Este proceso

se realiza el número de veces que especifica el usuario, creando un número determinado

de árboles. Cuantos más árboles, más subespacios, y por lo tanto, más precisión a la hora

de encontrar la traducción.[10]

Con este bosque de árboles, Annoy crea un índice que hace las búsquedas sobre él bastante

efectivas y rápidas.

35

Figura 13: División del espacio vectorial por Annoy [10]

El tiempo de indexación es bastante grande, sobre todo cuántos más vectores queramos

indexar y cuántos más árboles queramos tener en el índice. Para añadir elementos al índi-

ce es necesario pasar un identificador numérico para cada vector. Además, es conveniente

que los vectores estén normalizados para que Annoy compute las distancias correctamen-

te, puesto que para calcular la distancia coseno los métodos de la librería se limitan a

aplicar el producto escalar a los vectores.

Una vez creado el índice, basta con recorrerlo y en base a las distancias coseno compu-

tadas por Annoy, devolver las traducciones correspondientes. Dicho índice se creó sobre

todos los vectores en español, para hacer la búsqueda de traducciones mucho más rápida.

36

4.7. Mejora de los vectores empleados para el entrenamiento

Finalmente, y teniendo en cuenta todas las mejoras realizadas previamente, tan solo que-

daba optimizar los vectores de alguna forma. Para ello se empleó una implementación

modificada de Swivel, la librería con la que se generaron los conjuntos de vectores en

inglés y en español. En base a las pruebas descritas en 4.4 se concluyó que los vecto-

res iniciales podrían mejorarse para hacer la tarea de traducción más fácil. Para esto, el

equipo en Expert System encargado de generar los vectores añadió un componente de

regularización de los vectores durante el entrenamiento y generó nuevos vectores usando

también un número de epochs más alto.

Con los nuevos vectores se han obtenido los siguientes resultados.

Algoritmo Nodos capas intermedias Iteraciones Top 5 Traducciones encontradas

Matriz x x 1.374 0.356

nn2 4000 1500 2.606 0.61

nn2 5000 1500 3.008 0.68

nn2 10000 1500 3.48 0.776nn3 5000 1500 3.148 0.716

Tabla 29: Pruebas con los vectores optimizados

Tal y como se observa en la tabla, los mejores resultados son devueltos por la redneuronal de dos capas con 10000 nodos internos. La mejora es mucho mayor que en

los casos anteriores, obteniendo ahora un 77.6 % de las traducciones, mientras que con

los vectores sin regularizar se obtenía solo el 53,4 %.

Las siguientes gráficas ilustran un poco mejor a qué se debe esto. Ambas nos muestran,

para ambos datasets (el de vectores antiguos y el de vectores regularizados) la distancia

promedio entre una palabra y el vector de las palabras de su contexto. En el eje x tenemos

las palabras ordenadas por mayor frecuencia de aparición, y en el y este promedio. Cuanto

más cerca esté este promedio de 1 (la distancia coseno en este caso está en los valores [-

1,1]), más se parecen los vectores a su contexto, y por lo tanto más fácil es predecir la

palabra en cuestión.

37

Figura 14: Promedio de las distancias entre palabras y su contexto con los vectores anti-

guos

Figura 15: Promedio de las distancias entre palabras y su contexto con los vectores mejo-

rados

Como se puede apreciar, es mucho más sencillo averiguar las palabras por su contexto en

el segundo caso, con los vectores mejorados, puesto que las medias de las distancias se

aproximan bastante al 1 (indicando que se parecen bastante). Sin embargo, en el caso de

los vectores viejos, las traducciones se encontraban con facilidad en los 5000 primeros

tokens, pero en el resto empeora con creces.

Una traducción generada con el algoritmo final, por ejemplo, es la siguiente. Se han bus-

cado las traducciones para el concepto de equidistancia (en inglés), representado con el

syncon en#173290.

38

Distancia Concepto Descripción

0.442 línea media, media Median line, in the rugby, that of the central defenders

0.463 equidistancia Property of the equidistant geometric agencies

0.489 bisector Straight line that divides an angle in two equal parts

0.544 límite, línea A spatial location defined by a unidimensional extent

0.554 bajamar, regolfo The outward flow of the tide

Tabla 30: Ejemplo de traducción de un syncon

Tal y como puede observarse, todas las traducciones tienen bastante sentido. La primera

columna representa la distancia coseno entre el vector original pasado por el algoritmo y

los vectores devueltos como traducción. Pese a que la traducción correcta se encuentre en

segunda posición, lo importante es que dicha traducción aparece, puesto que, como se va

a comentar en la conclusión, los lingüistas de la empresa serán quiénes usen este algorit-

mo. Bastará con seleccionar la traducción correcta de las más cercanas que devuelva el

algoritmo.

39

5. RESULTADOS Y CONCLUSIONES

5.1. Implementación final del sistema

La implementación final del sistema consta de la red neuronal de dos capas con la com-

binación de parámetros mencionada anteriormente y el modelo generado por el entrena-

miento, además del índice creado por Annoy para agilizar la búsqueda de traducciones.

Una vez se guarda el modelo no es necesario realizar más entrenamientos, simplemente se

le pasa a dicho modelo el vector del que se quiere obtener la traducción para la obtención

de la misma.

Todos los códigos empleados para el desarrollo del proyecto pueden encontrarse en el

repositorio de GitHub14

En un futuro, es altamente probable que se prueben otras combinaciones de redes neu-

ronales que requieran más tiempo de entrenamiento. Esta vez, por falta de tiempo, la

red neuronal de dos capas cumple perfectamente los requisitos para ser el algoritmo de

traducción idóneo.

5.2. Conclusiones

El sistema planteado ofrece un porcentaje de traducciones encontradas bastante acepta-

ble. Sigue siendo mejorable realizando ciertos cambios, pero por falta de tiempo esto no

ha sido posible. Sin embargo, con este trabajo se ha demostrado que se pueden obtener

traducciones entre dos espacios vectoriales con buenos resultados y en poco tiempo. Una

red neuronal con varias capas y un número alto de nodos por capa podría mejorar los

resultados, pero esto requiere un aumento sustancial del tiempo de entrenamiento y pro-

bablemente también requiera cambios en la arquitectura de las redes neuronales ya que al

aumentar las capas es más difícil entrenarlas. [11]

El caso de uso práctico es el de ayudar a los lingüistas de la empresa a encontrar syncons

equivalentes entre idiomas. Para esto, no es necesario encontrar traducciones perfectas,

pero sí es necesario enseñar syncons relacionados. Por eso un acierto de casi 80 % es bas-

tante útil, porque para cada syncon en inglés se podrán sugerir cinco syncons relacionados

en español y en el 80 % de los casos la traducción real aparecerá en dichos syncons en

14https://github.com/olgasalas/tfg-translation_matrix

40

español, por lo que el lingüista solo tendría que seleccionar el syncon correcto.

Por otra parte, en cuanto a conocimientos adquiridos, gracias a este trabajo se han apren-

dido a usar distintas librerías y a entender el funcionamiento de los algoritmos de clasifi-

cación como las redes neuronales y tecnologías relacionadas con deep learning. Todo los

conceptos a implementar en este trabajo han sido materia nueva jamás vista antes.

41

6. REFERENCIAS

[1] A. Lenci. (2008). Distributional semantics in linguistic and cognitive research, di-

rección: http://linguistica.sns.it/RdL/20.1/ALenci.pdf.

[2] K. Team. (2016). Home Depot Product Search Relevance, Winners’ Interview: 1st

Place, dirección: https://blog.kaggle.com/2016/05/18/home-

depot-product-search-relevance-winners-interview-1st-

place-alex-andreas-nurlan/.

[3] M. Baroni, G. Dinu y G. Kruszewski. (2014). Don’t count, predict! A systematic

comparison of context-counting vs. context-predicting semantic vectors, dirección:

http://clic.cimec.unitn.it/marco/publications/acl2014/

baroni-etal-countpredict-acl2014.pdf.

[4] T. Mikolov, Q. V. Le e I. Sutskever. (2013). Exploiting Similarities among Langua-

ges for Machine Translation, dirección: https://arxiv.org/pdf/1309.

4168.pdf.

[5] T. M. et al. (2013). Distributed Representations of Words and Phrases and their

Compositionality, dirección: https://arxiv.org/pdf/1310.4546.pdf.

[6] Wikipedia. (2017). Neurona, dirección: https://es.wikipedia.org/

wiki/Neurona.

[7] U. de Salamanca. (2017). Redes Neuronales, dirección: http://avellano.

usal.es/~lalonso/RNA/index.htm.

[8] A. H. V. et al. (2016). Aplicación de Redes Neuronales para el Pronóstico de De-

manda a Corto Plazo, dirección: http://www.sectorelectricidad.

com/2625/aplicacion-de-redes-neuronales-para-el-pronostico-

de-demanda-a-corto-plazo/.

[9] M. Nielsen. (2017). Neural Networks and Deep Learning, dirección: http://

neuralnetworksanddeeplearning.com/.

[10] Spotify. (2017). Annoy, dirección: https://github.com/spotify/annoy.

[11] Wikipedia. (2017). Vanishing gradient problem, dirección: https://en.wikipedia.

org/wiki/Vanishing_gradient_problem.

42

Este documento esta firmado porFirmante CN=tfgm.fi.upm.es, OU=CCFI, O=Facultad de Informatica - UPM,

C=ES

Fecha/Hora Thu Jun 08 16:59:50 CEST 2017

Emisor delCertificado

[email protected], CN=CA Facultad deInformatica, O=Facultad de Informatica - UPM, C=ES

Numero de Serie 630

Metodo urn:adobe.com:Adobe.PPKLite:adbe.pkcs7.sha1 (AdobeSignature)

trabajo fin de grado procesamiento del lenguaje natural...

Documents