एलएसटीएम ऑटोनकोडर कोई प्रगति नहीं करता है जब स्क्रिप्ट बड़े डेटासेट पर चल रहा है

Question

p_input"test.py" के लिए आकार (128,8,1) है; जिसका मतलब 8 अंकों के 128 सेट है। मैं इस मॉडल को समय-श्रृंखला-आधारित डेटा पर 25,000 समय चरणों के 4 सेट (मूल रूप से 0 सेकंड से 25,000 सेकेंड) के साथ अनुकूलित करने की कोशिश कर रहा हूं। मैंने इस डेटासेट को आकार के साथ p_input में इनपुट करने की कोशिश की (4,25000,1) और कोई त्रुटि नहीं हुई। हालांकि जब मैं स्क्रिप्ट चलाता हूं, iter 1: 0.01727, iter 2: 0.00983, ... प्राप्त करने के बजाय मुझे स्क्रिप्ट से कोई मुद्रित प्रतिक्रिया नहीं मिलती है, इसलिए मुझे लगता है कि कुछ स्क्रिप्ट को पकड़ रहा है। मैंने batch_num को 4 और step_num से 25,000 तक सीधे संयुक्त "test.py" फ़ाइल पर बदलने की कोशिश की है और कोई भी मुद्रित प्रतिक्रिया नहीं हुई है।

मेरे विचार यह हैं कि "test.py", p_inputs में tf.split और tf.squeeze संचालन की गणना करने में बहुत अधिक समय लग रहा है। एक और विचार यह है कि मुझे छिपी हुई एलएसटीएम इकाइयों की संख्या hidden_num में बढ़ाने की आवश्यकता हो सकती है और/या युगों की संख्या में वृद्धि (iteration)। इसके अलावा, यह हो सकता है कि batch_numstep_num से अधिक होना चाहिए। मैंने इसे step_num = 4 और batch_num = 25000 के साथ "test.py" के साथ करने की कोशिश की और स्क्रिप्ट सामान्य रूप से मुद्रित प्रतिक्रिया के साथ चलती है।

मुझे अपने विचारों को बताएं कि स्क्रिप्ट को चलाने से समस्या क्या हो सकती है।

Answer 1

आपके इनपुट का दूसरा आयाम BPTT एल्गोरिदम द्वारा ग्रेडियेंट की गणना के लिए नेटवर्क को अनलॉक करने की संख्या है।

विचार यह है कि एक आवर्ती नेटवर्क (जैसे एलएसटीएम) को नेटवर्क की नई परत के रूप में प्रत्येक बार "अनलॉकिंग" द्वारा फीडफोर्ड नेटवर्क में बदल दिया जाता है।

जब आप पूरे समय श्रृंखला को एक साथ प्रदान करते हैं (यानी 25000 समय कदम) आप 25000 बार अपने नेटवर्क को अनलॉक कर रहे हैं, तो आप 25000 परतों के साथ एक अनियंत्रित फीडफोर्ड नेटवर्क प्राप्त करेंगे !!

तो, हालांकि मुझे नहीं पता कि आपको कोई त्रुटि क्यों नहीं मिलती है, समस्या शायद स्मृति समस्या से बाहर हो सकती है। आप मेमोरी में 25000 परतों के चर फिट करने में सक्षम नहीं हैं।

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

मैं आपको एक उदाहरण प्रदान कर सकता हूं। क्या आप अभी उपयोग कर (मैं व्यावहारिक कारणों के लिए तीसरे आयाम उपेक्षा) एक वेक्टर 4x25000 कि कुछ इस तरह आकार का है है:

--------------------- 25000---------------------- 
| 
| 
4 
| 
| 
-------------------------------------------------- 

अब आप टुकड़ों में इस तरह की यह विभाजित करने के लिए है:

----20----- ----20----- ----20----- 
|   | |   | |   | 
|   | |   | |   | 
4   | 4   | 4   | [...] 
|   | |   | |   | 
|   | |   | |   | 
----------- ----------- ----------- 

आप हर बार 4x20 का एक सिंगल चंच प्रदान करते हैं। फिर, प्रत्येक चक के बाद आपके एलएसटीएम की अंतिम स्थिति को अगले चक के साथ इनपुट के रूप में प्रदान किया जाना चाहिए।

feed_dict ={x: input_4_20}, 
      state.c = previous_state.c, 
      state.h=previous_state.h} 

कैसे अगले रन के लिए एक LSTM के राज्य प्रदान करने के लिए पर एक उदाहरण के लिए Tensorflow की LM tutorial देखें:

तो अपने feed_dict कुछ इस तरह होना चाहिए।

टेन्सफोर्लो स्वचालित रूप से ऐसा करने के लिए कुछ फ़ंक्शन प्रदान करता है। अधिक के लिए आरएनएन एपीआई पर Tensorflow DevSummit Tutorial देखें। मैंने सटीक दूसरे से लिंक किया जहां वांछित कार्यों को समझाया गया है। समारोह tf.contrib.training.batch_sequences_with_states(...)

अंतिम सलाह के रूप में, मैं आपको अपने कार्य पर पुनर्विचार करने का सुझाव दूंगा। वास्तव में, 25000 की एक समय श्रृंखला वास्तव में एक लंबी अनुक्रम है और मैं इस तथ्य के बारे में चिंतित हूं कि यहां तक ​​कि एक एलएसटीएम भी ऐसी पिछली निर्भरताओं का प्रबंधन नहीं कर सकता है। मेरा मतलब यह है कि जब आप श्रृंखला के 24000 वें तत्व को संसाधित कर रहे हैं तो एलएसटीएम राज्य शायद पहले तत्व के बारे में सबकुछ भूल गया है। इन मामलों में, यह देखने के लिए अपने डेटा को देखने का प्रयास करें कि आपकी घटना का स्तर कौन सा है। यदि आपको एक सेकंड की ग्रैन्युलरिटी की आवश्यकता नहीं है (यानी आपकी श्रृंखला अत्यधिक अनावश्यक है क्योंकि समय समय में बहुत तेजी से बदलाव नहीं होता है), तो अपनी श्रृंखला को प्रबंधित करने के लिए एक छोटा सा अनुक्रम प्राप्त करें।