सीक्वेंस-टू-सीक्वेंस पार्ट 2 मॉडल

सभी को नमस्कार!

अनुवाद का दूसरा भाग, जिसे हमने "डेटा वैज्ञानिक" पाठ्यक्रम की दूसरी धारा के लॉन्च की तैयारी में कुछ हफ़्ते पहले पोस्ट किया था। आगे एक और दिलचस्प सामग्री और एक खुला सबक है।

इस बीच, हम मॉडल के जंगल में आगे बढ़ गए।

तंत्रिका अनुवाद मॉडल

जबकि अनुक्रम-से-अनुक्रम मॉडल का मुख्य भाग tensorflow/tensorflow/python/ops/seq2seq.py से फ़ंक्शंस द्वारा बनाया गया है, हमारे अनुवाद मॉडल में अभी भी कुछ ट्रिक्स models/tutorials/rnn/translate/seq2seq_model.py में उपयोग की जाती हैं। ध्यान देने योग्य है।



सैम्पल सॉफ्टमैक्स और आउटपुट प्रोजेक्शन

जैसा कि ऊपर उल्लेख किया गया है, हम बड़े आउटपुट शब्दकोश के साथ काम करने के लिए सैंपल्ड सॉफ्टमैक्स का उपयोग करना चाहते हैं। इससे डिकोड करने के लिए, आपको आउटपुट के प्रक्षेपण को ट्रैक करना होगा। दोनों सैंपल्ड सॉफ्टमैक्स लॉस और आउटपुट प्रोजेक्शन seq2seq_model.py में निम्न कोड द्वारा उत्पन्न होते हैं।

 if num_samples > 0 and num_samples < self.target_vocab_size: w_t = tf.get_variable("proj_w", [self.target_vocab_size, size], dtype=dtype) w = tf.transpose(w_t) b = tf.get_variable("proj_b", [self.target_vocab_size], dtype=dtype) output_projection = (w, b) def sampled_loss(labels, inputs): labels = tf.reshape(labels, [-1, 1]) # We need to compute the sampled_softmax_loss using 32bit floats to # avoid numerical instabilities. local_w_t = tf.cast(w_t, tf.float32) local_b = tf.cast(b, tf.float32) local_inputs = tf.cast(inputs, tf.float32) return tf.cast( tf.nn.sampled_softmax_loss( weights=local_w_t, biases=local_b, labels=labels, inputs=local_inputs, num_sampled=num_samples, num_classes=self.target_vocab_size), dtype) 

पहले, ध्यान दें कि हम केवल सैंपल सॉफ्टमैक्स बनाते हैं यदि नमूनों की संख्या (डिफ़ॉल्ट रूप से 512) लक्ष्य शब्दकोश आकार से कम है। 512 से छोटे शब्दकोशों के लिए, मानक सॉफ्टमैक्स हानि का उपयोग करना बेहतर है।

फिर, आउटपुट का एक प्रक्षेपण बनाएं। यह एक जोड़ी है जिसमें एक वेट का एक मैट्रिक्स और एक विस्थापन वेक्टर होता है। जब उपयोग किया जाता है, तो rnn सेल आकार के प्रशिक्षण नमूनों की संख्या के आकार के वैक्टर लौटाता है, न कि target_vocab_size द्वारा प्रशिक्षण नमूनों की संख्या। लॉग को पुनर्स्थापित करने के लिए, आपको इसे वेट मैट्रिक्स द्वारा गुणा करना होगा और एक ऑफसेट जोड़ना होगा, जो कि seq2seq_model.py में seq2seq_model.py लाइनों में होता है।

 if output_projection is not None: for b in xrange(len(buckets)): self.outputs[b] = [tf.matmul(output, output_projection[0]) + output_projection[1] for ...] 

बकेटिंग और पैडिंग

