En muchas bibliotecas de redes neuronales, hay 'capas de incrustación', como en Keras o Lasagne .

No estoy seguro de entender su función, a pesar de leer la documentación. Por ejemplo, en la documentación de Keras dice:

Convierta enteros positivos (índices) en vectores densos de tamaño fijo, por ejemplo. [[4], [20]] -> [[0.25, 0.1], [0.6, -0.2]]

¿Podría una persona con conocimientos explicar qué hace y cuándo lo usaría?

EDITAR: En cuanto a pegar en la documentación, no hay mucho que pegar de la documentación, de ahí mi pregunta. No entiendo la transformación que hace, ni por qué debería usarse.

De todos modos, así es como se explica en Keras:

Incrustación

keras.layers.embeddings.Embedding (input_dim, output_dim, init = 'uniform', input_length = None, weights = None, W_regularizer = None, W_constraint = None, mask_zero = False) Convierta enteros positivos (índices) en vectores densos de tamaño fijo , p.ej. [[4], [20]] -> [[0.25, 0.1], [0.6, -0.2]]

Forma de entrada: tensor 2D con forma: (nb_samples, secuencia_length). Forma de salida: tensor 3D con forma: (nb_samples, secuencia_length, output_dim). Argumentos:

input_dim: int> = 0. Tamaño del vocabulario, es decir. 1 + índice entero máximo que ocurre en los datos de entrada. output_dim: int> = 0. Dimensión de la incrustación densa

Y así es como se explica en Lasagne:

Una capa para incrustaciones de palabras. La entrada debe ser una variable Tensor de tipo entero.

Parámetros: entrantes: una instancia de capa o una tupla

La capa que se alimenta a esta capa, o la forma de entrada esperada.

input_size: int

El número de diferentes incrustaciones. La última incrustación tendrá el índice input_size - 1.

output_size: int

El tamaño de cada incrustación.

W: variable compartida Theano, expresión, matriz numpy o invocable

Valor inicial, expresión o inicializador para la matriz de incrustación. Esto debería ser una matriz con forma (input_size, output_size). Consulte lasagne.utils.create_param () para obtener más información.

Ejemplos

>>> from lasagne.layers import EmbeddingLayer, InputLayer, get_output
>>> import theano
>>> x = T.imatrix()
>>> l_in = InputLayer((3, ))
>>> W = np.arange(3*5).reshape((3, 5)).astype('float32')
>>> l1 = EmbeddingLayer(l_in, input_size=3, output_size=5, W=W)
>>> output = get_output(l1, x)
>>> f = theano.function([x], output)
>>> x_test = np.array([[0, 2], [1, 2]]).astype('int32')
>>> f(x_test) array([[[  0.,   1.,   2.,   3.,   4.],
                      [ 10.,  11.,  12.,  13.,  14.]],
                     [[  5.,   6.,   7.,   8.,   9.],
                      [ 10.,  11.,  12.,  13.,  14.]]], dtype=float32)

Relación con Word2Vec

==========================================

Word2Vec en una imagen simple:

Explicación más profunda:

Creo que está relacionado con la reciente innovación de Word2Vec en el procesamiento del lenguaje natural. Aproximadamente, Word2Vec significa que nuestro vocabulario es discreto y aprenderemos un mapa que integrará cada palabra en un espacio vectorial continuo. El uso de esta representación de espacio vectorial nos permitirá tener una representación continua y distribuida de nuestras palabras de vocabulario. Si, por ejemplo, nuestro conjunto de datos consta de n-gramos, ahora podemos usar nuestras funciones de palabras continuas para crear una representación distribuida de nuestros n-gramos. En el proceso de capacitación de un modelo de idioma, aprenderemos este mapa de inclusión de palabras. La esperanza es que mediante el uso de una representación continua, nuestra inclusión mapeará palabras similares a regiones similares. Por ejemplo, en el documento histórico Representaciones distribuidas de palabras y frases y su composición, observe en las Tablas 6 y 7 que ciertas frases tienen frases vecinas muy buenas desde un punto de vista semántico. Transformarse en este espacio continuo nos permite usar nociones métricas continuas de similitud para evaluar la calidad semántica de nuestra inclusión.

Explicación usando el código de lasaña

Analicemos el fragmento de código de Lasagne:

x = T.imatrix()

