TensorFlow'da önceden eğitilmiş bir kelime yerleştirme (word2vec veya Glove) kullanma

Yakın zamanda evrişimli metin sınıflandırması için ilginç bir uygulamayı gözden geçirdim . Ancak incelediğim tüm TensorFlow kodu, aşağıdakiler gibi rastgele (önceden eğitilmemiş) gömme vektörleri kullanıyor:

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)

Word2vec veya GloVe önceden eğitilmiş bir kelime yerleştirmenin rastgele yerine nasıl kullanılacağını bilen var mı?

TensorFlow'da önceden eğitilmiş bir yerleştirmeyi kullanmanın birkaç yolu vardır. Diyelim ki, satırlar ve sütunlar embeddingile adlandırılan bir NumPy dizisinde gömme var ve bir çağrıda kullanılabilecek bir tensör oluşturmak istiyorsunuz .vocab_sizeembedding_dimWtf.nn.embedding_lookup()

1. Basitçe değerini alan Wbir yaratın :tf.constant()embedding

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

   Bu en kolay yaklaşımdır, ancak bellek açısından verimli değildir çünkü a'nın değeri tf.constant()bellekte birden çok kez depolanır. Yana embeddingçok büyük olabilir, sadece oyuncak örnekler için bu yaklaşımı kullanmalıdır.

2. WBir olarak oluşturun tf.Variableve onu NumPy dizisinden a 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})
   

   Bu embedding, grafiğin bir kopyasını depolamaktan kaçınır , ancak matrisin iki kopyasını aynı anda bellekte tutmak için yeterli bellek gerektirir (biri NumPy dizisi için ve biri için tf.Variable). Eğitim sırasında gömme matrisini sabit tutmak istediğinizi varsaydığımı unutmayın, bu yüzden Wile oluşturulur trainable=False.

3. Gömme başka bir TensorFlow modelinin parçası olarak eğitildiyse tf.train.Saver, değeri diğer modelin denetim noktası dosyasından yüklemek için a kullanabilirsiniz . Bu, gömme matrisinin Python'u tamamen atlayabileceği anlamına gelir. W2. seçenekteki gibi oluşturun , ardından aşağıdakileri yapın:

   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")
   

Bu yöntemi yerleştirmeyi yüklemek ve paylaşmak için kullanıyorum.

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

@Mrry'nin cevabı doğru değil çünkü ağın çalıştırıldığı her bir ağda yapılan düğün ağırlıklarının üzerine yazılmasına neden oluyor, bu nedenle ağınızı eğitmek için bir mini parti yaklaşımı izliyorsanız, düğünlerin ağırlıklarının üzerine yazıyorsunuz. Öyleyse, benim görüşüme göre, önceden eğitilmiş düğünlere giden doğru yol:

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

2.0 Uyumlu Cevap : Google tarafından geliştirilen ve Açık Kaynaklı birçok Ön Eğitimli Gömme vardır.

Onlardan bazıları Universal Sentence Encoder (USE), ELMO, BERT vs .. ve bunları kodunuzda yeniden kullanmak çok kolaydır.

Yeniden Kod Pre-Trained Embedding, Universal Sentence Encoderaşağıda gösterilmiştir:

  !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)

Google tarafından geliştirilmiş ve açık kaynaklı Ön Eğitimli Gömme hakkında daha fazla bilgi için TF Hub Bağlantısına bakın .

Tensorflow sürüm 2 ile Gömme katmanını kullanırsanız oldukça kolaydır

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)

Ben de gömme sorunuyla karşı karşıyaydım, bu yüzden veri kümesiyle ayrıntılı eğitim yazdım. Burada denediğimi eklemek istiyorum Bu yöntemi de deneyebilirsiniz,

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

Burada ayrıntılı Eğitim Ipython örneği çalışıyoruz , sıfırdan anlamak istiyorsanız bir göz atın.