सैंपल किए गए सॉफ्टमैक्स के अलावा, हमारे अनुवाद मॉडल में बकेटिंग का भी उपयोग किया गया है , एक ऐसा तरीका जो आपको विभिन्न लंबाई के वाक्यों को कुशलतापूर्वक प्रबंधित करने की अनुमति देता है। शुरू करने के लिए, समस्या की व्याख्या करें। अंग्रेजी से फ्रेंच में अनुवाद करते समय, हमारे प्रवेश द्वार पर अलग-अलग लंबाई के एल 1 के अंग्रेजी वाक्य होते हैं और बाहर निकलने पर अलग-अलग लंबाई के एल 1 के फ्रेंच वाक्य होते हैं। चूंकि अंग्रेजी वाक्य को encoder_inputs रूप में प्रेषित किया encoder_inputs , और फ्रेंच वाक्य को decoder_inputs (जीओ प्रतीक उपसर्ग के साथ) के रूप में प्रदर्शित किया जाता है, इसलिए अंग्रेजी और फ्रेंच वाक्यों की लंबाई के प्रत्येक जोड़े (L1, L + + 1) के लिए seq2seq मॉडल बनाना आवश्यक है। नतीजतन, हमें कई समान उपग्रहों से मिलकर एक विशाल ग्राफ मिलता है। दूसरी ओर, हम विशेष पैड पात्रों के साथ प्रत्येक वाक्य को "पैड" कर सकते हैं। और फिर हमें "पैक" लंबाई के लिए केवल एक seq2seq मॉडल की आवश्यकता है। लेकिन ऐसे मॉडल छोटे वाक्यों में अप्रभावी होंगे - आपको बहुत सारे बेकार PAD वर्णों को एनकोड और डिकोड करना होगा।

लंबाई के प्रत्येक जोड़े के लिए एक ग्राफ बनाने और एक ही लंबाई की स्टफिंग के बीच एक समझौते के रूप में, हम एक निश्चित संख्या में बाल्टियों का उपयोग करते हैं और प्रत्येक वाक्य को समूह की लंबाई तक सामान करते हैं। translate.py हम डिफ़ॉल्ट रूप से निम्नलिखित समूहों का उपयोग करते हैं।

 buckets = [(5, 10), (10, 15), (20, 25), (40, 50)] 

इस प्रकार, यदि 3 टोकन के साथ एक अंग्रेजी वाक्य इनपुट पर आता है, और इसी फ्रांसीसी वाक्य में आउटपुट में 6 टोकन शामिल हैं, तो वे पहले समूह में जाएंगे और एन्कोडर के इनपुट पर लंबाई 5 तक भरे जाएंगे और डिकोडर के इनपुट पर लंबाई 10 होगी। और अगर अंग्रेजी प्रस्ताव में 8 टोकन हैं, और इसी फ्रांसीसी 18 में, वे समूह (10, 15) में नहीं गिरेंगे और समूह (20, 25) में स्थानांतरित हो जाएंगे, अर्थात, अंग्रेजी प्रस्ताव 20 टोकन तक बढ़ जाएगा, और फ्रेंच एक से 25 हो जाएगा।

याद रखें कि डिकोडर इनपुट बनाते समय, हम इनपुट में विशेष GO वर्ण जोड़ते हैं। यह get_batch() में get_batch() फ़ंक्शन में seq2seq_model.py , जो अंग्रेजी वाक्य को भी फ़्लिप करता है। इनपुट के फ़्लिपिंग ने Sutskever et al।, 2014 (pdf) के तंत्रिका अनुवाद मॉडल के परिणामों को बेहतर बनाने में मदद की । अंततः यह पता लगाने के लिए, कल्पना करें कि एक वाक्य है "मैं जाता हूं।" इनपुट पर, टोकन टूट गया ["I", "go", "."] , और आउटपुट में एक वाक्य है "जेई वैस।", टोकन को टूट गया ["Je", "vais", "."] । उन्हें इनपुट एनकोडर [PAD PAD "." "go" "I"] प्रतिनिधित्व के साथ समूह (5, 10) में जोड़ा जाएगा [PAD PAD "." "go" "I"] [PAD PAD "." "go" "I"] और डिकोडर इनपुट [GO "Je" "vais" "." EOS PAD PAD PAD PAD PAD] [GO "Je" "vais" "." EOS PAD PAD PAD PAD PAD] ।