x es una matriz de enteros. Está bien, no hay problema. Cada palabra en el vocabulario puede representarse como un entero o una codificación dispersa de 1 punto. Entonces, si x es 2x2, tenemos dos puntos de datos, cada uno de 2 gramos.

l_in = InputLayer((3, ))

La capa de entrada. El 3 representa el tamaño de nuestro vocabulario. Entonces tenemos las palabras por ejemplo.$w_0, w_1, w_2$

W = np.arange(3*5).reshape((3, 5)).astype('float32')

Esta es nuestra matriz de inclusión de palabras. Es una matriz de 3 filas por 5 columnas con entradas de 0 a 14.

Hasta ahora tenemos la siguiente interpretación. Nuestro vocabulario tiene 3 palabras y las integraremos en un espacio vectorial de 5 dimensiones. Por ejemplo, podemos representar una palabra , y otra palabra y la otra palabra , por ejemplo, como codificaciones dispersas en caliente. Podemos ver la matriz como incrustando estas palabras a través de la multiplicación de matrices. Por lo tanto, la primera palabraDe manera similar . $w_0 = (1,0,0)$$w_1 = (0, 1, 0)$$w_2 = (0, 0, 1)$$W$$w_0 \rightarrow w_0W = [0, 1, 2, 3, 4].$$w_1 \rightarrow w_1W = [5, 6, 7, 8, 9]$

Cabe señalar que, debido a la codificación dispersa de un solo uso que estamos utilizando, también puede ver esto como búsquedas de tabla.

l1 = EmbeddingLayer(l_in, input_size=3, output_size=5, W=W)

La capa de incrustación

 output = get_output(l1, x)

Expresión simbólica de Theano para la incrustación.

f = theano.function([x], output)

Función Theano que calcula la incrustación.

x_test = np.array([[0, 2], [1, 2]]).astype('int32')

Vale la pena detenerse aquí para discutir qué significa exactamente x_test. Primero observe que todas las entradas de x_test están en {0, 1, 2}, es decir, rango (3). x_test tiene 2 puntos de datos. El primer punto de datos [0, 2] representa los 2 gramos y el segundo punto de datos representa los 2 gramos .$(w_0, w_2)$$(w_1, w_2)$

Deseamos incrustar nuestros 2 gramos usando nuestra capa de incrustación de palabras ahora. Antes de hacer eso, asegurémonos de tener claro qué debería devolver nuestra función de incrustación f. Los 2 gramos son equivalentes a una matriz [[1, 0, 0], [0, 0, 1]]. La aplicación de nuestra matriz de incrustación W a esta matriz dispersa debería producir: [[0, 1, 2, 3, 4], [10, 11, 12, 13, 14]]. Tenga en cuenta que para que la multiplicación de la matriz funcione, tenemos que aplicar la palabra matriz de incrustación mediante la multiplicación a la derecha a la representación de matriz dispersa de nuestros 2 gramos.$(w_0, w_2)$$W$

f(x_test) 

devoluciones:

          array([[[  0.,   1.,   2.,   3.,   4.],
                  [ 10.,  11.,  12.,  13.,  14.]],
                 [[  5.,   6.,   7.,   8.,   9.],
                  [ 10.,  11.,  12.,  13.,  14.]]], dtype=float32)

Para convencerte de que el 3 representa el tamaño del vocabulario, intenta ingresar una matriz x_test = [[5, 0], [1, 2]]. Verá que genera un error de coincidencia de matriz.

En https://stackoverflow.com/questions/45649520/explain-with-example-how-embedding-layers-in-keras-works/ Traté de preparar un ejemplo usando 2 oraciones, textos de keras a secuencias

'This is a text' --> [0 0 1 2 3 4]

y capa de inclusión. Basado en ¿Cómo funciona la capa de 'incrustación' de Keras? la capa de incrustación primero inicializa el vector de incrustación al azar y luego usa el optimizador de red para actualizarlo de manera similar a como lo haría con cualquier otra capa de red en keras.

[0 0 1 2 3 4] --> 
[-0.01494285, -0.007915  ,  0.01764857],
[-0.01494285, -0.007915  ,  0.01764857],
[-0.03019481, -0.02910612,  0.03518577],
[-0.0046863 ,  0.04763055, -0.02629668],
[ 0.02297204,  0.02146662,  0.03114786],
[ 0.01634104,  0.02296363, -0.02348827]

Arriba habría algún vector de inserción inicial para una oración de (máximo) 6 palabras y output_dim de 3.