TensorFlow में पूर्व-प्रशिक्षित शब्द एम्बेडिंग (word2vec या Glove) का उपयोग करना

Question

मैंने हाल ही में दृढ़ पाठ वर्गीकरण के लिए एक दिलचस्प कार्यान्वयन की समीक्षा की है । हालाँकि, मैंने जो सभी TensorFlow कोड की समीक्षा की है, वे निम्न की तरह एक यादृच्छिक (पूर्व-प्रशिक्षित नहीं) एम्बेडिंग वैक्टर का उपयोग करते हैं:

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 के परिणामों का उपयोग कैसे करें या एक यादृच्छिक के बजाय एक पूर्व-प्रशिक्षित शब्द GloVe का उपयोग करें?

Answer 1

कुछ तरीके हैं जिनसे आप TensorFlow में पूर्व-प्रशिक्षित एम्बेडिंग का उपयोग कर सकते हैं। मान लें कि आपके पास पंक्तियों और स्तंभों के embeddingसाथ एक NumPy सरणी में एम्बेडिंग है , और आप एक टेंसर बनाना चाहते हैं जिसका उपयोग कॉल में किया जा सकता है ।vocab_sizeembedding_dimWtf.nn.embedding_lookup()

1. सीधे शब्दों में बनाने के Wएक के रूप में tf.constant()है कि लेता है embeddingअपने मूल्य के रूप में:

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

   यह सबसे आसान तरीका है, लेकिन यह मेमोरी कुशल नहीं है क्योंकि a का मान tf.constant()मेमोरी में कई बार जमा होता है। चूंकि embeddingबहुत बड़ी हो सकती है, इसलिए आपको केवल खिलौने के उदाहरण के लिए इस दृष्टिकोण का उपयोग करना चाहिए।

2. Wएक के रूप में बनाएँ tf.Variableऔर इसे एक के माध्यम से NumPy सरणी से प्रारंभ करें 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})
   

   यह embeddingग्राफ़ की एक प्रति संग्रहीत करने से बचता है , लेकिन मैट्रिक्स की दो प्रतियों को एक बार में रखने के लिए पर्याप्त मेमोरी की आवश्यकता होती है (एक NumPy सरणी के लिए, और एक के लिए tf.Variable)। ध्यान दें कि मैंने मान लिया है कि आप प्रशिक्षण के दौरान एम्बेडिंग मैट्रिक्स को स्थिर रखना चाहते हैं, इसलिए Wइसे बनाया गया है trainable=False।

3. यदि एम्बेडिंग को अन्य TensorFlow मॉडल के भाग के रूप में प्रशिक्षित किया गया था, तो आप tf.train.Saverदूसरे मॉडल के चेकपॉइंट फ़ाइल से मान को लोड करने के लिए उपयोग कर सकते हैं । इसका मतलब है कि एम्बेडिंग मैट्रिक्स पूरी तरह से पायथन को बायपास कर सकता है। Wविकल्प 2 में बनाएं , फिर निम्न कार्य करें:

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

Comments