इसे चलाएं

ऊपर वर्णित मॉडल को प्रशिक्षित करने के लिए, आपको एक बड़े एंग्लो-फ्रेंच कोर की आवश्यकता होगी। प्रशिक्षण के लिए, हम WMT'15 वेबसाइट से 10 ^ 9 फ्रेंच-अंग्रेजी कोर का उपयोग करेंगे, और एक ही नमूना के रूप में एक ही साइट से समाचार का परीक्षण करेंगे। अगला आदेश चलने पर दोनों डेटासेट को train_dir में लोड किया जाएगा।

 python translate.py --data_dir [your_data_directory] --train_dir [checkpoints_directory] --en_vocab_size=40000 --fr_vocab_size=40000 

प्रशिक्षण भवन तैयार करने के लिए आपको 18GB हार्ड ड्राइव की जगह और कई घंटों की आवश्यकता होगी। केस data_dir, , डिक्शनरी फाइल्स data_dir, में बनाई गई हैं data_dir, और उसके बाद केस को टोकन करके पूर्णांक पहचानकर्ताओं में बदल दिया जाता है। शब्दकोश के आकार के लिए जिम्मेदार मापदंडों पर ध्यान दें। ऊपर दिए गए उदाहरण में, 40,000 सबसे अधिक इस्तेमाल किए जाने वाले शब्दों के बाहर सभी शब्दों को एक अज्ञात शब्द का प्रतिनिधित्व करने वाले UNK टोकन में बदल दिया जाएगा। इस प्रकार, शब्दकोश के आकार को बदलते समय, बाइनरी टोकन-आईडी द्वारा आवास को फिर से सुधार देगा। डेटा तैयार करने के बाद प्रशिक्षण शुरू होता है।

translate में निर्दिष्ट मूल्य डिफ़ॉल्ट रूप से बहुत अधिक हैं। लंबे समय तक सीखने वाले बड़े मॉडल अच्छे परिणाम दिखाते हैं, लेकिन इसमें बहुत अधिक समय या बहुत अधिक जीपीयू मेमोरी लग सकती है। आप एक छोटे मॉडल वर्कआउट को निर्दिष्ट कर सकते हैं, जैसा कि नीचे दिए गए उदाहरण में है।

 python translate.py --data_dir [your_data_directory] --train_dir [checkpoints_directory] --size=256 --num_layers=2 --steps_per_checkpoint=50 

ऊपर दिए गए आदेश में दो परतों के साथ मॉडल को प्रशिक्षित किया जाएगा (डिफ़ॉल्ट रूप से 3 हैं), जिनमें से प्रत्येक में 256 इकाइयां (डिफ़ॉल्ट - 1024) हैं, प्रत्येक 50 चरणों पर एक चौकी के साथ (डिफ़ॉल्ट - 200)। इन विकल्पों के साथ प्रयोग करके देखें कि आपके GPU के लिए कौन सा आकार मॉडल सही है।

प्रशिक्षण के दौरान, steps_per_checkpoin t बाइनरी के प्रत्येक चरण पिछले चरणों के आंकड़े देंगे। डिफ़ॉल्ट पैरामीटर (आकार 1024 की 3 परतें) के साथ, पहला संदेश इस प्रकार है:

 global step 200 learning rate 0.5000 step-time 1.39 perplexity 1720.62 eval: bucket 0 perplexity 184.97 eval: bucket 1 perplexity 248.81 eval: bucket 2 perplexity 341.64 eval: bucket 3 perplexity 469.04 global step 400 learning rate 0.5000 step-time 1.38 perplexity 379.89 eval: bucket 0 perplexity 151.32 eval: bucket 1 perplexity 190.36 eval: bucket 2 perplexity 227.46 eval: bucket 3 perplexity 238.66 

