Em muitas bibliotecas de redes neurais, existem 'camadas de incorporação', como em Keras ou Lasagne .

Não sei se entendi sua função, apesar de ler a documentação. Por exemplo, na documentação do Keras, ele diz:

Transforme números inteiros positivos (índices) em vetores densos de tamanho fixo, por exemplo. [[4], [20]] -> [[0,25, 0,1], [0,6, -0,2]]

Uma pessoa experiente poderia explicar o que faz e quando você o usaria?

Edição: Quanto à colagem na documentação, não há muito para colar a partir da documentação, daí a minha pergunta. Não entendo a transformação que ela faz, nem por que deveria ser usada.

De qualquer forma, é assim que é explicado em Keras:

Incorporação

keras.layers.embeddings.Embedding (input_dim, output_dim, init = 'uniforme', input_length = None, pesos = None, W_regularizer = None, W_constraint = None, mask_zero = False) Transforme inteiros positivos (índices) em densos vetores de tamanho fixo , por exemplo. [[4], [20]] -> [[0,25, 0,1], [0,6, -0,2]]

Formato de entrada: tensor 2D com formato: (nb_samples, sequence_length). Forma de saída: tensor 3D com forma: (nb_samples, sequence_length, output_dim). Argumentos:

input_dim: int> = 0. Tamanho do vocabulário, ie. 1 + índice inteiro máximo ocorrendo nos dados de entrada. output_dim: int> = 0. Dimensão da incorporação densa

E aqui está como é explicado em Lasanha:

Uma camada para incorporação de palavras. A entrada deve ser uma variável do tipo inteiro Tensor.

Parâmetros: entrante: uma instância de camada ou uma tupla

A camada que está sendo alimentada nessa camada ou a forma de entrada esperada.

input_size: int

O número de diferentes incorporações. A última incorporação terá o índice input_size - 1.

output_size: int

O tamanho de cada incorporação.

W: Theano compartilhou variável, expressão, matriz numpy ou chamada

Valor inicial, expressão ou inicializador para a matriz de incorporação. Deve ser uma matriz com forma (tamanho_de_ entrada, tamanho_de_saída). Veja lasagne.utils.create_param () para mais informações.

Exemplos

>>> 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)

Relação com Word2Vec

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

Word2Vec em uma imagem simples:

Explicação mais aprofundada:

Acredito que esteja relacionado à recente inovação do Word2Vec no processamento de linguagem natural. Grosso modo, Word2Vec significa que nosso vocabulário é discreto e aprenderemos um mapa que incorporará cada palavra em um espaço vetorial contínuo. O uso dessa representação do espaço vetorial nos permitirá ter uma representação distribuída e contínua de nossas palavras do vocabulário. Se, por exemplo, nosso conjunto de dados consiste em n gramas, agora podemos usar nossos recursos de palavras contínuas para criar uma representação distribuída de nossos n gramas. No processo de treinamento de um modelo de linguagem, aprenderemos esta palavra mapa de incorporação. A esperança é que, usando uma representação contínua, nossa incorporação mapeie palavras semelhantes para regiões semelhantes. Por exemplo, no documento de referência Representações distribuídas de palavras e frases e sua composicionalidade, observe nas tabelas 6 e 7 que certas frases têm frases vizinhas mais próximas muito boas do ponto de vista semântico. A transformação nesse espaço contínuo nos permite usar noções métricas contínuas de similaridade para avaliar a qualidade semântica de nossa incorporação.

Explicação usando o código Lasanha

Vamos detalhar o trecho de código Lasagne:

x = T.imatrix()

x é uma matriz de números inteiros. Ok sem problemas. Cada palavra no vocabulário pode ser representada como um número inteiro ou uma codificação esparsa a 1 quente. Portanto, se x é 2x2, temos dois pontos de dados, cada um com 2 gramas.

l_in = InputLayer((3, ))

A camada de entrada. O 3 representa o tamanho do nosso vocabulário. Portanto, temos as palavras por exemplo.$w_0, w_1, w_2$

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

Esta é a nossa matriz de incorporação de palavras. É uma matriz de 3 linhas por 5 colunas com entradas de 0 a 14.

Até agora, temos a seguinte interpretação. Nosso vocabulário tem 3 palavras e vamos incorporar nossas palavras em um espaço vetorial de 5 dimensões. Por exemplo, podemos representar uma palavra e outra palavra e a outra palavra , por exemplo, como codificações esparsas a quente. Podemos ver a matriz como incorporando essas palavras através da multiplicação da matriz. Portanto, a primeira palavraDa forma . $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]$

Deve-se observar que, devido à codificação esparsa que estamos usando, você também vê isso como consultas de tabela.

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

A camada de incorporação

 output = get_output(l1, x)

Expressão simbólica de Theano para a incorporação.

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

A função theano que calcula a incorporação.

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

Vale a pena fazer uma pausa aqui para discutir o que exatamente x_test significa. Primeiro observe que todas as entradas x_test estão em {0, 1, 2}, ou seja, no intervalo (3). O x_test possui 2 pontos de dados. O primeiro ponto de dados [0, 2] representa os 2 gramas e o segundo ponto de dados representa os 2 gramas .( w 1 , w 2$(w_0, w_2)$$(w_1, w_2)$

Desejamos incorporar nossos 2 gramas usando nossa camada de incorporação de palavras agora. Antes de fazer isso, vamos ter certeza de que estamos claros sobre o que deve ser retornado por nossa função de incorporação f. Os 2 gramas são equivalentes a uma matriz [[1, 0, 0], [0, 0, 1]]. A aplicação de nossa matriz de incorporação W a essa matriz esparsa deve render: [[0, 1, 2, 3, 4], [10, 11, 12, 13, 14]]. Observe que, para que a multiplicação de matrizes funcione, precisamos aplicar a matriz de incorporação de palavras via multiplicação correta, à representação de matriz esparsa de nossos 2 gramas.$(w_0, w_2)$$W$

f(x_test) 

retorna:

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

Para convencê-lo de que o 3 realmente representa o tamanho do vocabulário, tente inserir uma matriz x_test = [[5, 0], [1, 2]]. Você verá que isso gera um erro de incompatibilidade de matriz.

Em https://stackoverflow.com/questions/45649520/explain-with-example-how-embedding-layers-in-keras-works/ , tentei preparar um exemplo usando 2 frases, os textos de keras_to_sequences

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

e camada de incorporação. Baseado em Como a camada 'Incorporação' do Keras funciona? a camada de incorporação primeiro inicializa o vetor de incorporação aleatoriamente e, em seguida, usa o otimizador de rede para atualizá-lo da mesma forma que faria com qualquer outra camada de rede em 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]

Acima, haveria um vetor de incorporação inicial para uma frase de (máximo) 6 palavras e output_dim de 3.