2 डी में स्थानिक ड्रॉपआउट कैसे लागू किया जाता है?

Question

यह कागज के लिए रेफ़रेंस के साथ है। एफिशिएंट नेटवर्क्स का उपयोग करते हुए कुशल वस्तु स्थानीयकरण , और जो मुझे समझ में आता है कि ड्रॉपआउट को 2 डी में लागू किया गया है।

कर्स के कोड को पढ़ने के बाद कि स्थानिक 2 डी ड्रॉपआउट कैसे लागू किया जाता है, मूल रूप से आकार का एक यादृच्छिक बाइनरी मास्क [बैच_साइज़, 1, 1, अंक_चैनल्स] लागू किया जाता है। हालांकि, यह स्थानिक 2D ड्रॉपआउट वास्तव में आकार [बैच_साइज, ऊंचाई, चौड़ाई, num_channels] के इनपुट कन्वेक्शन ब्लॉक को क्या करता है?

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

हालांकि, अगर मेरा अनुमान सही है, तो आकार के एक बाइनरी मास्क का उपयोग कैसे करता है [बैच_साइज़, ऊंचाई, चौड़ाई, num_channels] जो मूल इनपुट ब्लॉक के आयाम में सामान्य तत्व-वार ड्रॉपआउट देते हैं (यह इस हिसाब से है टेंसोफ़्लो का मूल ड्रॉपआउट कार्यान्वयन जो बाइनरी मास्क के आकार को इनपुट के आकार के रूप में सेट करता है)? क्योंकि तब इसका मतलब होगा कि अगर कोई भी ब्लॉक ब्लॉक में कोई भी नेगेटिव है, तो पूरा का पूरा ब्लॉक 0. डिफॉल्ट हो जाएगा। यह भ्रामक हिस्सा है, जिसे मैं बिल्कुल नहीं समझता।

Answer 1

यह प्रतिक्रिया थोड़ी देर की है, लेकिन मुझे इसे स्वयं संबोधित करने की आवश्यकता है और सोचा कि इससे मदद मिल सकती है।

कागज को देखकर, ऐसा लगता है कि स्थानिक ड्रॉपआउट में, हम व्यक्तिगत रूप से 'पिक्सेल' के बजाय पूरे फीचर मैप (जिसे चैनल भी कहते हैं) को 0 पर सेट करते हैं।

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

यहाँ एक फ़ंक्शन है जो tf.nn.dropout के आधार पर इसे Tensorflow में लागू करता है। Tf.nn.dropout से एकमात्र वास्तविक परिवर्तन यह है कि हमारे ड्रॉपआउट मास्क का आकार बैच * * 1 * 1 है।

def spatial_dropout(x, keep_prob, seed=1234):
    # x is a convnet activation with shape BxWxHxF where F is the 
    # number of feature maps for that layer
    # keep_prob is the proportion of feature maps we want to keep

    # get the batch size and number of feature maps
    num_feature_maps = [tf.shape(x)[0], tf.shape(x)[3]]

    # get some uniform noise between keep_prob and 1 + keep_prob
    random_tensor = keep_prob
    random_tensor += tf.random_uniform(num_feature_maps,
                                       seed=seed,
                                       dtype=x.dtype)

    # if we take the floor of this, we get a binary matrix where
    # (1-keep_prob)% of the values are 0 and the rest are 1
    binary_tensor = tf.floor(random_tensor)

    # Reshape to multiply our feature maps by this tensor correctly
    binary_tensor = tf.reshape(binary_tensor, 
                               [-1, 1, 1, tf.shape(x)[3]])
    # Zero out feature maps where appropriate; scale up to compensate
    ret = tf.div(x, keep_prob) * binary_tensor
    return ret

उम्मीद है की वो मदद करदे!

Answer 2

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

मुझे पक्का यकीन नहीं है कि आपका यहां क्या मतलब है लेकिन ड्रॉपआउट मास्क के लिए बेतरतीब ढंग से खींचे जाने के अलावा किसी भी मूल्य के बावजूद ड्रॉपआउट होता है। यह ड्रॉपआउट पिक्सेल मूल्यों , फ़िल्टर भार या फ़ीचर मैप मानों से प्रभावित नहीं होता है । यदि आप आकार के मास्क का उपयोग करते हैं तो आपको [batch_size, 1, 1, num_channels]ड्रॉपआउट के दौरान इस आकार का एक बाइनरी मास्क मिलेगा। उस बाइनरी मास्क में शून्य संभावना के साथ होता है rate(कम से कम केरस कार्यान्वयन में, पहले तर्क Dropoutपरत)। इस मास्क को तब आपके फीचर मैप्स से गुणा किया जाता है, इसलिए जो भी मास्क आयाम आकार 1 का है - उस मास्क का आयाम आपको फीचर मैप आकार से मिलान करने के लिए प्रसारित किया जाता है।
एक सरल स्थिति की कल्पना करें - मान लें कि आपके पास आकार के नक्शे हैं [height, num_channels](अब के लिए बैच आकार को अनदेखा करें) और आपके पास मानचित्र के मान हैं:

print(feature_maps)

[[2 1 4]
 [1 3 2]
 [5 2 6]
 [2 2 1]]

print(feature_maps.shape)

(4, 3)

फिर आकार की एक बाइनरी ड्रॉपआउट मास्क की कल्पना करें [1, num_channels], जैसे यह:

print(dropout_mask)

[[0 1 0]]

print(dropout_mask.shape)

(1, 3)

अब देखें कि क्या होता है जब आप गुणा करते हैं feature_mapsऔर dropout_mask:

print(feature_maps * dropout_mask)

[[0 1 0]
 [0 3 0]
 [0 2 0]
 [0 2 0]]

dropout_maskप्रत्येक फीचर मैप की ऊंचाई से मिलान करने के लिए मूल्यों को प्रसारित किया गया और फिर तत्व-दर-तत्व गुणन प्रदर्शन किया गया। परिणामस्वरूप पूरे फीचर मानचित्र शून्य हो गए - और यही स्थानिक ड्रॉपआउट है।