केरास

Question

में एलएसटीएम परत में वजन की व्याख्या कैसे करें मैं वर्तमान में एलएसटीएम परत का उपयोग करके मौसम पूर्वानुमान के लिए आवर्ती तंत्रिका नेटवर्क का प्रशिक्षण दे रहा हूं। नेटवर्क में ही बहुत सरल है और इस तरह मोटे तौर पर दिखता है:

model = Sequential() 
model.add(LSTM(hidden_neurons, input_shape=(time_steps, feature_count), return_sequences=False)) 
model.add(Dense(feature_count)) 
model.add(Activation("linear")) 

LSTM परत के वजन निम्नलिखित आकार है:,

for weight in model.get_weights(): # weights from Dense layer omitted 
    print(weight.shape) 

> (feature_count, hidden_neurons) 
> (hidden_neurons, hidden_neurons) 
> (hidden_neurons,) 
> (feature_count, hidden_neurons) 
> (hidden_neurons, hidden_neurons) 
> (hidden_neurons,) 
> (feature_count, hidden_neurons) 
> (hidden_neurons, hidden_neurons) 
> (hidden_neurons,) 
> (feature_count, hidden_neurons) 
> (hidden_neurons, hidden_neurons) 
> (hidden_neurons,) 

संक्षेप में यह लग रहा है चार "तत्वों" की तरह देखते हैं इस एलएसटीएम परत में। अब मैं सोच रहा हूँ उन्हें समझने के:

• इस प्रतिनिधित्व में time_steps पैरामीटर कहां है? यह वजन को कैसे प्रभावित करता है?

• मैंने पढ़ा है कि एक एलएसटीएम में कई ब्लॉक होते हैं, जैसे इनपुट और भूलने वाला गेट। यदि इन वजन मैट्रिक्स में उनका प्रतिनिधित्व किया जाता है, तो कौन सा मैट्रिक्स किस द्वार से संबंधित है?

• क्या नेटवर्क को सीखा है यह देखने का कोई तरीका है? उदाहरण के लिए, पिछली बार चरण (t-1) से हम कितना लेते हैं यदि हम t का पूर्वानुमान करना चाहते हैं) और t-2 आदि से कितना? यह जानना दिलचस्प होगा कि क्या हम वजन से पढ़ सकते हैं कि इनपुट t-5 पूरी तरह से अप्रासंगिक है, उदाहरण के लिए।

स्पष्टीकरण और संकेतों की बहुत सराहना की जाएगी।

Answer 1

मैं शायद आपके सभी सवालों का जवाब नहीं दे पाऊंगा लेकिन मैं क्या कर सकता हूं एलएसटीएम सेल और इसके द्वारा बनाए गए विभिन्न घटकों पर अधिक जानकारी प्रदान करता है।

This post on github एक तरह से उन्हें प्रिंट करते समय मानकों 'नाम देखने के लिए प्रस्ताव:

model = Sequential() 
model.add(LSTM(4,input_dim=5,input_length=N,return_sequences=True)) 
for e in zip(model.layers[0].trainable_weights, model.layers[0].get_weights()): 
    print('Param %s:\n%s' % (e[0],e[1])) 

आउटपुट की तरह दिखता है:

Param lstm_3_W_i: 
[[ 0.00069305, ...]] 
Param lstm_3_U_i: 
[[ 1.10000002, ...]] 
Param lstm_3_b_i: 
[ 0., ...] 
Param lstm_3_W_c: 
[[-1.38370085, ...]] 
... 

अब आप उन विभिन्न वजन के बारे में here अधिक जानकारी प्राप्त कर सकते हैं। उनके पास विभिन्न सूचकांक के साथ डब्ल्यू, यू, वी और बी नाम हैं।

• डब्ल्यू matrices वे हैं जो इनपुट को किसी अन्य आंतरिक मूल्यों में बदलते हैं। उनके पास आकार [input_dim, output_dim] है।
• यू matrices वे हैं जो पिछले छिपे हुए राज्य को दूसरे आंतरिक मूल्य में बदलते हैं। उनके आकार [output_dim, output_dim] है।
• बी वैक्टर प्रत्येक ब्लॉक के लिए पूर्वाग्रह हैं। उनके पास आकार [output_dim]
• वी केवल आउटपुट गेट में उपयोग किया जाता है, यह नए आंतरिक राज्य से उत्पादन करने के लिए कौन से मूल्यों को चुनता है। इसका आकार [output_dim, output_dim]

