Uso de incrustación de palabras previamente entrenada (word2vec o guante) en TensorFlow

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

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

  1. Simplemente cree W como tf.constant() que toma 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 tf.constant() se almacena varias veces en la memoria. Dado que la embedding puede ser muy grande, solo debe utilizar este enfoque para los ejemplos de juguetes.

  2. Cree W como una tf.Variable 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 la memoria a la vez (una para la matriz NumPy y otra para la 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 entrenó 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 inserció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.restre(sess, "checkpoint_filename.ckpt") 

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) 

La respuesta de @mrry no es correcta porque provoca la sobrescritura de las ponderaciones 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 las ponderaciones de las incrustaciones. Por lo tanto, en mi punto de vista, la forma correcta de realizar empotramientos pre-entrenados es:

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

También me enfrenté a 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 el ejemplo del Tutorial Ipython detallado, si quiere entenderlo desde cero, eche un vistazo.