Qu'est-ce qu'un Embedding dans Keras ?

Question

La documentation de Keras n'est pas claire sur ce que c'est réellement. Je comprends que nous pouvons l'utiliser pour comprimer l'espace des caractéristiques d'entrée en un espace plus petit. Mais comment cela se fait-il du point de vue de la conception neuronale ? S'agit-il d'un autoenocdeur, d'un RBM ?

Answer 1

Pour autant que je sache, la couche d'incorporation est une simple multiplication matricielle qui transforme les mots en leurs incorporations de mots correspondantes.

Les poids de la couche d'intégration sont de la forme (vocabulary_size, embedding_dimension). Pour chaque échantillon d'apprentissage, ses entrées sont des entiers, qui représentent certains mots. Les entiers sont dans la gamme de la taille du vocabulaire. La couche d'incorporation transforme chaque entier i en la i-ème ligne de la matrice des poids d'incorporation.

Afin d'effectuer rapidement cette multiplication matricielle, les entiers d'entrée ne sont pas stockés sous forme de liste d'entiers mais sous forme de matrice à un coup. Par conséquent, la forme d'entrée est (nb_words, vocabulary_size) avec une valeur non nulle par ligne. Si vous multipliez cela par les poids d'intégration, vous obtenez une sortie de la forme suivante

(nb_words, vocab_size) x (vocab_size, embedding_dim) = (nb_words, embedding_dim)

Ainsi, par une simple multiplication matricielle, vous transformez tous les mots d'un échantillon en mots intégrés correspondants.

Answer 2

Le site Keras Embedding n'effectue pas de multiplication matricielle mais uniquement :

1. crée une matrice de poids de (taille_du_vocabulaire)x(dimension_de_l'intégration) dimensions

2. indexe cette matrice de poids

---

Il est toujours utile de jeter un coup d'œil au code source pour comprendre ce que fait une classe. Dans ce cas, nous allons examiner la classe class Intégration de qui hérite de la couche de base class appelé Couche .

(1) - Création d'une matrice de poids de (taille_du_vocabulaire)x(dimension_de_l'intégration) dimensions :

Cela se produit au build fonction de Intégration de :

def build(self, input_shape):
    self.embeddings = self.add_weight(
        shape=(self.input_dim, self.output_dim),
        initializer=self.embeddings_initializer,
        name='embeddings',
        regularizer=self.embeddings_regularizer,
        constraint=self.embeddings_constraint,
        dtype=self.dtype)
    self.built = True

Si vous jetez un coup d'œil à la classe de base Couche vous verrez que la fonction add_weight ci-dessus crée simplement une matrice de poids entraînables (dans ce cas de (taille_du_vocabulaire)x(dimension_de_l'intégration) dimensions) :

def add_weight(self,
               name,
               shape,
               dtype=None,
               initializer=None,
               regularizer=None,
               trainable=True,
               constraint=None):
    """Adds a weight variable to the layer.
    # Arguments
        name: String, the name for the weight variable.
        shape: The shape tuple of the weight.
        dtype: The dtype of the weight.
        initializer: An Initializer instance (callable).
        regularizer: An optional Regularizer instance.
        trainable: A boolean, whether the weight should
            be trained via backprop or not (assuming
            that the layer itself is also trainable).
        constraint: An optional Constraint instance.
    # Returns
        The created weight variable.
    """
    initializer = initializers.get(initializer)
    if dtype is None:
        dtype = K.floatx()
    weight = K.variable(initializer(shape),
                        dtype=dtype,
                        name=name,
                        constraint=constraint)
    if regularizer is not None:
        with K.name_scope('weight_regularizer'):
            self.add_loss(regularizer(weight))
    if trainable:
        self._trainable_weights.append(weight)
    else:
        self._non_trainable_weights.append(weight)
    return weight

(2) - Indexation de cette matrice de poids

Cela se produit au call fonction de Intégration de :

def call(self, inputs):
    if K.dtype(inputs) != 'int32':
        inputs = K.cast(inputs, 'int32')
    out = K.gather(self.embeddings, inputs)
    return out

Cette fonction renvoie la sortie de la fonction Embedding couche qui est K.gather(self.embeddings, inputs) . Ce que tf.keras.backend.gather fait exactement est d'indexer la matrice des poids self.embeddings (voir build ci-dessus) selon la fonction inputs qui doivent être des listes d'entiers positifs.

Ces listes peuvent être récupérées par exemple si vous passez vos entrées de texte/mots à la fonction one_hot de Keras qui code un texte en une liste d'index de mots de taille n (il ne s'agit PAS d'un codage à chaud - voir également cet exemple pour plus d'informations : https://machinelearningmastery.com/use-word-embedding-layers-deep-learning-keras/ ).

---

Par conséquent, c'est tout. Il n'y a pas de multiplication matricielle.

Au contraire, le site Keras Embedding n'est utile que parce qu'elle évite justement d'effectuer une multiplication matricielle et permet donc d'économiser certaines ressources informatiques.

Sinon, vous pourriez simplement utiliser un Keras Dense (après avoir encodé vos données d'entrée) pour obtenir une matrice de pondérations entraînables (de 1 à 10 %). (taille_du_vocabulaire)x(dimension_de_l'intégration) ) et il suffit ensuite d'effectuer la multiplication pour obtenir la sortie qui sera exactement la même que celle de la méthode Embedding couche.

Answer 3

Pour mieux comprendre une fonction, il est bon de consulter le code source. Voici pour Intégration de Donc, en gros, c'est une table de recherche entraînable.

Answer 4

Dans Keras, le Embedding La couche est PAS une simple couche de multiplication matricielle, mais une couche de table de consultation (voir la fonction d'appel ci-dessous ou l'original définition ).

def call(self, inputs):
    if K.dtype(inputs) != 'int32':
        inputs = K.cast(inputs, 'int32')
    out = K.gather(self.embeddings, inputs)
    return out

Ce qu'il fait, c'est de mettre en correspondance chaque entier connu n sur inputs à un vecteur caractéristique entraînable W[n] dont la dimension est la longueur de la caractéristique intégrée.

Answer 5

En termes simples (du point de vue de la fonctionnalité), il s'agit d'une codeur à un coup y couche entièrement connectée . Les poids des couches sont entraînables.