💞 ✊🏽 🏴 Tensorflow में seq2seq मॉडल को लागू करना ↕️ 🕺🏼 👷

आवर्ती तंत्रिका नेटवर्क का उपयोग करने वाली डेटा पीढ़ी एक तेजी से लोकप्रिय तरीका बनती जा रही है और कंप्यूटर विज्ञान के कई क्षेत्रों में इसका उपयोग किया जा रहा है। 2014 में seq2seq अवधारणा के जन्म की शुरुआत के बाद से, केवल पांच साल बीत चुके हैं, लेकिन दुनिया ने कई अनुप्रयोगों को देखा है, अनुवाद और भाषण मान्यता के क्लासिक मॉडल के साथ शुरू, और तस्वीरों में वस्तुओं के विवरण की पीढ़ी के साथ समाप्त होता है।

दूसरी ओर, समय के साथ, Google द्वारा विशेष रूप से तंत्रिका नेटवर्क के विकास के लिए जारी किए गए टेंसोरफ्लो लाइब्रेरी ने लोकप्रियता हासिल की। स्वाभाविक रूप से, Google डेवलपर्स seq2seq के रूप में इस तरह के एक लोकप्रिय प्रतिमान को नजरअंदाज नहीं कर सकते थे, इसलिए टेंसोरफ्लो लाइब्रेरी इस प्रतिमान के भीतर विकास के लिए कक्षाएं प्रदान करता है। यह लेख इस वर्ग प्रणाली का वर्णन करता है।

आवर्तक नेटवर्क

वर्तमान में, आवर्तक नेटवर्क गहरे तंत्रिका नेटवर्क के निर्माण के लिए सबसे प्रसिद्ध और व्यावहारिक औपचारिकताओं में से एक हैं। पुनरावर्ती नेटवर्क को सीरियल डेटा को संसाधित करने के लिए डिज़ाइन किया गया है, इसलिए, एक सामान्य सेल (न्यूरॉन) के विपरीत, जो इनपुट के रूप में डेटा प्राप्त करता है और गणना के परिणाम को आउटपुट करता है, एक पुनरावर्ती सेल में दो इनपुट और दो आउटपुट होते हैं।

इनपुट में से एक अनुक्रम के वर्तमान तत्व के डेटा का प्रतिनिधित्व करता है, और दूसरा इनपुट राज्य कहा जाता है और अनुक्रम के पिछले तत्व पर सेल गणना के परिणाम के रूप में प्रेषित होता है।

आंकड़ा सेल ए दिखाता है, जिसके लिए एक अनुक्रम तत्व का डेटा इनपुट है $x_t$ साथ ही साथ यहां पर भी संकेत नहीं दिया गया है $s_ {t-1}$ । आउटपुट पर, सेल ए राज्य देता है $s_t$ और गणना का परिणाम है $h_t$ ।

व्यवहार में, डेटा अनुक्रम को आमतौर पर एक निश्चित निश्चित लंबाई के बाद में विभाजित किया जाता है और पूरे उप-समूह (बैच) द्वारा गणना में पारित किया जाता है। दूसरे शब्दों में, इसके बाद के संस्करण सीखने के लिए उदाहरण हैं। एक पुनरावर्ती नेटवर्क के इनपुट, आउटपुट और सेल स्टेट्स वास्तविक संख्याओं के अनुक्रम हैं। इनपुट गणना के लिए $x_1$ आपको एक राज्य का उपयोग करना चाहिए जो किसी दिए गए डेटा अनुक्रम पर गणना का परिणाम नहीं था। ऐसे राज्यों को प्रारंभिक राज्य कहा जाता है। यदि अनुक्रम काफी लंबा है, तो यह प्रत्येक अनुवर्ती पर गणना के संदर्भ को बनाए रखने के लिए समझ में आता है। इस मामले में, पिछले राज्य में अंतिम गणना की गई अवस्था को प्रारंभिक अवस्था के रूप में प्रसारित करना संभव है। यदि अनुक्रम इतना लंबा नहीं है या इसके बाद का पहला खंड है, तो आप प्रारंभिक स्थिति को शून्य के साथ शुरू कर सकते हैं।

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

एक पुनरावर्ती नेटवर्क के मामले में, हमारे पास कई विकल्प हैं जिन पर त्रुटि पर विचार करने के लिए आउटपुट होता है। हम यहाँ दो मुख्य का वर्णन करेंगे:

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

