Usar una inserción de palabras previamente entrenadas (word2vec o Glove) en TensorFlow

Recientemente revisé 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 utilizar los resultados de Word2vec o una incrustación de palabras previamente entrenadas de GloVe en lugar de una incrustación aleatoria?

Hay algunas formas en las que puedes usar una inserción previamente entrenada en TensorFlow. Digamos que tiene la incrustación en una matriz NumPy llamada embedding, con vocab_sizefilas y embedding_dimcolumnas y desea crear un tensor Wque se pueda usar en una llamada a tf.nn.embedding_lookup().

1. Simplemente crea Wcomo un valor tf.constant()que tiene embedding:

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

   Este es el enfoque más fácil, pero no es eficiente en la memoria porque el valor de a tf.constant()se almacena varias veces en la memoria. Dado que embeddingpuede ser muy grande, solo debe usar este enfoque para ejemplos de juguetes.

2. Cree Wcomo a tf.Variablee inicialícelo desde la matriz NumPy a través de 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 embeddingen 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 Wse crea con trainable=False.

3. Si la incorporación se entrenó como parte de otro modelo de TensorFlow, puede usar a tf.train.Saverpara 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 Wcomo 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")
   

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)

La respuesta de @mrry no es correcta porque provoca la sobrescritura de los pesos de las incrustaciones 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 incrustaciones. Entonces, desde mi punto de vista, la forma correcta de realizar incrustaciones previamente entrenadas es:

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

Respuesta compatible con 2.0 : hay muchas incrustaciones previamente entrenadas, que son desarrolladas por Google y que han sido de código abierto.

Algunos de ellos lo son Universal Sentence Encoder (USE), ELMO, BERT, etc. y es muy fácil reutilizarlos en su código.

El código para reutilizar Pre-Trained Embedding, Universal Sentence Encoderse muestra a continuación:

  !pip install "tensorflow_hub>=0.6.0"
  !pip install "tensorflow>=2.0.0"

  import tensorflow as tf
  import tensorflow_hub as hub

  module_url = "https://tfhub.dev/google/universal-sentence-encoder/4"
  embed = hub.KerasLayer(module_url)
  embeddings = embed(["A long sentence.", "single-word",
                      "http://example.com"])
  print(embeddings.shape)  #(3,128)

Para obtener más información sobre las incrustaciones preformadas desarrolladas y de código abierto por Google, consulte TF Hub Link .

Con la versión 2 de tensorflow, es bastante fácil si usa la capa de incrustación

X=tf.keras.layers.Embedding(input_dim=vocab_size,
                            output_dim=300,
                            input_length=Length_of_input_sequences,
                            embeddings_initializer=matrix_of_pretrained_weights
                            )(ur_inp)

También estaba enfrentando un problema de incrustación, así que escribí un tutorial detallado con un 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í hay un ejemplo detallado de trabajo de Tutorial Ipython si desea comprender desde cero, eche un vistazo.