करस में एक से कई और कई LSTM उदाहरण के लिए

Question

मैं LSTM को समझने की कोशिश करता हूं और उन्हें केर के साथ कैसे बनाया जाए। मुझे पता चला, कि RNN चलाने के लिए मुख्य रूप से 4 मोड हैं (चित्र में 4 सही वाले)

छवि स्रोत: कन्या करपाथी

अब मुझे आश्चर्य है कि उनमें से प्रत्येक के लिए एक न्यूनतम कोड स्निपेट कैसेरे में दिखेगा। तो कुछ ऐसा है

model = Sequential()
model.add(LSTM(128, input_shape=(timesteps, data_dim)))
model.add(Dense(1))

4 कार्यों में से प्रत्येक के लिए, शायद थोड़ा सा स्पष्टीकरण के साथ।

Answer 1

इसलिए:

1. एक-से-एक : आप एक Denseपरत का उपयोग कर सकते हैं क्योंकि आप दृश्यों को संसाधित नहीं कर रहे हैं:

   model.add(Dense(output_size, input_shape=input_shape))

2. एक से कई : यह विकल्प अच्छी तरह से समर्थित नहीं है क्योंकि मॉडल का Kerasपीछा करना बहुत आसान नहीं है , इसलिए निम्न संस्करण सबसे आसान है:

   model.add(RepeatVector(number_of_times, input_shape=input_shape))
   model.add(LSTM(output_size, return_sequences=True))

3. कई-से-एक : वास्तव में, आपका कोड स्निपेट (लगभग) इस दृष्टिकोण का एक उदाहरण है:

   model = Sequential()
   model.add(LSTM(1, input_shape=(timesteps, data_dim)))

4. कई-कई : यह सबसे आसान स्निपेट है जब इनपुट और आउटपुट की लंबाई आवर्तक चरणों की संख्या से मेल खाती है:

   model = Sequential()
   model.add(LSTM(1, input_shape=(timesteps, data_dim), return_sequences=True))

5. कई-से-कई जब इनपुट / आउटपुट लंबाई से चरणों की संख्या भिन्न होती है : यह केरस में कठिन है। कोड करने के लिए कोई आसान कोड स्निपेट नहीं हैं।

संपादित करें: विज्ञापन ५

मेरे हाल के एक आवेदन में, हमने कुछ ऐसा लागू किया जो 4-छवि से कई-से-कई के समान हो सकता है । यदि आप निम्नलिखित वास्तुकला के साथ एक नेटवर्क रखना चाहते हैं (जब एक इनपुट आउटपुट से अधिक है):

                                        O O O
                                        | | |
                                  O O O O O O
                                  | | | | | | 
                                  O O O O O O

आप इसे निम्नलिखित तरीके से प्राप्त कर सकते हैं:

    model = Sequential()
    model.add(LSTM(1, input_shape=(timesteps, data_dim), return_sequences=True))
    model.add(Lambda(lambda x: x[:, -N:, :]

Nअंतिम चरण की संख्या कहां है जिसे आप कवर करना चाहते हैं (छवि पर N = 3)।

इस बिंदु से:

                                        O O O
                                        | | |
                                  O O O O O O
                                  | | | 
                                  O O O 

एक उपयुक्त आकार में इसे समायोजित करने के लिए, वैक्टर के Nसाथ उदाहरण के लिए लंबाई के कृत्रिम पैडिंग अनुक्रम के रूप में सरल है 0।

Comments

एक स्पष्टीकरण: उदाहरण के लिए कई के लिए, आप LSTM (1, input_shape = (टाइमस्टेप्स, data_dim)) का उपयोग करते हैं) मैंने सोचा था कि 1 LSTM कोशिकाओं / छिपे हुए नोड्स की संख्या के लिए खड़ा है, लेकिन स्पष्ट रूप से यह नहीं बताएगा कि आप कई कोड कैसे बनाएंगे- के साथ एक कहते हैं, हालांकि 512 नोड्स से? (? क्योंकि मैं simliar मैंने सोचा कि यह model.add (LSTM (512, input_shape = ...)) model.add (घने (1)) क्या है कि तुलना के लिए इस्तेमाल के साथ किया जा होगा कुछ पढ़ा)

— लुका थेडे

इस स्थिति में - आपका कोड - टाइप करने के बाद ठीक होना चाहिए।

— Marcin Mo

हम दोहराव का उपयोग क्यों करते हैं, और पहली प्रविष्टि 1 = 0 और अन्य सभी प्रविष्टियों के साथ वेक्टर नहीं है = 0 (ऊपर चित्र के अनुसार, बाद के राज्यों में कोई इनपुट नहीं है, और हमेशा एक ही इनपुट नहीं है, मेरी समझ में रिपीट वेक्टर क्या करेगा)

— लुका थाइडे

यदि आप इस तस्वीर के बारे में ध्यान से सोचते हैं - यह केवल एक-से-कई के विचार की एक वैचारिक प्रस्तुति है । इस छिपी हुई सभी इकाइयों को इनपुट के रूप में कुछ स्वीकार करना चाहिए । इसलिए - वे उसी इनपुट को स्वीकार कर सकते हैं जो पहले इनपुट के बराबर है xऔर इसके बराबर है 0। लेकिन - दूसरी ओर - वे एक ही xबार-बार एक ही बात को स्वीकार कर सकते हैं । अलग-अलग दृष्टिकोण चेन मॉडल के लिए है जो कठिन है Keras। मेरे द्वारा प्रदान किया गया विकल्प एक से कई वास्तुकला का सबसे आसान मामला है Keras।

— Marcin Mo Marejko

अच्छा लगा! IAM एक GAN आर्किटेक्चर में LSTM N से N का उपयोग करने के बारे में सोच रहा है। मेरे पास एक एलएसटीएम आधारित जनरेटर होगा। मैं इस जेनरेटर को (जैसा कि "लेटेंट वैरिएबल" गन्स में इस्तेमाल किया गया है) टाइम सीरीज़ का पहला हाफ होगा और यह जनरेटर टाइम सीरीज़ के दूसरे हाफ को प्रोड्यूस करेगा। फिर मैं गण के लिए "नकली" इनपुट का उत्पादन करने के लिए दो आधे (वास्तविक और उत्पन्न) को मिलाऊंगा। क्या आपको लगता है कि सॉल्यूशन के 4 के प्रयोग से आप काम करेंगे? या, दूसरे शब्दों में, क्या यह (समाधान 4) ऐसा करने का सही तरीका है?

— rjpg

Answer 2

@Marcin Możejko द्वारा शानदार जवाब

मैं निम्नलिखित NR.5 में जोड़ूंगा (कई में अलग / बाहर लंबाई के साथ कई):

ए) वेनिला एलएसटीएम के रूप में

model = Sequential()
model.add(LSTM(N_BLOCKS, input_shape=(N_INPUTS, N_FEATURES)))
model.add(Dense(N_OUTPUTS))

बी) एनकोडर-डिकोडर LSTM के रूप में

model.add(LSTM(N_BLOCKS, input_shape=(N_INPUTS, N_FEATURES))  
model.add(RepeatVector(N_OUTPUTS))
model.add(LSTM(N_BLOCKS, return_sequences=True))  
model.add(TimeDistributed(Dense(1)))
model.add(Activation('linear')) 

Comments

क्या आप कृपया B) Encoder-Decoder LSTMवास्तुकला के विवरण की व्याख्या कर सकते हैं ? मुझे "रिपीटवेक्टर" / "टाइमडिस्ट्रिब्यूटेड" चरणों की भूमिकाओं को समझने में समस्याएँ आ रही हैं।

— मार्सेलस वालेस