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
16. Distancias con vectores origen originales y vectores destino generados
tres matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
17. Top 5 con vectores origen originales y vectores destino generados con
cincuenta matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
18. Distancias con vectores origen originales y vectores destino generados
cincuenta matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
19. Top 5 con vectores origen originales y vectores destino generados con 10
matrices asociadas a vectores . . . . . . . . . . . . . . . . . . . . . . . . 30
20. Distancias con vectores origen originales y vectores destino generados
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
22. Distancias con vectores origen originales y vectores destino generados
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
Número de vectores Top 5 Traducciones encontradas
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
Número de vectores Top 5 Traducciones encontradas
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
Número de vectores Top 5 Traducciones encontradas
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.
Número de vectores Top 5 Traducciones encontradas
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)
Número de vectores Top 5 Traducciones encontradas
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
Número de vectores Top 5 Traducciones encontradas
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.
Algoritmo Top 5 Traducciones encontradas
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
Algoritmo Pérdida (loss) Media de las distancias
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.
Algoritmo Top 5 Traducciones encontradas
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
Algoritmo Pérdida (loss) Media de las distancias
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.
Algoritmo Top 5 Traducciones encontradas
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
Algoritmo Pérdida (loss) Media de las distancias
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
Algoritmo Top 5 Traducciones encontradas
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
Algoritmo Pérdida (loss) Media de las distancias
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.
Algoritmo Top 5 Traducciones encontradas
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
Algoritmo Pérdida (loss) Media de las distancias
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.
Algoritmo Top 5 Traducciones encontradas
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
Algoritmo Pérdida (loss) Media de las distancias
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.
Algoritmo Top 5 Traducciones encontradas
TM 1.496 0.374
nn1 1.27 0.312
nn3 1.448 0.348
Tabla 23: Top 5 con conjuntos originales
Algoritmo Pérdida (loss) Media de las distancias
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
Nodos capas intermedias Iteraciones Top 5 Traducciones encontradas
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
Nodos capas intermedias Iteraciones Top 5 Traducciones encontradas
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)