मैं W को निम्नानुसार बनाता हूं: W = np.loadtxt ("/ media / w2vTest.txt", dtype = 'string', delimiter = '') जो पंक्ति के रूप में बनाता है: ['' in '0.070312 ...... '-.0625']। यहाँ समस्याएं हैं! क्या मैं इसे 'W' हटाने के बाद और स्ट्रिंग से फ्लोट 32 तक संख्याओं को परिवर्तित करने के बाद इस पर विचार करूंगा? यदि यह मामला है, तो 'इन' को अपने संबंधित वेक्टर से कैसे कनेक्ट करें? या मुझे आंकड़े को फ्लोट 32 में बदलना होगा और फिर 'इन' के रूप में छोड़ना होगा; उम्मीद है कि टेंसरफ़्लो सभी आवश्यक प्रसंस्करण करेगा? धन्यवाद!

— user3147590

आह, आपके पास यहां कुछ विकल्प हैं। आप टेन्सरफ्लो ऑप का उपयोग टेक्स्ट फाइल को टेंसर में बदलने के लिए कर सकते हैं tf.decode_csv(), लेकिन यह महंगा हो सकता है (विशेष रूप से, इसके लिए आपको Tensorप्रति कॉलम एक बनाना होगा , और फिर न्यूमेरिक को एक साथ जोड़ना होगा)। शायद एक आसान विकल्प का उपयोग करना होगा pandas.read_csv()और pandas.DataFrame.as_matrix()इनपुट को न्यूपी सरणी के रूप में प्राप्त करना होगा ।

— 20

NumPy ऐरे को कॉल करने के बाद इकट्ठा किया गया कचरा होना चाहिए sess.run(embedding_init, ...)(यह मानते हुए कि आप अपने प्रोग्राम में इसका संदर्भ नहीं रखते हैं)। अपने कार्यक्रम की संरचना के आधार पर, आप पहले सरणी को जारी करने के लिए del embedding(जहाँ embeddingNumPy सरणी है) चाहते हो सकता है ।

— mrry

@ स्मृति: आप विकल्प 1 के बारे में अधिक बात कर सकते हैं और अधिक विशेष रूप से "यह स्मृति कुशल नहीं है क्योंकि एक tf.constant () का मान मेमोरी में कई बार संग्रहीत होता है"। GPU या CPU के लिए मेमोरी अक्षम है? अधिक आम तौर पर, tf.constant () के पास मेमोरी में कई प्रतियां क्यों होती हैं, जबकि tf.Variable () + विकल्प 2 के प्लेसहोल्डर को खिलाने में यह समस्या नहीं होती है?

— गेब्रियल पैरेंट

यदि आप यह भी आश्चर्य करते हैं कि क्यों "tf.constant () का मूल्य मेमोरी में कई बार संग्रहीत किया जाता है" तो इस उत्तर पर एक नज़र डालें: stackoverflow.com/a/42450418/5841473

— alyaxey

Answer 2

मैं एम्बेडिंग को लोड करने और साझा करने के लिए इस पद्धति का उपयोग करता हूं।

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

Comments

क्या अंकीकरण मैट्रिक्स में स्तंभ या पंक्तियाँ होना चाहिए?

— ग्रीशॉक

Answer 3

@Mrry का उत्तर सही नहीं है क्योंकि यह प्रत्येक नेटवर्क को चलाए जाने वाले एम्बेडिंग वेट के ओवरराइटिंग को भड़काता है, इसलिए यदि आप अपने नेटवर्क को प्रशिक्षित करने के लिए एक मिनीबैच दृष्टिकोण का पालन कर रहे हैं, तो आप एंबेड्स के वेट को ओवरराइट कर रहे हैं। इसलिए, मेरे दृष्टिकोण पर पूर्व-प्रशिक्षित एम्बेडिंग का सही तरीका है:

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

Comments

लियूजिया के उत्तर की सटीक नकल।

— तिमज़ामैन

@ टिमजमान .. वास्तव में, वह ट्रेन करने योग्य = गलत तर्क को याद कर रहा है, और इस तरह से इस प्रक्रिया में उसके एम्बेडिंग को ठीक कर देगा।

— शतु

इसके अलावा, मुझे लगता है कि यूजेनियो का तर्क गलत है। आपको हर मिनी-बैच के साथ "एम्बेडिंग_इनिट" सेशन चलाने की ज़रूरत नहीं है, और सब कुछ ठीक हो जाएगा। यही है, बस प्रशिक्षण के शुरू में केवल एक बार एम्बेडिंग इनिशियलाइज़ेशन चलाएं।

— शत्रु

@ शटू मैं यह कैसे सुनिश्चित करूं कि प्रशिक्षण की शुरुआत में एम्बेडिंग इनिशियलाइज़ेशन ही चलाया जाए?

@ dust0x .. यदि एम्बेडिंग का आकार काफी छोटा है, तो आप उन्हें प्रारंभिक मूल्य के रूप में निर्दिष्ट कर सकते हैं। यदि वे काफी बड़े हैं, तो जब आप सभी चर के लिए इनिशलाइज़र चलाते हैं, तो आप उन्हें feed_dict में पास कर सकते हैं। मुझे बताएं कि क्या यह पर्याप्त स्पष्ट नहीं है, और मैं दोनों दृष्टिकोणों के लिए कुछ नमूना कोड पोस्ट करने का प्रयास करूंगा।

— शतायु

Answer 4

2.0 संगत जवाब : कई पूर्व-प्रशिक्षित एंबेडेडिंग हैं, जो Google द्वारा विकसित किए गए हैं और जिन्हें ओपन सॉर्ड किया गया है।

उनमें से कुछ हैं Universal Sentence Encoder (USE), ELMO, BERT, आदि .. और उन्हें आपके कोड में पुन: उपयोग करना बहुत आसान है।

कोड का पुन: उपयोग करने के लिए Pre-Trained Embedding, Universal Sentence Encoderनीचे दिखाया गया है:

  !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 द्वारा पूर्व-प्रशिक्षित एंबेडेड विकसित और खुले-खट्टे हैं, TF हब लिंक देखें ।

Answer 5

अगर आप एंबेडिंग लेयर का उपयोग करते हैं तो टेंसोफ़्लो संस्करण 2 इसके काफी आसान है

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)

Answer 6

मैं भी एम्बेडिंग समस्या का सामना कर रहा था, इसलिए मैंने डेटासेट के साथ विस्तृत ट्यूटोरियल लिखा। यहाँ मैं जोड़ना चाहूँगा जो मैंने कोशिश की थी आप इस विधि को भी आजमा सकते हैं,

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

यदि आप स्क्रैच से समझना चाहते हैं, तो एक विस्तृत ट्यूटोरियल इफिथॉन उदाहरण पर काम कर रहे हैं।