संक्षेप में आपके पास वास्तव में 4 अलग-अलग "ब्लॉक" (या आंतरिक परतें) हैं।

• गेट भूल: यह फैसला करता है, पिछले छिपा राज्य (h_ {टी 1}) और इनपुट (एक्स), सेल के पिछले आंतरिक स्थिति से भूल जाते हैं को महत्व देता है जो (C_ {टी के आधार पर -1}):

  f_t = अवग्रह (W_f * x + U_f * h_ {टी 1} + b_f)

  f_t 0 और 1 के बीच मूल्यों है कि क्या रखने के लिए (सांकेतिक शब्दों में बदलना होगा का एक वेक्टर है = 1) और पिछले सेल राज्य से क्या भूलना है (= 0)।

• इनपुट गेट: यह पिछले छिपा राज्य के आधार पर फैसला करता है, (h_ {टी 1}) और इनपुट (x) है, जो इनपुट से उपयोग करने के लिए महत्व देता है (एक्स):

  i_t = अवग्रह (W_i * x + U_i * h_ {t-1} + b_i)

  i_t 0 और 1 के बीच मानों का एक वेक्टर है जो नए सेल स्थिति को अद्यतन करने के लिए उपयोग किए जाने वाले मानों को एन्कोड करेगा।

• उम्मीदवार मूल्य: हम आंतरिक सेल राज्य अद्यतन करने के लिए, इनपुट (x) और पिछले छिपा राज्य (h_ {टी 1}) का उपयोग कर नए उम्मीदवार मूल्यों का निर्माण:

  Ct_t = tanh (W_c * x + U_c * h_ {t-1} + b_c)

  सीटी_टी एक वेक्टर है जिसमें सेल स्थिति को अद्यतन करने के लिए संभावित मान होते हैं (C_ {t-1})।

हम उन तीन मूल्यों का उपयोग एक नई आंतरिक सेल राज्य (C_t) के निर्माण के लिए:

C_t = f_t * C_ {टी 1} + i_t * Ct_t

के रूप में आप देख सकते हैं, नया आंतरिक सेल राज्य दो चीजों से बना है: वह हिस्सा जिसे हम अंतिम राज्य से नहीं भूलते थे, और हम इनपुट से क्या सीखना चाहते थे।

• आउटपुट गेट: हम नहीं करते उत्पादन करने के लिए सेल राज्य के रूप में यह है कि हम क्या निर्गम (h_t) करना चाहते हैं की एक अमूर्त रूप में देखा जा सकता है चाहता हूँ। इसलिए हम h_t निर्माण, यह कदम सभी जानकारी के आधार पर उत्पादन हमने:

  h_t = W_o * x + U_o * h_ {टी 1} + V_o * C_t + b_o

मैं उम्मीद है कि यह स्पष्ट करता है कि एलएसटीएम सेल कैसे काम करता है। मैं आपको एलएसटीएम पर ट्यूटोरियल पढ़ने के लिए आमंत्रित करता हूं क्योंकि वे अच्छे स्कीमा, चरण-दर-चरण उदाहरणों आदि का उपयोग करते हैं। यह एक अपेक्षाकृत जटिल परत है।

अपने प्रश्नों के बारे में, अब मुझे पता है कि राज्य को संशोधित करने के लिए इनपुट से क्या उपयोग किया गया है इसका ट्रैक करना है। आप अंततः विभिन्न डब्ल्यू matrices को देख सकते हैं, क्योंकि वे इनपुट प्रसंस्करण कर रहे हैं। W_c आपको सेल के राज्य को अद्यतन करने के लिए संभावित रूप से उपयोग किए जाने वाले चीज़ों के बारे में जानकारी देगा। W_o आपको आउटपुट बनाने के लिए उपयोग की जाने वाली चीज़ों के बारे में कुछ जानकारी दे सकता है ... लेकिन यह सब अन्य वजनों के सापेक्ष होगा क्योंकि पिछले राज्यों का भी प्रभाव है।

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

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

मुझे आशा है कि इस मदद करता है :-)