ध्यान दें कि प्रत्येक चरण में 1.4 सेकंड से थोड़ा कम समय लगता है, प्रशिक्षण नमूने को छोटा करके और प्रत्येक समूह में काम करने वाले नमूने को खराब कर देता है। लगभग 30 हजार चरणों के बाद, हम देखते हैं कि छोटे वाक्यों के समूह (0 और 1) कैसे अस्पष्ट हो जाते हैं। प्रशिक्षण भवन में लगभग 22 मिलियन वाक्य होते हैं, एक पुनरावृत्ति (प्रशिक्षण डेटा का एक रन) 64 की मात्रा में प्रशिक्षण के नमूनों की संख्या के साथ लगभग 340 हजार कदम उठाता है। इस स्तर पर, मॉडल को --decode विकल्प का उपयोग करके अंग्रेजी वाक्यों का फ्रेंच में अनुवाद करने के लिए उपयोग किया जा सकता है।

 python translate.py --decode --data_dir [your_data_directory] --train_dir [checkpoints_directory] Reading model parameters from /tmp/translate.ckpt-340000 > Who is the president of the United States? Qui est le président des États-Unis ? 

आगे क्या है?

ऊपर दिए गए उदाहरण से पता चलता है कि अपना खुद का अंग्रेजी-फ्रेंच अनुवादक अंत-टू-एंड कैसे बनाया जाए। इसे चलाएं और देखें कि मॉडल कैसे काम करता है। गुणवत्ता स्वीकार्य है, लेकिन डिफ़ॉल्ट मापदंडों के साथ एक आदर्श अनुवाद मॉडल प्राप्त नहीं किया जा सकता है। यहाँ कुछ चीजें हैं जिन्हें आप सुधार सकते हैं।

सबसे पहले, हम prim_ tokenization का उपयोग करते हैं, basic_tokenizer में data_utils का मूल कार्य। WMT'15 वेबसाइट पर एक बेहतर टोकन मिल सकता है। यदि आप इसका उपयोग करते हैं और एक बड़ा शब्दकोश, तो आप बेहतर अनुवाद प्राप्त कर सकते हैं।

इसके अलावा, अनुवाद मॉडल के डिफ़ॉल्ट पैरामीटर पूरी तरह से कॉन्फ़िगर नहीं किए गए हैं। आप मॉडल भार के सीखने की गति, क्षीणन, आरंभीकरण को बदलने का प्रयास कर सकते हैं। आप seq2seq_model.py में मानक GradientDescentOptimizer को कुछ और उन्नत जैसे AdagradOptimizer भी बदल सकते हैं। बेहतर परिणाम के लिए प्रयास करें और देखें!

अंत में, ऊपर प्रस्तुत मॉडल का उपयोग न केवल अनुवाद के लिए किया जा सकता है, बल्कि किसी अन्य अनुक्रम-से-अनुक्रम कार्य के लिए भी किया जा सकता है। यहां तक ​​कि अगर आप किसी अनुक्रम को एक पेड़ में बदलना चाहते हैं, उदाहरण के लिए, एक पार्स ट्री उत्पन्न करते हैं, तो यह मॉडल अत्याधुनिक परिणाम उत्पन्न कर सकता है, जैसा कि विनील्स एंड कैसर एट अल, 2014 (पीडीएफ) द्वारा दिखाया गया है। इसलिए आप न केवल एक अनुवादक, बल्कि एक पार्सर, चैट बॉट या किसी भी अन्य प्रोग्राम को भी बना सकते हैं जो आप चाहते हैं। प्रयोग!

वह सब है!

हम यहां आपकी टिप्पणियों और प्रश्नों की प्रतीक्षा कर रहे हैं या हम आपको एक खुले पाठ में उनके शिक्षक से पूछने के लिए आमंत्रित करते हैं।