मुझे तंत्रिका नेटवर्क में ड्रॉपआउट परतें कहां रखनी चाहिए?

Question

क्या तंत्रिका नेटवर्क में ड्रॉपआउट परतों को रखने के लिए कोई सामान्य दिशानिर्देश हैं?

Comments

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

— निवारण करें

क्या कर्म की अनुमति है?

— निवारण करें

@redress कौन खेती करता है, और कैसे?

— फ्रेंक डर्नोनकोर्ट

क्या आपने इसका उत्तर हल किया?

— ब्लैसजार्ड

किस प्रकार के तंत्रिका नेटवर्क हैं? सीएनएन, आरएनएन, अन्य?

— वेन

Answer 1

हिंटन (2012) द्वारा ड्रॉपआउट लेयर प्रस्तावित करने वाले मूल पेपर में, आउटपुट से पहले पूरी तरह से जुड़ी (घनी) परतों में से प्रत्येक पर ड्रॉपआउट (p = 0.5 के साथ) का उपयोग किया गया था; इसका इस्तेमाल कंटेस्टेंट लेयर्स पर नहीं किया गया था। यह सबसे अधिक उपयोग किया जाने वाला कॉन्फ़िगरेशन बन गया।

अधिक हाल के शोध ने ड्रॉपआउट को भी आनुषंगिक परतों को लागू करने में कुछ मूल्य दिखाया है, हालांकि बहुत कम स्तरों पर: पी = 0.1 या 0.2। ड्रॉपआउट का उपयोग प्रत्येक दृढ़ परत के सक्रियण समारोह के बाद किया गया था: CONV-> RELU-> DROP।

Comments

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

— z0r

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

— ओ 4

यह ध्यान देने योग्य है कि हिंटन पेपर में, पृष्ठ 10 (1938) पर, वे लिखते हैं कि Google स्ट्रीट व्यू डेटासेट के विरुद्ध परीक्षण में त्रुटि को कम करते हुए संकरात्मक परतों का उपयोग करना वर्गीकरण त्रुटि को कम करता है।

— मिकी पी

Answer 2

हर रैखिक अनुमानों के सामने। श्रीवास्तव एट अल का संदर्भ लें । (2014) ।

Comments

अन्य उत्तर का वर्णन कैसे छोड़ने वालों लागू करने के लिए, लेकिन यह केवल प्रतिक्रिया है कि के ओपी सवाल का जवाब है जहां स्कूल छोड़ने लागू करने के लिए।

— तूफ़ान

Answer 3

मूल पेपर प्रस्तावित ड्रॉपआउट परतें जो आउटपुट से पहले पूरी तरह से जुड़े (घने) परतों में से प्रत्येक पर उपयोग की जाती थीं; इसका इस्तेमाल कंटेस्टेंट की परतों पर नहीं किया गया था।

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

Answer 4

अगर मैं गलत नहीं हूं, तो आप इसे हर सेल के गैर-रैखिकता के बाद जोड़ सकते हैं:

layer_1 = (1/(1+np.exp(-(np.dot(X,synapse_0)))))
if(do_dropout):
    layer_1 *= np.random.binomial([np.ones((len(X),hidden_dim))],1-dropout_percent)[0] * (1.0/(1-dropout_percent))

पहली पंक्ति सक्रियण फ़ंक्शन है, और अंतिम परिणाम में ड्रॉपआउट जोड़ रहा है। कृपया इस ब्लॉग को देखें । उम्मीद है की यह मदद करेगा।

या आप इसे इस स्निपेट की तरह इनपुट एम्बेडिंग में रख सकते हैं:

class BahdanauAttnDecoderRNN(nn.Module):
    def __init__(self, hidden_size, output_size, n_layers=1, dropout_p=0.1):
        super(AttnDecoderRNN, self).__init__()

        # Define parameters
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.n_layers = n_layers
        self.dropout_p = dropout_p
        self.max_length = max_length

        # Define layers
        self.embedding = nn.Embedding(output_size, hidden_size)
        self.dropout = nn.Dropout(dropout_p)
        self.attn = GeneralAttn(hidden_size)
        self.gru = nn.GRU(hidden_size * 2, hidden_size, n_layers, dropout=dropout_p)
        self.out = nn.Linear(hidden_size, output_size)

    def forward(self, word_input, last_hidden, encoder_outputs):
        # Note that we will only be running forward for a single decoder time step, but will use all encoder outputs

        # Get the embedding of the current input word (last output word)
        word_embedded = self.embedding(word_input).view(1, 1, -1) # S=1 x B x N
        word_embedded = self.dropout(word_embedded)

        # Calculate attention weights and apply to encoder outputs
        attn_weights = self.attn(last_hidden[-1], encoder_outputs)
        context = attn_weights.bmm(encoder_outputs.transpose(0, 1)) # B x 1 x N

        # Combine embedded input word and attended context, run through RNN
        rnn_input = torch.cat((word_embedded, context), 2)
        output, hidden = self.gru(rnn_input, last_hidden)

        # Final output layer
        output = output.squeeze(0) # B x N
        output = F.log_softmax(self.out(torch.cat((output, context), 1)))

        # Return final output, hidden state, and attention weights (for visualization)
        return output, hidden, attn_weights

स्रोत: https://github.com/spro/practical-pytorch/blob/master/seq2seq-translation/seq2seq-translation.ipynb

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

Comments

GeneralAttn को कहाँ परिभाषित किया गया है?

— राफेलवाल्ले