¿Cómo funciona la capa de 'incrustación' de Keras?

Necesita comprender el funcionamiento de la capa 'Incrustación' en la biblioteca Keras. Ejecuto el siguiente código en Python

import numpy as np
from keras.models import Sequential
from keras.layers import Embedding

model = Sequential()
model.add(Embedding(5, 2, input_length=5))

input_array = np.random.randint(5, size=(1, 5))

model.compile('rmsprop', 'mse')
output_array = model.predict(input_array)

que da el siguiente resultado

input_array = [[4 1 3 3 3]]
output_array = 
[[[ 0.03126476  0.00527241]
  [-0.02369716 -0.02856163]
  [ 0.0055749   0.01492429]
  [ 0.0055749   0.01492429]
  [ 0.0055749   0.01492429]]]

Entiendo que cada valor en input_array se asigna a un vector de 2 elementos en output_array, por lo que un vector 1 X 4 proporciona vectores 1 X 4 X 2. Pero, ¿cómo se calculan los valores mapeados?

De hecho, los vectores de salida no se calculan a partir de la entrada utilizando ninguna operación matemática. En cambio, cada entero de entrada se utiliza como índice para acceder a una tabla que contiene todos los vectores posibles. Esa es la razón por la que necesita especificar el tamaño del vocabulario como primer argumento (para que la tabla se pueda inicializar).

La aplicación más común de esta capa es para el procesamiento de texto. Veamos un ejemplo simple. Nuestro conjunto de entrenamiento consta solo de dos frases:

Espero verte pronto

Qué gusto verte de nuevo

Por lo tanto, podemos codificar estas frases asignando a cada palabra un número entero único (por orden de aparición en nuestro conjunto de datos de entrenamiento, por ejemplo). Entonces nuestras frases podrían reescribirse como:

[0, 1, 2, 3, 4]

[5, 1, 2, 3, 6]

Ahora imagine que queremos entrenar una red cuya primera capa es una capa de inserción. En este caso, deberíamos inicializarlo de la siguiente manera:

Embedding(7, 2, input_length=5)

El primer argumento (7) es el número de palabras distintas en el conjunto de entrenamiento. El segundo argumento (2) indica el tamaño de los vectores de incrustación. El argumento input_length, por supuesto, determina el tamaño de cada secuencia de entrada.

Una vez que la red ha sido entrenada, podemos obtener los pesos de la capa de incrustación, que en este caso será de tamaño (7, 2) y puede considerarse como la tabla utilizada para asignar enteros a los vectores de incrustación:

+------------+------------+
|   index    |  Embedding |
+------------+------------+
|     0      | [1.2, 3.1] |
|     1      | [0.1, 4.2] |
|     2      | [1.0, 3.1] |
|     3      | [0.3, 2.1] |
|     4      | [2.2, 1.4] |
|     5      | [0.7, 1.7] |
|     6      | [4.1, 2.0] |
+------------+------------+

Entonces, de acuerdo con estas incrustaciones, nuestra segunda frase de entrenamiento se representará como:

[[0.7, 1.7], [0.1, 4.2], [1.0, 3.1], [0.3, 2.1], [4.1, 2.0]]

Puede parecer contradictorio al principio, pero los motores de diferenciación automática subyacentes (por ejemplo, Tensorflow o Theano) logran optimizar estos vectores asociados a cada entero de entrada como cualquier otro parámetro de su modelo. También es interesante utilizar las incrustaciones aprendidas por otros métodos / personas en diferentes dominios (consulte https://blog.keras.io/using-pre-trained-word-embeddings-in-a-keras-model.html ) como hecho en [1].

[1] López-Sánchez, D., Herrero, JR, Arrieta, AG y Corchado, JM Hibridación de aprendizaje métrico y razonamiento basado en casos para la detección de clickbait adaptable. Inteligencia Aplicada, 1-16.

También tuve la misma pregunta y después de leer un par de publicaciones y materiales, creo que descubrí cuál es el papel de la capa de incrustación.

Creo que esta publicación también es útil para entender, sin embargo, realmente encuentro la respuesta de Daniel conveniente para digerir. Pero también tuve la idea detrás de esto principalmente al comprender las palabras incrustadas .

Creo que es incorrecto decir que las capas de incrustación reducen la entrada de codificación en caliente a menos entradas. Después de todo, el vector caliente es un dato unidimensional y, de hecho, se convierte en 2 dimensiones en nuestro caso. Es mejor decir que

la capa de incrustación aparece con una relación de las entradas en otra dimensión

Ya sea en 2 dimensiones o incluso más.

También encuentro una similitud muy interesante entre la incrustación de palabras con el Análisis de componentes principales. Aunque el nombre puede parecer complicado, el concepto es sencillo. Lo que PCA hace es definir un conjunto de datos basado en algunas reglas generales (los llamados componentes principales). Entonces es como tener un dato y quieres describirlo pero usando solo 2 componentes. Lo que en este sentido es muy similar a las incrustaciones de palabras. Ambos hacen el mismo trabajo en un contexto diferente. Puedes encontrar más aquí . Espero que comprender PCA ayude a comprender la incorporación de capas mediante analogía.

Para concluir, la respuesta a la pregunta original de la publicación que " ¿cómo calcula el valor? " Sería:

• Básicamente, nuestra red neuronal captura la estructura subyacente de las entradas (nuestras oraciones) y pone la relación entre las palabras de nuestro vocabulario en una dimensión superior (digamos 2) mediante la optimización.
• Una comprensión más profunda diría que la frecuencia de cada palabra que aparece con otra palabra de nuestro vocabulario influye (en un enfoque muy ingenuo podemos calcularlo a mano)
• La frecuencia mencionada anteriormente podría ser una de las muchas estructuras subyacentes que NN puede capturar
• Puede encontrar la intuición en el enlace de youtube que explica las incrustaciones de palabras