Menggunakan penyematan kata terlatih (word2vec atau Glove) di TensorFlow

Saya baru-baru ini meninjau implementasi menarik untuk klasifikasi teks konvolusional . Namun semua kode TensorFlow yang saya tinjau menggunakan vektor penyematan acak (tidak terlatih sebelumnya) seperti berikut:

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)

Adakah yang tahu cara menggunakan hasil Word2vec atau penyematan kata terlatih GloVe daripada yang acak?

Ada beberapa cara untuk menggunakan penyematan terlatih di TensorFlow. Katakanlah Anda memiliki embedding dalam array NumPy yang dipanggil embedding, dengan vocab_sizebaris dan embedding_dimkolom dan Anda ingin membuat tensor Wyang dapat digunakan dalam panggilan ke tf.nn.embedding_lookup().

1. Cukup buat Wsebagai tf.constant()yang mengambil embeddingnilainya:

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

   Ini adalah pendekatan yang paling mudah, tetapi tidak efisien dalam memori karena nilai a tf.constant()disimpan beberapa kali dalam memori. Karena embeddingbisa sangat besar, Anda sebaiknya hanya menggunakan pendekatan ini untuk contoh mainan.

2. Buat Wsebagai tf.Variabledan inisialisasi dari array NumPy melalui 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})

   Hal ini menghindari penyimpanan salinan embeddingdalam grafik, tetapi memerlukan cukup memori untuk menyimpan dua salinan matriks dalam memori sekaligus (satu untuk larik NumPy, dan satu untuk larik tf.Variable). Perhatikan bahwa saya berasumsi bahwa Anda ingin menahan matriks embedding secara konstan selama pelatihan, jadi Wdibuat dengan trainable=False.

3. Jika penyematan dilatih sebagai bagian dari model TensorFlow lain, Anda dapat menggunakan a tf.train.Saveruntuk memuat nilai dari file checkpoint model lain. Ini berarti matriks embedding dapat melewati Python sama sekali. Buat Wseperti pada opsi 2, lalu lakukan hal berikut:

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

Saya menggunakan metode ini untuk memuat dan membagikan penyematan.

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

Jawaban dari @mrry tidak benar karena memicu penimpaan bobot embeddings setiap jaringan dijalankan, jadi jika Anda mengikuti pendekatan minibatch untuk melatih jaringan Anda, Anda menimpa bobot embeddings. Jadi, menurut saya, cara yang benar untuk embeddings terlatih adalah:

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

2.0 Jawaban yang Kompatibel : Ada banyak Embeddings yang Dilatih, yang dikembangkan oleh Google dan telah Bersumber Terbuka.

Beberapa di antaranya adalah Universal Sentence Encoder (USE), ELMO, BERT, dll .. dan sangat mudah untuk digunakan kembali dalam kode Anda.

Kode untuk menggunakan kembali Pre-Trained Embedding, Universal Sentence Encoderditunjukkan di bawah ini:

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

Untuk informasi lebih lanjut tentang Embeddings yang Dilatih yang dikembangkan dan bersumber terbuka oleh Google, lihat TF Hub Link .

Dengan tensorflow versi 2 cukup mudah jika Anda menggunakan lapisan Embedding

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)

Saya juga menghadapi masalah embedding, jadi saya menulis tutorial mendetail dengan dataset. Di sini saya ingin menambahkan apa yang saya coba. Anda juga dapat mencoba metode ini,

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

Berikut ini adalah contoh detail kerja Tutorial Ipython jika Anda ingin memahami dari awal, lihat.