ग्रहणशील क्षेत्र के आकार की गणना कैसे करें?

Question

मैं ऑब्जेक्ट डिटेक्शन के लिए सीएनएन (कनवॉल्यूशनल तंत्रिका नेटवर्क) का उपयोग करने के बारे में पेपर पढ़ रहा हूं।

The pool5 feature map is 6x6x256 = 9216 dimensional. Ignoring boundary effects, each pool5 unit has a receptive field of 195x195 pixels in the original 227x227 pixel input. A central pool5 unit has a nearly global view, 
while one near the edge has a smaller, clipped support. 

मेरे सवाल कर रहे हैं:

1. ग्रहणशील क्षेत्र की परिभाषा क्या है

   Rich feature hierarchies for accurate object detection and semantic segmentation

   यहाँ ग्रहणशील क्षेत्र के बारे में एक उद्धरण है?

2. वे ग्रहणशील क्षेत्र के आकार और स्थान की गणना कैसे करते हैं?
3. कैफी/पायकाफ का उपयोग करके हम ग्रहणशील क्षेत्र के बाध्यकारी आय की गणना कैसे कर सकते हैं?

Answer 1

1) यह पिक्सेल के क्षेत्र का आकार है जो अंतिम संकल्प के उत्पादन को प्रभावित करता है।

2) प्रत्येक रूपांतरण और पूलिंग ऑपरेशन के लिए, आउटपुट के आकार की गणना करें। अब इनपुट आकार ढूंढें जिसके परिणामस्वरूप 1x1 का आउटपुट आकार होता है। ग्रहणशील क्षेत्र का आकार

3) आपको ऐसा करने के लिए लाइब्रेरी का उपयोग करने की आवश्यकता नहीं है। प्रत्येक 2x2 पूलिंग के लिए आउटपुट आकार प्रत्येक आयाम के साथ आधे से कम हो जाता है। घुमावदार संकल्पों के लिए, आप प्रत्येक आयाम के आकार को भी विभाजित करते हैं। यदि आप अपने संकल्पों के लिए पैडिंग का उपयोग करते हैं, तो आपको कुछ आयामों को दाढ़ी देना पड़ सकता है। सबसे आसान मामला पैडिंग = फर्श (कर्नेल आकार/2) का उपयोग करना है, ताकि एक रूपांतरण की खुराक में आउटपुट आकार पर कोई अतिरिक्त परिवर्तन न हो।

Answer 2

यहां पाइथन स्क्रिप्ट है जो आरएफ आकार की गणना करता है और आउटपुट के आकार के अलावा।

# [filter size, stride, padding] 

convnet =[[11,4,0],[3,2,0],[5,1,2],[3,2,0],[3,1,1],[3,1,1],[3,1,1],[3,2,0],[6,1,0]] 
layer_name = ['conv1','pool1','conv2','pool2','conv3','conv4','conv5','pool5','fc6-conv'] 
imsize = 227 


def outFromIn(isz, layernum = 9, net = convnet): 
    if layernum>len(net): layernum=len(net) 

    totstride = 1 
    insize = isz 
    #for layerparams in net: 
    for layer in range(layernum): 
     fsize, stride, pad = net[layer] 
     outsize = (insize - fsize + 2*pad)/stride + 1 
     insize = outsize 
     totstride = totstride * stride 

    RFsize = isz - (outsize - 1) * totstride 

    return outsize, totstride, RFsize 

if __name__ == '__main__': 

    print "layer output sizes given image = %dx%d" % (imsize, imsize) 
    for i in range(len(convnet)): 
     p = outFromIn(imsize,i+1) 
     print "Layer Name = %s, Output size = %3d, Stride = % 3d, RF size = %3d" % (layer_name[i], p[0], p[1], p[2]) 

Answer 3

जैसा कि ऊपर, आरएफ की संभवतः सही गणना के साथ:

#Compute input size that leads to a 1x1 output size, among other things 

# [filter size, stride, padding] 

convnet =[[11,4,0],[3,2,0],[5,1,2],[3,2,0],[3,1,1],[3,1,1],[3,1,1],[3,2,0],[6,1,0]] 
layer_name = ['conv1','pool1','conv2','pool2','conv3','conv4','conv5','pool5','fc6-conv'] 
imsize = 227 

def outFromIn(isz, layernum = 9, net = convnet): 
    if layernum>len(net): layernum=len(net) 

    totstride = 1 
    insize = isz 
    #for layerparams in net: 
    for layer in range(layernum): 
     fsize, stride, pad = net[layer] 
     outsize = (insize - fsize + 2*pad)/stride + 1 
     insize = outsize 
     totstride = totstride * stride 
    return outsize, totstride 

def inFromOut(layernum = 9, net = convnet): 
    if layernum>len(net): layernum=len(net) 
    outsize = 1 
    #for layerparams in net: 
    for layer in reversed(range(layernum)): 
     fsize, stride, pad = net[layer] 
     outsize = ((outsize -1)* stride) + fsize 
    RFsize = outsize 
    return RFsize 

if __name__ == '__main__': 

    print "layer output sizes given image = %dx%d" % (imsize, imsize) 
    for i in range(len(convnet)): 
     p = outFromIn(imsize,i+1) 
     rf = inFromOut(i+1) 
     print "Layer Name = %s, Output size = %3d, Stride = % 3d, RF size = %3d" % (layer_name[i], p[0], p[1], rf) 

Answer 4

यहाँ एक और तरीका सीधे ग्रहणशील क्षेत्र की गणना करता है। Stackoverflow गणित सूत्र का समर्थन नहीं करता, एक अधिक पठनीय संस्करण के लिए, कृपया http://shawnleezx.github.io/blog/2017/02/11/calculating-receptive-field-of-cnn/

ग्रहणशील क्षेत्र (आरएफ) परत $ कश्मीर $ के $ l_k $ का उल्लेख है:

$$ 
    l_k = l_{k-1} + ((f_k - 1) * \prod_{i=1}^{k-1}s_i) 
$$ 

जहां $ L_ {k- 1} $ परत $ k-1 $ का ग्रहणशील क्षेत्र है, $ f_k $ फ़िल्टर आकार (ऊंचाई या चौड़ाई है, लेकिन मानते हैं कि वे यहां समान हैं), और $ s_i $ स्ट्रिंग परत $ i $ है ।

उपरोक्त सूत्र नीचे से ऊपर ग्रहणशील क्षेत्र की गणना करता है (परत 1 से)। सहजता से, परत $ k $ $ $ $ ($__-1) $ s $ {f-k =} $ s पिक्सल परत $ k-1 $ के साथ सापेक्ष रूप से आरएफ में $ R $ कवर करता है। हालांकि, वृद्धि को पहली परत में अनुवादित करने की आवश्यकता है, इसलिए वृद्धि एक फैक्टोरियल है --- परत $ k-1 $ में एक स्ट्रॉइड निचली परतों में तेजी से अधिक प्रगति है।

आशा है कि यह सहायक होगा।

Answer 5

Tensorflow अब बस tf.contrib.receptive_field

का उपयोग कर जानकारी के लिए https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/receptive_field देखें द्वारा, ग्रहणशील क्षेत्र गणना का समर्थन करता है।