क्या पूलिंग परतें ड्रॉपआउट परतों से पहले या बाद में जोड़ी जाती हैं?

Question

मैं एक कन्वेन्शियल न्यूरल नेटवर्क (CNN) बना रहा हूँ, जहाँ मेरे पास एक संकरी परत है, जिसके बाद एक पूलिंग लेयर है और मैं ओवरफिटिंग को कम करने के लिए ड्रॉपआउट लगाना चाहता हूँ। मेरी यह भावना है कि ड्रॉपआउट परत को पूलिंग परत के बाद लागू किया जाना चाहिए, लेकिन मेरे पास वास्तव में ऐसा कुछ भी नहीं है। ड्रॉपआउट परत को जोड़ने के लिए सही जगह कहां है? पूलिंग लेयर से पहले या बाद में?

Answer 1

संपादित करें: जैसा कि @Toke Faurby ने सही ढंग से बताया है, टेंसोफ़्लो में डिफ़ॉल्ट कार्यान्वयन वास्तव में एक तत्व-वार ड्रॉपआउट का उपयोग करता है। मैंने पहले जो वर्णन किया था वह CNNs में एक विशिष्ट संस्करण पर लागू होता है, जिसे स्थानिक ड्रॉपआउट कहा जाता है :

CNN में, प्रत्येक न्यूरॉन एक फीचर मैप तैयार करता है। चूंकि ड्रॉपआउट स्थानिक ड्रॉपआउट प्रति-न्यूरॉन काम करता है, इसलिए न्यूरॉन छोड़ने का मतलब है कि संबंधित फीचर मैप को गिरा दिया गया है - उदाहरण के लिए प्रत्येक स्थिति का एक ही मूल्य (आमतौर पर 0) है। तो प्रत्येक सुविधा का नक्शा या तो पूरी तरह से गिरा हुआ है या बिल्कुल भी नहीं गिरा है।

पूलिंग आमतौर पर प्रत्येक फीचर मैप पर अलग से संचालित होती है, इसलिए यदि आप पूलिंग से पहले या बाद में ड्रॉपआउट लागू करते हैं तो इससे कोई फर्क नहीं पड़ना चाहिए। कम से कम यह अधिकतम संचालन या औसत जैसे पूलिंग संचालन के लिए मामला है।

संपादित करें: हालांकि, यदि आप वास्तव में तत्व-वार ड्रॉपआउट का उपयोग करते हैं (जो कि टेंसोफ़्लो के लिए डिफ़ॉल्ट के रूप में सेट किया गया लगता है), तो यह वास्तव में एक फर्क पड़ता है यदि आप पूलिंग से पहले या बाद में ड्रॉपआउट लागू करते हैं। हालांकि, इसे करने का कोई गलत तरीका नहीं है । औसत पूलिंग ऑपरेशन पर विचार करें: यदि आप पूलिंग से पहले ड्रॉपआउट लागू करते हैं, तो आप परिणामी न्यूरॉन सक्रियणों को प्रभावी ढंग से मापते हैं 1.0 - dropout_probability, लेकिन अधिकांश न्यूरॉन गैर-शून्य (सामान्य रूप से) होंगे। यदि आप औसत पूलिंग के बाद ड्रॉपआउट लागू करते हैं, तो आप आम तौर पर (1.0 - dropout_probability)गैर-शून्य "अनकल्क्ड" न्यूरॉन सक्रियणों के एक अंश और dropout_probabilityशून्य न्यूरॉन्स के एक अंश के साथ समाप्त होते हैं। दोनों मेरे लिए व्यवहार्य लगते हैं, न ही गलत है।

Comments

मुझे यकीन नहीं है कि यह ड्रॉपआउट प्रदर्शन का मानक तरीका है। जैसे tf.nn.dropout में यह कहा गया है "डिफ़ॉल्ट रूप से, प्रत्येक तत्व को स्वतंत्र रूप से रखा या गिराया जाता है"। क्या आपके पास इसका स्रोत है?

— फॉकबी

ओह! मैंने जो वर्णन किया है, उसे अब स्थानिक ड्रॉपआउट कहा जाता है : arxiv.org/pdf/1411.4280.pdf । इसलिए @TokeFaurby मेरे दावे पर संदेह करने में सही है। हालाँकि, जैसा कि आप लिंक किए गए पेपर में भी पढ़ सकते हैं, स्थानिक ड्रॉपआउट तरीके से संपूर्ण फ़ीचर मैप छोड़ने से प्रदर्शन में सुधार होता है। यह कोई आश्चर्य की बात पर आता है, आसन्न सक्रियण अत्यधिक सहसंबद्ध और छोड़ने एक विशिष्ट तत्व वास्तव में नहीं है कर रहे हैं के रूप में ड्रॉप जानकारी सभी को उस तत्व के द्वारा किया जाता है (क्योंकि यह बहुत जब यह कर रही एक विशेषता मानचित्र में एक सतत "छेद" ड्रॉप की संभावना नहीं है तत्व अनुसार)। मैं इस अंतर को दर्शाने के लिए अपना उत्तर संपादित करूँगा।

— schreon

Answer 2

यह ट्यूटोरियल ड्रॉपआउट से पहले पूलिंग का उपयोग करता है और अच्छे परिणाम प्राप्त करता है।

इसका मतलब यह नहीं है कि अन्य आदेश निश्चित रूप से काम नहीं करता है। मेरा अनुभव सीमित है, मैंने केवल उन्हें पूलिंग के बिना घने परतों पर उपयोग किया है।

Answer 3

केरास से वीजीजी जैसे काफिले का उदाहरण (पूलिंग के बाद इस्तेमाल किया जाने वाला ड्रॉपआउट):

import numpy as np
import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras.optimizers import SGD

# Generate dummy data
x_train = np.random.random((100, 100, 100, 3))
y_train = keras.utils.to_categorical(np.random.randint(10, size=(100, 1)), num_classes=10)
x_test = np.random.random((20, 100, 100, 3))
y_test = keras.utils.to_categorical(np.random.randint(10, size=(20, 1)), num_classes=10)

model = Sequential()
# input: 100x100 images with 3 channels -> (100, 100, 3) tensors.
# this applies 32 convolution filters of size 3x3 each.
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(100, 100, 3)))
model.add(Conv2D(32, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))

sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer=sgd)

model.fit(x_train, y_train, batch_size=32, epochs=10)
score = model.evaluate(x_test, y_test, batch_size=32)