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

Question

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

J'ai récemment passé en revue une implémentation intéressante pour convolutional text classification . Cependant, tout le code TensorFlow que j'ai examiné utilise un vecteur d'intégration 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'un gant pré-formé word embedding au lieu d'un aléatoire?

77

deep-learning numpy python tensorflow

demandé sur mrry 2016-02-28 23:11:43

4 réponses

score 118 · Answer 1

Il existe plusieurs façons d'utiliser une intégration pré-formée dans TensorFlow. Disons que vous avez l'intégration dans un tableau NumPy appelé embedding, avec vocab_size lignes et embedding_dim colonnes et que vous souhaitez créer un tenseur W, ce qui peut être utilisé dans un appel à tf.nn.embedding_lookup().

Créez simplement W en tant que tf.constant() cela prend embedding comme 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 d'un tf.constant() est stockée plusieurs fois dans la mémoire. Puisque embedding peut être très grand, vous ne devriez utiliser cette approche que pour les exemples de jouets.
Créez W en tant que 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 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 voulez tenir la matrice d'intégration constante pendant l'entraînement, donc W est créé avec trainable=False.
Si l'intégration a été formée dans le cadre d'un autre modèle TensorFlow, vous pouvez utiliser 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 complètement 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")
```

score 29 · Answer 2

J'utilise cette méthode pour charger et partager leur incorporation.

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

score 6 · Answer 3

La réponse de @ mrry n'est pas correcte car elle provoque l'écrasement des poids d'intégration chaque réseau est exécuté, donc si vous suivez une approche minibatch pour former votre réseau, vous écrasez les poids des intégrations. Donc, de mon point de vue, la bonne façon d'intégrer pré-formés est:

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

score 2 · Answer 4

J'étais également confronté à un problème d'intégration, alors j'ai écrit un tutoriel détaillé avec dataset. 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 tutoriel détaillé Exemple Ipython Si vous voulez comprendre à partir de zéro , jetez un oeil .

Las etiquetas más populares

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

4 réponses