Utilisation d'une incorporation de mots pré-entraînée (word2vec ou Glove) dans TensorFlow

J'ai récemment examiné une implémentation intéressante pour la classification de texte convolutif . Cependant, tout le code TensorFlow que j'ai examiné utilise des vecteurs d'incorporation aléatoires (non pré-entraînés) comme celui-ci:

with tf.device('/cpu:0'), tf.name_scope("embedding"):
    W = tf.Variable(
        tf.random_uniform([vocab_size, embedding_size], -1.0, 1.0),
        name="W")
    self.embedded_chars = tf.nn.embedding_lookup(W, self.input_x)
    self.embedded_chars_expanded = tf.expand_dims(self.embedded_chars, -1)

Est-ce que quelqu'un sait comment utiliser les résultats de Word2vec ou d'une incorporation de mots pré-entraînés GloVe au lieu d'un mot aléatoire?

Il existe plusieurs façons d'utiliser une intégration pré-entraînée dans TensorFlow. Supposons que vous ayez l'incorporation dans un tableau NumPy appelé embedding, avec des vocab_sizelignes et des embedding_dimcolonnes et que vous souhaitiez créer un tenseur Wpouvant être utilisé dans un appel à tf.nn.embedding_lookup().

1. Créez simplement Wcomme un tf.constant()qui prend embeddingsa valeur:

   W = tf.constant(embedding, name="W")

   C'est l'approche la plus simple, mais elle n'est pas efficace en mémoire car la valeur de a tf.constant()est stockée plusieurs fois en mémoire. Puisqu'il embeddingpeut être très volumineux, vous ne devez utiliser cette approche que pour des exemples de jouets.

2. Créez en Wtant que tf.Variableet initialisez-le à partir du tableau NumPy via un tf.placeholder():

   W = tf.Variable(tf.constant(0.0, shape=[vocab_size, embedding_dim]),
                   trainable=False, name="W")
   
   embedding_placeholder = tf.placeholder(tf.float32, [vocab_size, embedding_dim])
   embedding_init = W.assign(embedding_placeholder)
   
   # ...
   sess = tf.Session()
   
   sess.run(embedding_init, feed_dict={embedding_placeholder: embedding})

   Cela évite de stocker une copie de embeddingdans le graphique, mais cela nécessite suffisamment de mémoire pour conserver deux copies de la matrice en mémoire à la fois (une pour le tableau NumPy et une pour le tf.Variable). Notez que j'ai supposé que vous souhaitiez conserver la constante de matrice d'incorporation pendant l'entraînement, donc West créée avec trainable=False.

3. Si l'incorporation a été formée dans le cadre d'un autre modèle TensorFlow, vous pouvez utiliser a tf.train.Saverpour charger la valeur à partir du fichier de point de contrôle de l'autre modèle. Cela signifie que la matrice d'intégration peut contourner complètement Python. Créez Wcomme dans l'option 2, puis procédez comme suit:

   W = tf.Variable(...)
   
   embedding_saver = tf.train.Saver({"name_of_variable_in_other_model": W})
   
   # ...
   sess = tf.Session()
   embedding_saver.restore(sess, "checkpoint_filename.ckpt")

J'utilise cette méthode pour charger et partager l'intégration.

W = tf.get_variable(name="W", shape=embedding.shape, initializer=tf.constant_initializer(embedding), trainable=False)

La réponse de @mrry n'est pas correcte car elle provoque l'écrasement des poids des plongements chaque fois que le réseau est exécuté, donc si vous suivez une approche de minibatch pour former votre réseau, vous écrasez les poids des plongements. Donc, de mon point de vue, la bonne façon de procéder aux incorporations pré-entraînées est:

embeddings = tf.get_variable("embeddings", shape=[dim1, dim2], initializer=tf.constant_initializer(np.array(embeddings_matrix))

Réponse compatible 2.0 : il existe de nombreux intégrations pré-formées, développées par Google et Open Source.

Certains le sont Universal Sentence Encoder (USE), ELMO, BERT, etc. et il est très facile de les réutiliser dans votre code.

Le code pour réutiliser le Pre-Trained Embedding, Universal Sentence Encoderest indiqué ci-dessous:

  !pip install "tensorflow_hub>=0.6.0"
  !pip install "tensorflow>=2.0.0"

  import tensorflow as tf
  import tensorflow_hub as hub

  module_url = "https://tfhub.dev/google/universal-sentence-encoder/4"
  embed = hub.KerasLayer(module_url)
  embeddings = embed(["A long sentence.", "single-word",
                      "http://example.com"])
  print(embeddings.shape)  #(3,128)

Pour plus d'informations sur les Embeddings pré-formés développés et open-source par Google, consultez TF Hub Link .

Avec la version 2 de tensorflow, c'est assez facile si vous utilisez le calque Embedding

X=tf.keras.layers.Embedding(input_dim=vocab_size,
                            output_dim=300,
                            input_length=Length_of_input_sequences,
                            embeddings_initializer=matrix_of_pretrained_weights
                            )(ur_inp)

J'étais également confronté à un problème d'intégration, j'ai donc écrit un tutoriel détaillé avec un jeu de données. Ici, je voudrais ajouter ce que j'ai essayé Vous pouvez également essayer cette méthode,

import tensorflow as tf

tf.reset_default_graph()

input_x=tf.placeholder(tf.int32,shape=[None,None])

#you have to edit shape according to your embedding size


Word_embedding = tf.get_variable(name="W", shape=[400000,100], initializer=tf.constant_initializer(np.array(word_embedding)), trainable=False)
embedding_loopup= tf.nn.embedding_lookup(Word_embedding,input_x)

with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        for ii in final_:
            print(sess.run(embedding_loopup,feed_dict={input_x:[ii]}))

Voici un exemple détaillé du didacticiel Ipython si vous voulez comprendre à partir de zéro, jetez un œil.