python - started - tensorflow tutorial español

Uso de una inserción de palabras previamente entrenada(word2vec o Glove) en TensorFlow

Question

Recientemente he revisado una implementación interesante para la clasificación de texto convolucional . Sin embargo, todo el código TensorFlow que he revisado utiliza vectores de incrustación aleatorios (no pre-entrenados) 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 usar los resultados de Word2vec o una incrustación de palabras pre-entrenadas GloVe en lugar de una aleatoria?

Answer 1

Hay algunas maneras en que puede usar una incrustación pre-entrenada en TensorFlow. Supongamos que tiene la incrustación en una matriz NumPy llamada embedding , con filas vocab_size y columnas embedding_dim y desea crear un tensor W que pueda usarse en una llamada a tf.nn.embedding_lookup() .

1. Simplemente cree W como tf.constant() que tome la 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 la embedding puede ser muy grande, solo debe usar este enfoque para ejemplos de juguetes.

2. Cree W como tf.Variable e tf.Variable desde la matriz NumPy mediante 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 la memoria a la vez (una para la matriz NumPy y otra para el tf.Variable ). Tenga en cuenta que asumí que desea mantener constante la matriz de incrustación durante el entrenamiento, por lo que W se crea con trainable=False .

3. Si la incrustación se formó como parte de otro modelo TensorFlow, puede usar un tf.train.Saver para cargar el valor del archivo de punto de control 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")

Answer 2

La respuesta de @mrry no es correcta porque provoca la sobrescritura de los pesos de inserción cada vez que se ejecuta la red, por lo que si está siguiendo un enfoque de minibatch para entrenar su red, está sobrescribiendo los pesos de las incorporaciones. Entonces, desde 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))

Answer 3

También estaba enfrentando un problema de incrustación, así que escribí un tutorial detallado con el conjunto de datos. Aquí me gustaría agregar lo que probé. También puedes 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 un ejemplo detallado de Tutorial Ipython si desea comprender desde cero, eche un vistazo.

Answer 4

Utilizo este método para cargar y compartir incrustaciones.

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