एक नियमित रूप से पूरी तरह से जुड़े तंत्रिका नेटवर्क के विपरीत, एक पुनरावर्ती नेटवर्क इस अर्थ में गहरा है कि त्रुटि न केवल नेटवर्क के आउटपुट से इसके वजन तक, बल्कि बाईं ओर भी राज्यों के बीच कनेक्शन के माध्यम से प्रचारित करती है। नेटवर्क की गहराई इस प्रकार बाद की लंबाई से निर्धारित होती है। पुनरावर्ती नेटवर्क की स्थिति के माध्यम से त्रुटि का प्रचार करने के लिए, एक विशेष एल्गोरिथ्म है । इसकी विशेषता यह है कि वजन के ग्रेडिएंट एक दूसरे के साथ गुणा करते हैं, जब त्रुटि दाएं से बाएं ओर फैलती है। यदि प्रारंभिक त्रुटि एकता से अधिक है, तो इसके परिणामस्वरूप त्रुटि बहुत बड़ी हो सकती है। इसके विपरीत, यदि प्रारंभिक त्रुटि एकता से कम है, तो कहीं न कहीं अनुक्रम की शुरुआत में त्रुटि दूर हो सकती है। तंत्रिका नेटवर्क के सिद्धांत में इस स्थिति को मानक त्रुटि का हिंडोला कहा जाता है। प्रशिक्षण के दौरान ऐसी स्थितियों से बचने के लिए, विशेष कोशिकाओं का आविष्कार किया गया था जिनमें ऐसी कमियां नहीं हैं। पहले ऐसी सेल LSTM थी , अब विकल्पों की एक विस्तृत श्रृंखला है, जिनमें से सबसे लोकप्रिय GRU है ।

पुनरावृत्ति नेटवर्क का एक अच्छा परिचय इस लेख में पाया जा सकता है। एक अन्य प्रसिद्ध स्रोत एंड्री करपाटी के ब्लॉग का एक लेख है।

Tensorflow लाइब्रेरी में पुनरावर्ती नेटवर्क को लागू करने के लिए कई वर्ग और कार्य हैं। यहाँ GRU प्रकार के सेल पर आधारित एक गतिशील पुनरावर्ती नेटवर्क बनाने का एक उदाहरण दिया गया है:

cell = tf.contrib.rnn.GRUCell(dimension) outputs, state = tf.nn.dynamic_rnn(cell, input, sequence_length=input_length, dtype=tf.float32)

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

एक गतिशील पुनरावर्ती नेटवर्क एक स्थिर से भिन्न होता है जिसमें यह अग्रिम में बाद के लिए नेटवर्क कोशिकाओं का एक नेटवर्क नहीं बनाता है (गणना ग्राफ निर्धारित करने के चरण में), लेकिन इनपुट डेटा पर ग्राफ की गणना के दौरान गतिशील रूप से इनपुट पर कोशिकाओं को लॉन्च करता है। इसलिए, इस फ़ंक्शन को सही समय पर रोकने के लिए इनपुट डेटा के बाद की लंबाई जानने की आवश्यकता है।

पुनरावृत्ति नेटवर्क पर आधारित मॉडल बनाना

पुनरावृत्ति नेटवर्क उत्पन्न करना

पहले, हमने पुनरावर्ती नेटवर्क की त्रुटियों की गणना के लिए दो तरीकों पर विचार किया: अंतिम आउटपुट पर या किसी दिए गए अनुक्रम के लिए सभी आउटपुट पर। यहां हम अनुक्रम बनाने की समस्या पर विचार करते हैं। जनरेटर नेटवर्क प्रशिक्षण उपरोक्त की दूसरी विधि पर आधारित है।

अधिक विस्तार से, हम एक अनुक्रम के अगले तत्व की भविष्यवाणी करने के लिए एक पुनरावर्ती नेटवर्क को प्रशिक्षित करने की कोशिश कर रहे हैं। जैसा कि ऊपर उल्लेख किया गया है, एक पुनरावर्ती नेटवर्क में एक सेल का उत्पादन केवल संख्याओं का एक क्रम है। यह वेक्टर सीखने के लिए बहुत सुविधाजनक नहीं है, इसलिए, वे एक और स्तर पेश करते हैं, जो इनपुट पर इस वेक्टर को प्राप्त करता है, और आउटपुट में भविष्यवाणियों का वजन देता है। इस स्तर को प्रक्षेपण स्तर कहा जाता है और आपको लेबल के डेटा में अपेक्षित आउटपुट के साथ अनुक्रम के दिए गए तत्व पर सेल के आउटपुट की तुलना करने की अनुमति मिलती है।

