web-dev-qa-db-fra.com

Utilisation d'une incorporation de Word pré-formée (Word2vec ou Glove) dans TensorFlow

J'ai récemment passé en revue une implémentation intéressante pour classification convolutionnelle du texte . Cependant, tout le code TensorFlow que j'ai examiné utilise un vecteur d'incorporation aléatoire (non pré-formé), comme suit:

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 Word pré-entraînée par GloVe à la place d'un résultat aléatoire?

pythonnumpytensorflowdeep-learning
86
user3147590

Vous pouvez utiliser une intégration pré-formée dans TensorFlow de plusieurs manières. Supposons que vous avez incorporé dans un tableau NumPy appelé embedding, avec _vocab_size_ lignes et _embedding_dim_ colonnes et que vous voulez créer un tenseur W pouvant être utilisé dans un appel à tf.nn.embedding_lookup() .

  1. Créez simplement W en tant que tf.constant() qui prend embedding en tant que valeur:

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

    Cette approche est la plus simple, mais elle n’est pas efficace en mémoire car la valeur de tf.constant() est stockée plusieurs fois en mémoire. Puisque embedding peut être très volumineux, vous ne devriez utiliser cette approche que pour des exemples de jouets.

  2. Créez W sous la forme d'un _tf.Variable_ et 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 embedding dans le graphique, mais nécessite assez de mémoire pour conserver deux copies de la matrice en même temps (une pour le tableau NumPy et une pour le _tf.Variable_). Notez que je suppose que vous souhaitez conserver la matrice d’incorporation constante pendant l’entraînement. W est donc créé avec _trainable=False_.

  3. Si l'intégration a été formée dans le cadre d'un autre modèle TensorFlow, vous pouvez utiliser un tf.train.Saver pour 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 Python. Créez W comme 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")
_
124
mrry

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

La réponse de @mrry n’est pas correcte car elle provoque l’écrasement des poids des embeddings chaque fois que le réseau est exécuté. Ainsi, si vous suivez une approche par minibatch pour former votre réseau, vous écrasez les poids des embeddings. Donc, de mon point de vue, la bonne façon de procéder à des intégrations pré-formées est la suivante:

embeddings = tf.get_variable("embeddings", shape=[dim1, dim2], initializer=tf.constant_initializer(np.array(embeddings_matrix))
5
Eugenio Martínez Cámara

Je faisais également face à un problème d'intégration, j'ai donc écrit un tutoriel détaillé avec dataset. Ici, j'aimerais ajouter ce que j'ai essayé. Vous pouvez aussi 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 le didacticiel détaillé exemple Ipython si vous voulez comprendre à partir de zéro, jetez un oeil.

2
Aaditya Ura