Uso de una incrustación de palabras preentrenada (word2vec o Glove) en TensorFlow

Question

Uso de una incrustación de palabras preentrenada (word2vec o Glove) en TensorFlow

Recientemente he revisado una implementación interesante para convolutional text classification. Sin embargo, todo el código de TensorFlow que he revisado utiliza vectores de incrustación aleatorios (no preentrenados) como los siguientes:

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)

¿Alguien sabe cómo utilizar los resultados de Word2vec o un guante de incrustación de palabras pre-entrenados en lugar de uno al azar?

77

python numpy deep-learning tensorflow

Author: mrry, 2016-02-28

Source

4 answers

Uso este método para cargar y compartir incrustaciones.

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

29

Author: LiuJia,
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/ajaxhispano.com/template/agent.layouts/content.php on line 61
2017-10-31 12:58:50

La respuesta de @mrry no es correcta porque provoca la sobreescritura de los pesos de embeddings cada vez que se ejecuta la red, por lo que si está siguiendo un enfoque de minibatch para entrenar su red, está sobreescribiendo los pesos de los embeddings. Por lo tanto, en mi punto de vista, la forma correcta de incrustaciones pre-entrenadas es:

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

6

Author: Eugenio Martínez Cámara,
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/ajaxhispano.com/template/agent.layouts/content.php on line 61
2016-10-24 09:25:01

También me enfrentaba a un problema de incrustación, así que escribí un tutorial detallado con un conjunto de datos. Aquí me gustaría añadir lo que he intentado También puede probar este método,

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

Aquí está trabajando tutorial detallado Ejemplo de Ipython si quieres entender desde cero , echa un vistazo .

2

Author: Ayodhyankit Paul,
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/ajaxhispano.com/template/agent.layouts/content.php on line 61
2018-07-22 10:19:31

score 118 · Accepted Answer

Hay algunas maneras en las que puede usar una incrustación preentrenada en TensorFlow. Digamos que tiene la incrustación en una matriz NumPy llamada embedding, con vocab_size filas y embedding_dim columnas y desea crear un tensor W que se puede usar en una llamada a tf.nn.embedding_lookup().

Simplemente crea W como un tf.constant() que toma embedding como su valor:
```
W = tf.constant(embedding, name="W")
```
Este es el enfoque más fácil, pero no es eficiente en memoria porque el valor de un tf.constant() se almacena varias veces en la memoria. Dado que embedding puede ser muy grande, solo debe usar este enfoque para ejemplos de juguetes.
Crear W como un tf.Variable e inicializarlo desde la matriz NumPy a través de 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})
```
Esto evita almacenar una copia de embedding en el gráfico, pero requiere suficiente memoria para mantener dos copias de la matriz en memoria a la vez (una para la matriz NumPy y otra para la tf.Variable). Tenga en cuenta que he asumido que desea mantener la matriz de incrustación constante durante el entrenamiento, por lo que W se crea con trainable=False.
Si la incrustación se entrenó como parte de otro modelo TensorFlow, puede usar un tf.train.Saver para cargar el valor del archivo checkpoint del otro modelo. Esto significa que la matriz de incrustación puede omitir Python por completo. Cree W como en la opción 2, luego haga lo siguiente:
```
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")
```