वर्णन करने के लिए, पाठ को उत्पन्न करने के कार्य पर विचार करें जिसे वर्णों के अनुक्रम के रूप में दर्शाया गया है। प्रक्षेपण स्तर के आउटपुट वेक्टर की लंबाई स्रोत पाठ की वर्णमाला के आकार के बराबर है। वर्णमाला का आकार आमतौर पर 150 वर्णों से अधिक नहीं होता है, यदि आप रूसी और अंग्रेजी भाषाओं के वर्णों की गणना करते हैं, साथ ही साथ विराम चिह्न भी। प्रक्षेपण स्तर का आउटपुट वर्णमाला की लंबाई के साथ एक वेक्टर है, जहां प्रत्येक प्रतीक इस वेक्टर में एक निश्चित स्थिति से मेल खाता है - इस प्रतीक का सूचकांक। लेबल किए गए डेटा भी शून्य से मिलकर एक वेक्टर है, जहां एक अनुक्रम के बाद चरित्र की स्थिति में खड़ा होता है।

प्रशिक्षण के लिए, हम दो डेटा अनुक्रमों का उपयोग करते हैं:

स्रोत पाठ में वर्णों का एक क्रम, जिसके आरंभ में एक विशेष वर्ण जोड़ा जाता है जो स्रोत पाठ का हिस्सा नहीं है। इसे आमतौर पर गो के रूप में जाना जाता है।
स्रोत पाठ के पात्रों का क्रम, बिना परिवर्धन के है।

पाठ के लिए उदाहरण "माँ ने फ्रेम को धोया":

 ['<go>', '', '', ', '', ' ', '', '', '', '', ' ', '', '', '', ''] ['', '', ', '', ' ', '', '', '', '', ' ', '', '', '', '']

प्रशिक्षण के लिए, छोटी-छोटी संख्याओं से मिलकर आमतौर पर मिनीबैच बनते हैं। हमारे मामले में, ये तार हैं जो अलग-अलग लंबाई के हो सकते हैं। नीचे वर्णित कोड विभिन्न लंबाई की समस्या को हल करने के लिए निम्नलिखित विधि का उपयोग करता है। इस मिनीपैक में कई लाइनों में से, अधिकतम लंबाई की गणना की जाती है। अन्य सभी लाइनें एक विशेष चरित्र (पैडिंग) से भरी हुई हैं ताकि मिनीपैक में सभी उदाहरण समान लंबाई के हों। नीचे दिए गए कोड नमूने में, पैड स्ट्रिंग का उपयोग ऐसे चरित्र के रूप में किया जाता है। इसके अलावा, बेहतर पीढ़ी के लिए, उदाहरण के अंत में, वाक्य प्रतीक का अंत जोड़ें - eos । इस प्रकार, वास्तव में, उदाहरण से डेटा थोड़ा अलग दिखाई देगा:

 ['<go>', '', '', ', '', ' ', '', '', '', '', ' ', '', '', '', '', '<eos>', '<pad>', '<pad>', '<pad>'] ['', '', ', '', ' ', '', '', '', '', ' ', '', '', '', '', '<eos>', '<pad>', '<pad>', '<pad>', '<pad>']

पहला अनुक्रम नेटवर्क इनपुट को खिलाया जाता है, और दूसरे अनुक्रम को टैग किए गए डेटा के रूप में उपयोग किया जाता है। भविष्यवाणी प्रशिक्षण मूल अनुक्रम को एक वर्ण को बाईं ओर स्थानांतरित करने पर आधारित है।

प्रशिक्षण और स्पॉनिंग

ट्रेनिंग

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

स्पष्टता के लिए, हम कुछ संकेतन प्रस्तुत करते हैं। प्रतीक_ द्वारा हम प्रतीक के पहचानकर्ता (वर्णमाला में इसका क्रमांक) को निरूपित करेंगे। यहाँ प्रतीक शब्द बल्कि मनमाना है और इसका अर्थ है वर्णमाला का एक तत्व। वर्णमाला में प्रतीक नहीं हो सकते हैं, लेकिन शब्द या विशेषताओं के कुछ और जटिल सेट भी हो सकते हैं। शब्द__बेडिंग का उपयोग वर्णमाला के दिए गए तत्व के अनुरूप संख्याओं के वेक्टर को दर्शाने के लिए किया जाएगा। आमतौर पर, संख्याओं के ऐसे सेट एक आकार तालिका में संग्रहीत किए जाते हैं जो वर्णमाला के आकार से मेल खाते हैं।

