Dans de nombreuses bibliothèques de réseaux neuronaux, il existe des «couches d'intégration», comme dans Keras ou Lasagne .

Je ne suis pas sûr de comprendre son fonctionnement, malgré la lecture de la documentation. Par exemple, dans la documentation de Keras, il est écrit:

Transformez les entiers positifs (index) en vecteurs denses de taille fixe, par exemple. [[4], [20]] -> [[0.25, 0.1], [0.6, -0.2]]

Une personne bien informée pourrait-elle expliquer son rôle et son utilisation?

EDIT: En ce qui concerne le collage dans la documentation, il n’ya pas grand chose à coller de la documentation, d’où ma question. Je ne comprends pas la transformation, ni pourquoi il devrait être utilisé.

Quoi qu'il en soit, voici comment cela est expliqué dans Keras:

Enrobage

keras.layers.embeddings.Embedding (input_dim, output_dim, init = 'uniforme', input_length = None, poids = None, W_regularizer = None, W_constraint = None, mask_zero = False) Transforme les entiers positifs (indices) en vecteurs denses de taille fixe , par exemple. [[4], [20]] -> [[0.25, 0.1], [0.6, -0.2]]

Forme d'entrée: Tenseur 2D de forme: (nb_samples, sequence_length). Forme de sortie: Tenseur 3D de forme: (nb_samples, sequence_length, output_dim). Arguments:

input_dim: int> = 0. Taille du vocabulaire, c'est-à-dire. 1 + index entier maximum apparaissant dans les données d'entrée. output_dim: int> = 0. Dimension de l'incorporation dense

Et voici comment ça s’explique à Lasagne:

Une couche pour les mots imbriqués. L'entrée doit être une variable de type entier de type entier.

Paramètres: incoming: une instance de couche ou un tuple

Le calque alimentant ce calque ou la forme d'entrée attendue.

taille_entrée: int

Le nombre de plongements différents. La dernière incorporation aura index input_size - 1.

taille_sortie: int

La taille de chaque incorporation.

W: Theano variable partagée, expression, tableau numpy ou appelable

Valeur initiale, expression ou initialiseur pour la matrice d’incorporation. Cela devrait être une matrice de forme (input_size, output_size). Voir lasagne.utils.create_param () pour plus d'informations.

Exemples

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

Relation avec Word2Vec

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

Word2Vec dans une image simple:

Explication plus approfondie:

Je crois que cela est lié à la récente innovation Word2Vec dans le traitement du langage naturel. En gros, Word2Vec signifie que notre vocabulaire est discret et nous allons apprendre une carte qui intégrera chaque mot dans un espace vectoriel continu. L'utilisation de cette représentation vectorielle nous permettra d'avoir une représentation continue et distribuée de nos mots de vocabulaire. Si, par exemple, notre jeu de données se compose de n-grammes, nous pouvons maintenant utiliser nos fonctions de mots continus pour créer une représentation distribuée de nos n-grammes. Au cours de la formation d’un modèle linguistique, nous apprendrons ce mot carte enchâssante. L'espoir est qu'en utilisant une représentation continue, notre intégration mappera des mots similaires à des régions similaires. Par exemple, dans le document phare Représentations distribuées de mots et d'expressions et de leur compositionnalité, observez aux Tableaux 6 et 7 que certaines phrases ont de très bonnes phrases de voisins proches d’un point de vue sémantique. Transformer en cet espace continu nous permet d’utiliser des notions métriques continues de similarité pour évaluer la qualité sémantique de notre intégration.

Explication en utilisant le code Lasagne

Décomposons l'extrait de code Lasagne:

x = T.imatrix()

x est une matrice d'entiers. OK pas de problème. Chaque mot du vocabulaire peut être représenté sous la forme d'un entier ou d'un codage 1-hot sparse. Donc, si x est 2x2, nous avons deux points de données, chacun étant un gramme.

l_in = InputLayer((3, ))

La couche d'entrée. Le 3 représente la taille de notre vocabulaire. Nous avons donc les mots par exemple.$w_0, w_1, w_2$

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

Ceci est notre mot matrice d'intégration. C'est une matrice de 3 lignes par 5 colonnes avec les entrées 0 à 14.

Jusqu'à présent, nous avons l'interprétation suivante. Notre vocabulaire comprend 3 mots et nous intégrerons nos mots dans un espace vectoriel à 5 ​​dimensions. Par exemple, nous pouvons représenter un mot , un autre mot et l'autre mot , par exemple en tant que codages clairsemés à chaud. Nous pouvons voir la matrice comme intégrant ces mots via la multiplication matricielle. Par conséquent, le premier motSimmilarly . $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]$

Il convient de noter que, en raison de l'encodage à une seule couche que nous utilisons, vous voyez également ce que l'on appelle des recherches dans les tables.

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

La couche d'intégration

 output = get_output(l1, x)

Expression symbolique de Theano pour l’intégration.

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

Theano fonction qui calcule l’intégration.

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

Cela vaut la peine de s’arrêter ici pour discuter de ce que signifie exactement x_test. Notez d'abord que toutes les entrées x_test sont dans {0, 1, 2}, c'est-à-dire dans la plage (3). x_test a 2 points de données. Le premier point de données [0, 2] représente le 2 grammes et le deuxième point de données représente le 2 grammes .( w 1 , w 2$(w_0, w_2)$$(w_1, w_2)$

Nous souhaitons intégrer nos 2 grammes à l’aide de notre couche d’incorporation de mots maintenant. Avant de faire cela, assurons-nous que nous savons clairement ce qui doit être renvoyé par notre fonction d'intégration f. Le 2 grammes équivaut à une matrice [[1, 0, 0], [0, 0, 1]]. L'application de notre matrice d'inclusion W à cette matrice clairsemée devrait donner: [[0, 1, 2, 3, 4], [10, 11, 12, 13, 14]]. Remarque Pour que la multiplication de matrice fonctionne, nous devons appliquer le mot matrice d’incorporation via la multiplication de droite à la représentation matricielle éparse de notre gramme.$(w_0, w_2)$$W$

f(x_test) 

résultats:

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

Pour vous convaincre que le 3 représente bien la taille du vocabulaire, essayez de saisir une matrice x_test = [[5, 0], [1, 2]]. Vous verrez qu'il soulève une erreur de correspondance de matrice.

Dans https://stackoverflow.com/questions/45649520/explain- avec-example-how-embedding-layers-in-keras-works/ j'ai essayé de préparer un exemple en utilisant 2 phrases, les textes de keras_to_sequences

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

et couche d'inclusion. Basé sur Comment fonctionne la couche 'Enrobage' de Keras? la couche d’incorporation initialise d’abord le vecteur d’incorporation de manière aléatoire, puis utilise l’optimiseur de réseau pour le mettre à jour de la même manière que pour toute autre couche de réseau de 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]

Ci-dessus se trouve un vecteur d’intégration initial pour une phrase de (maximum) 6 mots et output_dim de 3.