Tensorflow Strides Argument

Question

मैं स्ट्राइड को समझने की कोशिश कर रहा हूं tf.nn.avg_pool, tf.nn.max_pool, tf.nn.conv2d में तर्क।

प्रलेखन बार-बार कहते हैं

strides: एक किलों की एक सूची जिसमें लंबाई है = = 4. इनपुट टेंसर के प्रत्येक आयाम के लिए स्लाइडिंग विंडो की स्ट्राइड।

मेरे प्रश्न हैं:

1. 4+ पूर्णांक में से प्रत्येक क्या दर्शाता है?
2. वे क्यों [0] = स्ट्राइड्स [3] = 1 के लिए काफिलों से टकराए होंगे?
3. में इस उदाहरण हम देखते हैं tf.reshape(_X,shape=[-1, 28, 28, 1])। क्यों -1

उदासी के उदाहरणों में उदासीनता के उदाहरण -1 का उपयोग करके इस परिदृश्य में बहुत अच्छा अनुवाद न करें।

Answer 1

पूलिंग और कनफ़ेक्शनल ऑप्स इनपुट टेंसर के पार एक "विंडो" स्लाइड करते हैं। tf.nn.conv2dएक उदाहरण के रूप में उपयोग करना : यदि इनपुट टेंसर के 4 आयाम हैं: [batch, height, width, channels]तो, कन्वेंशन height, widthआयामों पर 2 डी विंडो पर संचालित होता है ।

stridesनिर्धारित करता है कि प्रत्येक आयाम में खिड़की कितनी शिफ्ट होती है। विशिष्ट उपयोग पहले (बैच) और अंतिम (गहराई) 1 के समीप सेट करता है।

आइए एक बहुत ही ठोस उदाहरण का उपयोग करें: 32x32 ग्रेस्केल इनपुट छवि पर 2-डी कनवल्शन चलाना। मैं कहता हूं कि greyscale क्योंकि तब इनपुट छवि में गहराई = 1 होती है, जो इसे सरल रखने में मदद करती है। उस छवि को इस तरह देखें:

00 01 02 03 04 ...
10 11 12 13 14 ...
20 21 22 23 24 ...
30 31 32 33 34 ...
...

एक एकल उदाहरण (बैच आकार = 1) पर 2x2 कनवेंशन विंडो चलाते हैं। हम कनवल्शन को 8 के आउटपुट चैनल की गहराई देंगे।

सजा के लिए इनपुट है shape=[1, 32, 32, 1]।

यदि आप निर्दिष्ट strides=[1,1,1,1]करते हैं padding=SAME, तो फ़िल्टर का आउटपुट [1, 32, 32, 8] होगा।

फ़िल्टर पहले इसके लिए एक आउटपुट बनाएगा:

F(00 01
  10 11)

और फिर इसके लिए:

F(01 02
  11 12)

और इसी तरह। फिर यह गणना करते हुए दूसरी पंक्ति में चला जाएगा:

F(10, 11
  20, 21)

फिर

F(11, 12
  21, 22)

यदि आप [1, 2, 2, 1] की स्ट्राइड निर्दिष्ट करते हैं, तो यह ओवरलैपिंग विंडोज़ नहीं करेगा। यह गणना करेगा:

F(00, 01
  10, 11)

और फिर

F(02, 03
  12, 13)

स्ट्राइड पूलिंग ऑपरेटरों के लिए समान रूप से संचालित होता है।

प्रश्न 2: क्यों [1, एक्स, वाई, 1] काफिलों के लिए

पहला 1 बैच है: आप आमतौर पर अपने बैच में उदाहरणों को छोड़ना नहीं चाहते हैं, या आपको उन्हें पहली जगह में शामिल नहीं करना चाहिए। :)

अंतिम 1 दीक्षांत की गहराई है: आप आमतौर पर इसी कारण से इनपुट को छोड़ना नहीं चाहते हैं।

Conv2d ऑपरेटर अधिक सामान्य है, इसलिए आप ऐसे कॉन्फोल्यूशन बना सकते हैं जो विंडो को अन्य आयामों के साथ स्लाइड करते हैं, लेकिन यह कंफर्टसेट में एक विशिष्ट उपयोग नहीं है। विशिष्ट उपयोग उन्हें स्थानिक रूप से उपयोग करना है।

क्यों -1 -1 में फेरबदल एक प्लेसहोल्डर है जो कहता है कि "पूर्ण टेंसर के लिए आवश्यक आकार से मेल खाने के लिए आवश्यक रूप से समायोजित करें।" यह कोड को इनपुट बैच आकार से स्वतंत्र बनाने का एक तरीका है, ताकि आप अपनी पाइपलाइन को बदल सकें और कोड में बैच आकार को हर जगह समायोजित न करना पड़े।