Tensorflow एक सुविधा प्रदान करता है जो आपको एम्बेडिंग तालिका तक पहुंचने और चरित्र सूचकांकों को उनके एम्बेडिंग वैक्टर से बदलने की अनुमति देता है। सबसे पहले, हम तालिका को संग्रहीत करने के लिए एक चर को परिभाषित करते हैं:

 embedding_table = tf.Variable(tf.random_uniform([alphabet_size, embedding_size]))

उसके बाद, आप इनपुट टेनर्स को एम्बेड करने वाले टेंसरों में बदल सकते हैं:

 input_embeddings = tf.nn.embedding_lookup(embedding_table, input_ids)

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

पीढ़ी

गणना करने के लिए, एक पुनरावर्ती नेटवर्क के एक सेल को एक राज्य और वर्तमान चरित्र की आवश्यकता होती है। गणना का परिणाम एक निकास और एक नई स्थिति है। यदि हम प्रक्षेपण स्तर को आउटपुट पर लागू करते हैं, तो हम वजन का एक वेक्टर प्राप्त कर सकते हैं, जहां इसी स्थिति में वजन (बहुत सशर्त) माना जा सकता है क्योंकि इस प्रतीक की संभावना अनुक्रम में अगली स्थिति में दिखाई देती है।

प्रक्षेपण स्तर द्वारा उत्पन्न वजन वेक्टर के आधार पर अगले प्रतीक का चयन करने के लिए विभिन्न रणनीतियों का उपयोग किया जा सकता है:

लालची खोज की रणनीति। हर बार हम सबसे अधिक वजन वाले प्रतीक का चयन करते हैं, अर्थात। इस स्थिति में सबसे अधिक संभावना है, लेकिन जरूरी नहीं कि पूरे अनुक्रम के संदर्भ में सबसे उपयुक्त हो।
सर्वश्रेष्ठ अनुक्रम (बीम खोज) चुनने की रणनीति। हम एक बार में एक प्रतीक का चयन नहीं करते हैं, लेकिन सबसे संभावित प्रतीकों के कई रूपों को याद करते हैं। उत्पन्न अनुक्रम के सभी तत्वों के लिए ऐसे सभी विकल्पों की गणना करने के बाद, हम वर्णों के सबसे संभावित अनुक्रम का चयन करते हैं, पूरे अनुक्रम के संदर्भ को ध्यान में रखते हैं। आमतौर पर, यह एक मैट्रिक्स के माध्यम से महसूस किया जाता है, जिसकी चौड़ाई अनुक्रम की लंबाई के बराबर होती है, और जनरेट करने वाले वर्णों की संख्या की ऊंचाई (बीम खोज चौड़ाई)। अनुक्रम वेरिएंट की पीढ़ी के पूरा होने के बाद, सबसे संभावित अनुक्रम का चयन करने के लिए विटर्बी एल्गोरिथ्म के वेरिएंट में से एक का उपयोग किया जाता है।

Tensorflow पुस्तकालय seq2seq प्रकार प्रणाली

उपरोक्त को देखते हुए, यह स्पष्ट है कि पुनरावृत्ति नेटवर्क के आधार पर जेनरिक मॉडल का कार्यान्वयन कोडिंग के लिए एक कठिन काम है। इसलिए, स्वाभाविक रूप से, इस समस्या के समाधान की सुविधा के लिए वर्ग प्रणालियों का प्रस्ताव किया गया था। इन प्रणालियों में से एक को seq2seq कहा जाता है, फिर हम इसके मुख्य प्रकारों की कार्यक्षमता का वर्णन करते हैं।

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

वास्तव में, Tensorflow में seq2seq का कार्यान्वयन एनकोडर को प्रभावित किए बिना, डिकोडर भाग के अंतर्गत आता है। इसलिए, 2seq पुस्तकालय को कॉल करना सही होगा, लेकिन परंपरा की ताकत और यहां सोचने की जड़ता स्पष्ट रूप से सामान्य ज्ञान पर हावी है।

Seq2seq लाइब्रेरी में दो मुख्य मेटाटाइप हैं:

सहायक वर्ग।
कक्षा विकोडक ।

पुस्तकालय डेवलपर्स ने निम्नलिखित विचारों के आधार पर इन प्रकारों की पहचान की। आइए हम सीखने की प्रक्रिया और पीढ़ी की प्रक्रिया पर विचार करें, जिसे हमने थोड़ा अलग कोण से ऊपर वर्णित किया है।

प्रशिक्षण के लिए आपको चाहिए:

प्रत्येक चरित्र के लिए, वर्तमान स्थिति की गणना और वर्तमान चरित्र के एम्बेडिंग पर पास करें।
आउटपुट के लिए गणना की गई स्थिति और प्रक्षेपण याद रखें।
अनुक्रम में अगला चरित्र प्राप्त करें और चरण 1 पर जाएं।

उसके बाद, आप अनुक्रम के निम्नलिखित पात्रों के साथ गणना के परिणामों की तुलना करके त्रुटियों को गिनना शुरू कर सकते हैं।

इसे उत्पन्न करने के लिए आवश्यक है:

प्रत्येक चरित्र के लिए, वर्तमान स्थिति की गणना और वर्तमान चरित्र के एम्बेडिंग पर पास करें।
आउटपुट के लिए गणना की गई स्थिति और प्रक्षेपण याद रखें।
अगले वर्ण को प्रक्षेपण स्तर सूचकांकों की अधिकतम संख्या के रूप में परिकलित करें और चरण 1 पर जाएँ।

जैसा कि विवरण से देखा जा सकता है, एल्गोरिदम बहुत समान हैं। इसलिए, पुस्तकालय के डेवलपर्स ने हेल्पर वर्ग में अगले चरित्र को प्राप्त करने के लिए प्रक्रिया को इनकैप्सुलेट करने का फैसला किया। प्रशिक्षण के लिए, यह केवल अनुक्रम से अगला चरित्र पढ़ रहा है, और इसे उत्पन्न करने के लिए, अधिकतम भार के साथ चरित्र का चयन करना (ज़ाहिर है, लालची खोज के लिए)।

तदनुसार, हेल्पर बेस क्लास अगले चरित्र को वर्तमान और राज्य से प्राप्त करने के लिए लागू करता है, साथ ही प्रोजेक्शन स्तर से चरित्र सूचकांक प्राप्त करने के लिए नमूना विधि। प्रशिक्षण के कार्यान्वयन के लिए, TrainingHelper वर्ग प्रदान किया जाता है, और लालची खोज विधि द्वारा पीढ़ी के कार्यान्वयन के लिए, GreedyEmbeddingHelper वर्ग प्रदान किया जाता है । दुर्भाग्य से, बीम खोज मॉडल इस प्रकार की प्रणाली में फिट नहीं होता है, इसलिए, लाइब्रेरी में एक विशेष वर्ग BeamSearchDecoder कार्यान्वित किया जाता है। हेल्पर का उपयोग नहीं करना।

डिकोडर वर्ग एक डिकोडर को लागू करने के लिए एक इंटरफ़ेस प्रदान करता है। वास्तव में, वर्ग दो तरीके प्रदान करता है:

काम की शुरुआत में इनिशियलाइज़ करना।
एक सीखने के कदम या पीढ़ी को लागू करने के लिए कदम। इस चरण की सामग्री संगत हेल्पर द्वारा निर्धारित की जाती है।

लाइब्रेरी बेसिकडेकोडर वर्ग को लागू करती है, जिसका उपयोग प्रशिक्षण के लिए और प्रशिक्षणहेल्पर और लालचीमेडबेडिंग हेल्पर सहायकों के साथ प्रजनन के लिए किया जा सकता है। ये तीन वर्ग आमतौर पर पुनरावृत्ति नेटवर्क पर आधारित पीढ़ी के मॉडल को लागू करने के लिए पर्याप्त हैं।

अंत में, एक इनपुट या उत्पन्न अनुक्रम के माध्यम से डायनामिक_डबल फ़ंक्शंस का उपयोग मार्ग को व्यवस्थित करने के लिए किया जाता है।

अगला, हम एक उदाहरण के उदाहरण पर विचार करेंगे, जो विभिन्न प्रकार के seq2seq लाइब्रेरी के लिए उत्पादक मॉडल बनाने के तरीकों को दर्शाता है।

उदाहरण उदाहरण

सबसे पहले, यह कहा जाना चाहिए कि पायथन 2.7 में सभी उदाहरण लागू हैं। अतिरिक्त पुस्तकालयों की एक सूची आवश्यकताएँ फ़ाइल में पाई जा सकती है।