Comments

@ डेरेक क्योंकि (पाठ से) "हम कनवल्शन को एक आउटपुट चैनल की गहराई देंगे 8."। यह कुछ ऐसा है जिसे आप

— कनविक्शन

Answer 2

इनपुट 4 आयामी हैं और फॉर्म के हैं: [batch_size, image_rows, image_cols, number_of_colors]

सामान्य तौर पर स्ट्राइड्स, अप्लाई ऑपरेशंस के बीच एक ओवरलैप को परिभाषित करते हैं। Conv2d के मामले में, यह निर्दिष्ट करता है कि लगातार फ़िल्टर के लगातार अनुप्रयोगों के बीच की दूरी क्या है। किसी विशिष्ट आयाम में 1 का मान का अर्थ है कि हम ऑपरेटर को प्रत्येक पंक्ति / कॉल पर लागू करते हैं, 2 के मान का अर्थ है हर सेकंड, और इसी तरह।

1) पुनरावृत्तियों के लिए मायने रखने वाले मान 2 और 3 हैं और वे पंक्तियों और स्तंभों के साथ दृढ़ फिल्टर के अनुप्रयोग में ओवरलैप का प्रतिनिधित्व करते हैं। [1, 2, 2, 1] का मान कहता है कि हम हर दूसरी पंक्ति और कॉलम पर फ़िल्टर लागू करना चाहते हैं।

2) मैं तकनीकी सीमाओं (CuDNN आवश्यकता हो सकती है ) को नहीं जानता, लेकिन आमतौर पर लोग पंक्तियों या स्तंभों के आयामों का उपयोग करते हैं। यह जरूरी नहीं है कि यह बैच आकार पर करने के लिए समझ में आता है। अंतिम आयाम के बारे में निश्चित नहीं है।

3) आयाम में से किसी एक के लिए -1 सेट करने का मतलब है, "पहले आयाम के लिए मूल्य निर्धारित करें ताकि टेंसर में तत्वों की कुल संख्या अपरिवर्तित हो"। हमारे मामले में, -1 बैच_साइज के बराबर होगा।

Answer 3

1-मंद मामले में स्ट्राइड क्या करता है, इसके साथ शुरू करते हैं।

चलिए मान लेते हैं कि आपका input = [1, 0, 2, 3, 0, 1, 1]और kernel = [2, 1, 3]कनविक्शन का नतीजा है [8, 11, 7, 9, 4], जो इनपुट पर आपके कर्नेल को स्लाइड करके, तत्व-वार गुणा का प्रदर्शन करके और सब कुछ समेट कर गणना की जाती है। इस तरह :

• 8 = 1 * 2 + 0 * 1 + 2 * 3
• ११ = ० * २ + २ * १ + ३ * ३
• 7 = 2 * 2 + 3 * 1 + 0 * 3
• 9 = 3 * 2 + 0 * 1 + 1 * 3
• 4 = 0 * 2 + 1 * 1 + 1 * 3

यहां हम एक तत्व द्वारा स्लाइड करते हैं, लेकिन किसी भी अन्य संख्या का उपयोग करके आपको कुछ भी नहीं रोकता है। यह नंबर आपका स्ट्राइड है। आप इसके बारे में सोच सकते हैं कि प्रत्येक एस-वें परिणाम को लेने के द्वारा 1-तारित कनवल्शन का परिणाम घटाया जाता है।

इनपुट आकार i , कर्नेल आकार k , स्ट्राइड s और पैडिंग p को जानने के बाद आप आसानी से कनवल्शन के आउटपुट आकार की गणना कर सकते हैं:

यहाँ || ऑपरेटर का मतलब है सीलिंग ऑपरेशन। पूलिंग परत के लिए s = 1।

---

एन-मंद मामला।

1-मंद मामले के लिए गणित को जानना, एक बार जब आप देखेंगे कि प्रत्येक मंद स्वतंत्र है, तो एन-मंद मामला आसान है। तो आप प्रत्येक आयाम को अलग से स्लाइड करें। यहाँ 2-d के लिए एक उदाहरण है । ध्यान दें कि आपको सभी आयामों पर समान प्रगति की आवश्यकता नहीं है। तो एन-मंद इनपुट / कर्नेल के लिए आपको एन स्ट्राइड प्रदान करना चाहिए।

---

इसलिए अब आपके सभी सवालों का जवाब देना आसान है:

1. 4+ पूर्णांक में से प्रत्येक क्या दर्शाता है? । conv2d , पूल आपको बताता है कि यह सूची प्रत्येक आयाम के बीच प्रगति का प्रतिनिधित्व करती है। ध्यान दें कि स्ट्राइड लिस्ट की लंबाई कर्नेल टेंसर की रैंक के समान है।
2. वे क्यों [0] = स्ट्राइड 3 = 1 काफिले के लिए होना चाहिए? । पहला आयाम बैच आकार है, अंतिम चैनल है। यहां न तो बैच लगाने की कोई बात है और न ही चैनल की। तो आप उन्हें बनाते हैं 1. चौड़ाई / ऊँचाई के लिए आप कुछ छोड़ सकते हैं और इसीलिए वे 1 नहीं हो सकते हैं।
3. tf.reshape (_X, आकार = [- 1, 28, 28, 1])। क्यों -1 tf.reshape ने इसे आपके लिए कवर किया है:

   यदि आकार का एक घटक विशेष मान -1 है, तो उस आयाम के आकार की गणना की जाती है ताकि कुल आकार स्थिर रहे। विशेष रूप से, [-1] का आकार 1-डी में समतल होता है। आकार के अधिकतम एक घटक पर -1 हो सकता है।

Answer 4

@dga ने समझाते हुए एक अद्भुत काम किया है और मैं इस बात के लिए आभारी नहीं हूं कि यह कितना उपयोगी रहा। इसी तरह से, मैं stride3D निष्कर्ष में कैसे काम करता है, इस पर अपने निष्कर्षों को साझा करना चाहूंगा ।

T3orFlow डॉक्यूमेंट के अनुसार conv3d पर, इनपुट का आकार इस क्रम में होना चाहिए:

[batch, in_depth, in_height, in_width, in_channels]

आइए एक उदाहरण का उपयोग करके चर को दाईं ओर से बाईं ओर समझाएं। मान लें कि इनपुट आकार है input_shape = [1000,16,112,112,3]

input_shape[4] is the number of colour channels (RGB or whichever format it is extracted in)
input_shape[3] is the width of the image
input_shape[2] is the height of the image
input_shape[1] is the number of frames that have been lumped into 1 complete data
input_shape[0] is the number of lumped frames of images we have.

नीचे एक सार प्रलेखन है कि स्ट्राइड का उपयोग कैसे किया जाता है।

strides: लंबाई में => 5. 5.-D दसियों की लंबाई वाले किलों की एक सूची। इनपुट के प्रत्येक आयाम के लिए स्लाइडिंग विंडो की स्ट्राइड। होना आवश्यक हैstrides[0] = strides[4] = 1

जैसा कि कई कामों में संकेत दिया गया है, स्ट्राइड्स का मतलब है कि कितने कदम दूर एक खिड़की या कर्नेल निकटतम तत्व से दूर हो जाता है, यह एक डेटा फ्रेम या पिक्सेल हो सकता है (यह जिस तरह से पैराफ्रेस्ड है)।

उपरोक्त प्रलेखन से, 3 डी में एक स्ट्राइड इस तरह दिखाई देगा = (1, एक्स , वाई , जेड , 1)।

प्रलेखन उस पर जोर देता है strides[0] = strides[4] = 1।

strides[0]=1 means that we do not want to skip any data in the batch 
strides[4]=1 means that we do not want to skip in the channel 

स्ट्राइड्स [X] का अर्थ है कि हम कितने ढेलेदार फ्रेम में बनाना चाहिए। इसलिए, उदाहरण के लिए, यदि हमारे पास 16 फ्रेम हैं, तो X = 1 का अर्थ है कि हर फ्रेम का उपयोग करें। एक्स = 2 का मतलब है कि हर दूसरे फ्रेम का उपयोग करें और यह आगे बढ़ता है

strides [y] और strides [z] @dga द्वारा स्पष्टीकरण का पालन करें ताकि मैं उस हिस्से को फिर से न करूँ।

हालांकि केरस में, आपको केवल 3 पूर्णांक की एक टपल / सूची को निर्दिष्ट करने की आवश्यकता है, प्रत्येक स्थानिक आयाम के साथ कनवल्शन के स्ट्राइड्स को निर्दिष्ट करते हुए, जहां स्थानिक आयाम [x], स्ट्राइड [y] और strides [z] है। स्ट्राइड्स [0] और स्ट्राइड्स [4] पहले से ही डिफॉल्ट 1 हो गया है।

मुझे आशा है कि किसी को यह उपयोगी लगता है!