एक उदाहरण के रूप में, पाठ सामान्यीकरण चुनौती के लिए डेटा का एक भाग पर विचार करें - 2017 में Google द्वारा कागल द्वारा आयोजित रूसी भाषा प्रतियोगिता। इस प्रतियोगिता का उद्देश्य रूसी पाठ को पढ़ने के लिए उपयुक्त रूप में परिवर्तित करना था। प्रतियोगिता के लिए पाठ टाइप किए गए भावों में टूट गया था। प्रशिक्षण डेटा निम्नलिखित फॉर्म की CSV फ़ाइल में निर्दिष्ट किया गया था:

 "sentence_id","token_id","class","before","after" 0,0,"PLAIN","","" 0,1,"PLAIN","","" 0,2,"PLAIN","","" 0,3,"DATE","1862 ","    " 0,4,"PUNCT",".","." 1,0,"PLAIN","","" 1,1,"PLAIN","","" 1,2,"PLAIN","","" 1,3,"PLAIN","","" 1,4,"PLAIN","","" 1,5,"PLAIN","","" 1,6,"PLAIN","","" 1,7,"PLAIN","","" 1,8,"PLAIN","","" 1,9,"PUNCT",".","." ...

ऊपर दिए गए उदाहरण में, DATE का एक प्रकार दिलचस्प है; इसमें "1862" का अनुवाद "एक हजार आठ सौ इकसठ वर्ष" में किया गया है। वर्णन करने के लिए, हम प्रकार DATE के डेटा को केवल फॉर्म के जोड़े (अभिव्यक्ति से पहले, बाद में अभिव्यक्ति) के रूप में मानते हैं। डेटा फ़ाइल की शुरुआत:

 before,after 1862 ,     1811 ,    12  2013,      15  2013,      1905 ,    17  2014,      7  2010 ,      1 ,  1843 ,     30  2007 ,      1846 ,     1996 ,     9 ,  ...

हम seq2seq लाइब्रेरी का उपयोग करके जनरेटिंग मॉडल का निर्माण करेंगे, जिसमें एनकोडर को प्रतीक स्तर (यानी, वर्णमाला के तत्व प्रतीक हैं) पर लागू किया जाएगा, और डिकोडर वर्णमाला के रूप में शब्दों का उपयोग करेगा। नमूना कोड, डेटा की तरह, गितुब पर रिपॉजिटरी में उपलब्ध है।

प्रशिक्षण डेटा को क्रमशः तीन चरणों में विभाजित किया गया है: train.csv, test.csv और dev.csv, क्रमशः, प्रशिक्षण, परीक्षण और सत्यापन को पुनः सत्यापित करने के लिए। डेटा निर्देशिका में है। रिपॉजिटरी में तीन मॉडल लागू किए गए हैं: seq2seq_greedy.py, seq2seq_attention.py और seq2seq_beamsearch.py। यहां हम बुनियादी लालची खोज मॉडल के लिए कोड को देखते हैं।

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

डेटा जनरेशन

प्रशिक्षण और पीढ़ी के लिए एक डेटा पीढ़ी कोड पर विचार करें।

 def parse_fn(line_before, line_after): # Encode in Bytes for TF source = [c.encode('utf8') for c in line_before.decode('utf8').rstrip('\n')] t = [w.encode('utf8') for w in nltk.word_tokenize(line_after.decode('utf8').strip())] learn_target = t + ['<eos>'] + ['<pad>'] target = ['<go>'] + t + ['<eos>'] return (source, len(source)), (target, learn_target, len(target)) def generator_fn(data_file): with open(data_file, 'rb') as f: reader = csv.DictReader(f, delimiter=',', quotechar='"') for row in reader: yield parse_fn(row['before'], row['after']) def input_fn(data_file, params=None): params = params if params is not None else {} shapes = (([None], ()), ([None], [None], ())) types = ((tf.string, tf.int32), (tf.string, tf.string, tf.int32)) defaults = (('<pad>', 0), ('<pad>', '<pad>', 0)) dataset = tf.data.Dataset.from_generator(functools.partial(generator_fn, data_file), output_shapes=shapes, output_types=types) dataset = dataset.repeat(params['epochs']) return (dataset.padded_batch(params.get('batch_size', 50), shapes, defaults).prefetch(1))

Input_fn फ़ंक्शन का उपयोग डेटा का एक संग्रह बनाने के लिए किया जाता है जो अनुमानक तब प्रशिक्षण और पीढ़ी के लिए गुजरता है। डेटा प्रकार पहले सेट किया गया है। यह प्रपत्र की एक जोड़ी है ((एनकोडर अनुक्रम, लंबाई), (डिकोडर अनुक्रम, एक उपसर्ग, लंबाई के साथ डिकोडर अनुक्रम)। स्ट्रिंग "" का उपयोग उपसर्ग के रूप में किया जाता है, प्रत्येक एनकोडर अनुक्रम एक विशेष शब्द "" के साथ समाप्त होता है। इसके अलावा, इस तथ्य के कारण कि अनुक्रम (इनपुट और आउटपुट दोनों) में एक असमान लंबाई है, मूल्य "" के साथ पैडिंग प्रतीक का उपयोग किया जाता है।

डेटा तैयारी कोड डेटा फ़ाइल को पढ़ता है, एनकोडर स्ट्रिंग को वर्णों में विभाजित करता है, और डिकोडर स्ट्रिंग को शब्दों में, इसके लिए nltk लाइब्रेरी का उपयोग करता है। इस तरह से संसाधित एक पंक्ति प्रशिक्षण डेटा का एक उदाहरण है। उत्पन्न संग्रह को मिनी-पैकेज में विभाजित किया गया है, और डेटा की मात्रा को प्रशिक्षण युग की संख्या के अनुसार क्लोन किया जाता है (प्रत्येक युग एक डेटा पास है)।

शब्दकोशों के साथ काम करें

शब्दकोशों को फ़ाइलों में एक सूची के रूप में संग्रहीत किया जाता है, एक शब्द या वर्ण के लिए एक पंक्ति। शब्दकोशों का निर्माण करने के लिए, build_vocabs.py स्क्रिप्ट का उपयोग करें। जनरेट किए गए शब्दकोशों डेटा निर्देशिका में फॉर्म वकब की फ़ाइलों के रूप में स्थित हैं। *। Txt

शब्दकोशों को पढ़ने के लिए कोड:

 # Read vocabs and inputs dropout = params['dropout'] source, source_length = features training = (mode == tf.estimator.ModeKeys.TRAIN) vocab_source = tf.contrib.lookup.index_table_from_file(vocabulary_file=params['source_vocab_file'], num_oov_buckets=params['num_oov_buckets']) with open(params['source_vocab_file']) as f: num_sources = sum(1 for _ in f) + params['num_oov_buckets'] vocab_target = tf.contrib.lookup.index_table_from_file(vocabulary_file=params['target_vocab_file'], num_oov_buckets=params['num_oov_buckets']) with open(params['target_vocab_file']) as f: num_targets = sum(1 for _ in f) + params['num_oov_buckets']

यहां, शायद, index_table_from_file फ़ंक्शन, जो किसी फ़ाइल से शब्दकोश प्रविष्टियों को पढ़ता है, दिलचस्प है, और इसका पैरामीटर num_oov_buckets शब्दावली बास्केट से बाहर की संख्या है। डिफ़ॉल्ट रूप से, यह संख्या एक के बराबर है, अर्थात सभी शब्द जो डिक्शनरी में नहीं हैं, डिक्शनरी + के आकार के बराबर एक ही इंडेक्स है। हमारे पास तीन अज्ञात शब्द हैं: "", "" और "", जिसके लिए हम अलग-अलग इंडेक्स चाहते हैं। इसलिए, इस पैरामीटर को संख्या तीन पर सेट करें। दुर्भाग्य से, आपको मॉडल ग्राफ को सेट करने के लिए एक समय स्थिर के रूप में शब्दकोष में शब्दों की संख्या प्राप्त करने के लिए इनपुट फाइल को फिर से पढ़ना होगा।

हमें अभी भी एम्बेडिंग लागू करने के लिए एक तालिका बनाने की आवश्यकता है - _source_embedding, साथ ही पहचान के लिए शब्द स्ट्रिंग का अनुवाद करना:

 # source embeddings matrix _source_embedding = tf.Variable(tf.random_uniform([num_sources, params['embedding_size']])) source_ids = vocab_source.lookup(source) source_embedding = tf.nn.embedding_lookup(_source_embedding, source_ids)

एनकोडर कार्यान्वयन

एनकोडर के लिए, हम कई स्तरों के साथ एक द्विदिश पुनरावर्ती नेटवर्क का उपयोग करेंगे। , , .

 # add multilayer bidirectional RNN cell_fw = tf.contrib.rnn.MultiRNNCell([tf.contrib.rnn.GRUCell(params['dim']) for _ in range(params['layers'])]) cell_bw = tf.contrib.rnn.MultiRNNCell([tf.contrib.rnn.GRUCell(params['dim']) for _ in range(params['layers'])]) outputs, states = tf.nn.bidirectional_dynamic_rnn(cell_fw, cell_bw, source_embedding, sequence_length=source_length, dtype=tf.float32) # prepare output output = tf.concat(outputs, axis=-1) encoder_output = tf.layers.dense(output, params['dim']) # prepare state state_fw, state_bw = states cells = [] for fw, bw in zip(state_fw, state_bw): state = tf.concat([fw, bw], axis=-1) cells += [tf.layers.dense(state, params['dim'])] encoder_state = tuple(cells)

GRU, MultiRNNCell, , rnn.Cell. ,
sequence_length — , , .

, , , . , 128, 256. , , 128. .

. क्योंकि , , bidirectional_dynamic_rnn, , . , . , .. . , , . , , .

, . .

  # decoder RNN cell decoder_cell = tf.contrib.rnn.MultiRNNCell([tf.contrib.rnn.GRUCell(params['dim']) for _ in range(params['layers'])]) decoder_initial_state = encoder_state # projection layer projection_layer = tf.layers.Dense(num_targets, use_bias=False) # embedding table for targets target_embedding = tf.Variable(tf.random_uniform([num_targets, params['embedding_size']]))

TrainingHelper + BasicDecoder.

  # target embeddings matrix target, learn_target, target_length = labels target_ids = vocab_target.lookup(target) target_learn_ids = vocab_target.lookup(learn_target) # train encoder _target_embedding = tf.nn.embedding_lookup(target_embedding, target_ids) train_helper = tf.contrib.seq2seq.TrainingHelper(_target_embedding, target_length) train_decoder = tf.contrib.seq2seq.BasicDecoder(decoder_cell, train_helper, decoder_initial_state, output_layer=projection_layer) train_outputs, _, _ = tf.contrib.seq2seq.dynamic_decode(train_decoder) train_output = train_outputs.rnn_output train_sample_id = train_outputs.sample_id

 # prediction decoder prediction_helper = tf.contrib.seq2seq.GreedyEmbeddingHelper( embedding=target_embedding, start_tokens=tf.fill([batch_size], tf.to_int32(vocab_target.lookup(tf.fill([], '<go>')))), end_token=tf.to_int32(vocab_target.lookup(tf.fill([], '<eos>')))) prediction_decoder = tf.contrib.seq2seq.BasicDecoder(decoder_cell, prediction_helper, decoder_initial_state, output_layer=projection_layer) prediction_output, _, _ = tf.contrib.seq2seq.dynamic_decode(prediction_decoder, maximum_iterations=params['max_iters']) # prepare prediction reverse_vocab_target = tf.contrib.lookup.index_to_string_table_from_file(params['target_vocab_file']) pred_strings = reverse_vocab_target.lookup(tf.to_int64(prediction_output.sample_id)) predictions = { 'ids': prediction_output.sample_id, 'text': pred_strings }

GreedyEmbeddingHelper "", "". . , , dynamic_decode . , , . , , .

, seq2seq.

 # loss masks = tf.sequence_mask(lengths=target_length, dtype=tf.float32) loss = tf.contrib.seq2seq.sequence_loss(logits=train_output, targets=target_learn_ids, weights=masks)

, , sequence_mask.

Adam , .

 optimizer = tf.train.AdamOptimizer(learning_rate=params.get('lr', .001)) grads, vs = zip(*optimizer.compute_gradients(loss)) grads, gnorm = tf.clip_by_global_norm(grads, params.get('clip', .5)) train_op = optimizer.apply_gradients(zip(grads, vs), global_step=tf.train.get_or_create_global_step())

. 0.9 . , , , . , .

 24  1944                 1  2003              1992 .           11  1927               1969            1  2016             1047          1863            17      22  2014

. — , — , — .

, — . . , ( ), . . , .

निष्कर्ष

seq2seq. , , . , .

. Tensorflow , , . , , . , . , , padding , embedding ? , , . — . , , . , , , . , . , , , , .

Tensorflow में seq2seq मॉडल को लागू करना