tensorflow
टीएफ में उन्नत उदाहरणों के साथ 2 डी के पीछे गणित

परिचय

कोई पैडिंग, स्ट्राइड = 1 नहीं

सबसे आसान गणना के साथ यह सबसे बुनियादी उदाहरण है। मान लें कि आपका input और kernel हैं:

जब आप अपना कर्नेल करेंगे तो आपको निम्न आउटपुट प्राप्त होंगे: , जिसकी गणना निम्नलिखित तरीके से की जाती है:

• 14 = 4 * 1 + 3 * 0 + 1 * 1 + 2 * 2 + 1 * 1 + 0 * 0 + 1 * 0 + 2 * 0 + 4 * 1
• 6 = 3 * 1 + 1 * 0 + 0 * 1 + 1 * 2 + 0 * 1 + 1 * 0 + 2 * 0 + 4 * 0 + 1 * 1
• 6 = 2 * 1 + 1 * 0 + 0 * 1 + 1 * 2 + 2 * 1 + 4 * 0 + 3 * 0 + 1 * 0 + 0 * 1
• 12 = 1 * 1 + 0 * 0 + 1 * 1 + 2 * 2 + 4 * 1 + 1 * 0 + 1 * 0 + 0 * 0 + 2 * 1

TF का conv2d फ़ंक्शन बैचों में संकल्पों की गणना करता है और थोड़ा अलग प्रारूप का उपयोग करता है। इनपुट के लिए यह कर्नेल के लिए [batch, in_height, in_width, in_channels] है, यह [filter_height, filter_width, in_channels, out_channels] । इसलिए हमें सही प्रारूप में डेटा प्रदान करने की आवश्यकता है:

import tensorflow as tf
k = tf.constant([
    [1, 0, 1],
    [2, 1, 0],
    [0, 0, 1]
], dtype=tf.float32, name='k')
i = tf.constant([
    [4, 3, 1, 0],
    [2, 1, 0, 1],
    [1, 2, 4, 1],
    [3, 1, 0, 2]
], dtype=tf.float32, name='i')
kernel = tf.reshape(k, [3, 3, 1, 1], name='kernel')
image  = tf.reshape(i, [1, 4, 4, 1], name='image')

बाद में दृढ़ संकल्प के साथ गणना की जाती है:

res = tf.squeeze(tf.nn.conv2d(image, kernel, [1, 1, 1, 1], "VALID"))
# VALID means no padding
with tf.Session() as sess:
   print sess.run(res)

और हमारे द्वारा गणना की गई हाथ के बराबर होगी।

कुछ गद्दी, तार = १

पैडिंग केवल बताने का एक फैंसी नाम है: कुछ स्थिर के साथ अपने इनपुट मैट्रिक्स को घेरें। अधिकांश मामलों में स्थिरांक शून्य होता है और यही कारण है कि लोग इसे शून्य गद्दी कहते हैं। इसलिए यदि आप हमारे मूल इनपुट में 1 का एक पैडिंग का उपयोग करना चाहते हैं ( padding=0, strides=1 साथ पहला उदाहरण देखें), मैट्रिक्स इस तरह दिखेगा:

सजा के मूल्यों की गणना करने के लिए आप एक ही स्लाइडिंग करते हैं। ध्यान दें कि हमारे मामले में मध्य में कई मूल्यों को पुनर्गणना करने की आवश्यकता नहीं है (वे पिछले उदाहरण में समान होंगे। मैं यहां सभी गणनाओं को भी नहीं दिखाऊंगा, क्योंकि विचार सीधे-सीधे है। परिणाम है:

कहाँ पे

• 5 = 0 * 1 + 0 * 0 + 0 * 1 + 0 * 2 + 4 * 1 + 3 * 0 + 0 * 0 + 0 * 1 + 1 * 1
• ...
• 6 = 4 * 1 + 1 * 0 + 0 * 1 + 0 * 2 + 2 * 1 + 0 * 0 + 0 * 0 * 0 + 0 * 0 + 1 * 1

TF2 समारोह में मनमाने ढंग से पैडिंग का समर्थन नहीं करता है, इसलिए यदि आपको कुछ ऐसे पैडिंग की आवश्यकता है जो समर्थित नहीं है, तो tf.pad () का उपयोग करें। सौभाग्य से हमारे इनपुट के लिए पैडिंग 'SAME' पैडिंग = 1 के बराबर होगा। इसलिए हमें अपने पिछले उदाहरण में लगभग कुछ भी नहीं बदलने की आवश्यकता है:

res = tf.squeeze(tf.nn.conv2d(image, kernel, [1, 1, 1, 1], "SAME"))
# 'SAME' makes sure that our output has the same size as input and 
# uses appropriate padding. In our case it is 1.
with tf.Session() as sess:
   print sess.run(res)

आप सत्यापित कर सकते हैं कि उत्तर हाथ से गणना के समान होगा।

पैडिंग और स्ट्राइड्स (सबसे सामान्य मामला)

अब हम अपने पहले से वर्णित गद्देदार उदाहरण के लिए एक तार दी गई सजा लागू करेंगे और उस गणना की गणना करेंगे जहाँ p = 1, s = 2

पहले जब हम strides = 1 उपयोग करते थे, तो हमारा स्लेज विंडो 1 पोजीशन पर आ जाता है, strides = s साथ strides = s यह s पोजीशन से आगे बढ़ता है (आपको s^2 एलिमेंट्स को कम करने की आवश्यकता है। लेकिन हमारे मामले में हम एक शॉर्टकट ले सकते हैं और कोई भी प्रदर्शन नहीं कर सकते हैं। सभी पर संगणना। क्योंकि हमने पहले से ही s = 1 के मूल्यों की गणना की है, हमारे मामले में हम प्रत्येक दूसरे तत्व को पकड़ सकते हैं।

तो अगर समाधान s = 1 का मामला है

s = 2 मामले में यह होगा:

पिछले मैट्रिक्स में मान 14, 2, 12, 6 के पदों की जाँच करें। हमारे कोड में प्रदर्शन करने के लिए एकमात्र परिवर्तन चौड़ाई और ऊंचाई आयाम (2-nd, 3-rd) के लिए 1 से 2 तक के परिवर्तन को बदलना है।

res = tf.squeeze(tf.nn.conv2d(image, kernel, [1, 2, 2, 1], "SAME"))
with tf.Session() as sess:
   print sess.run(res)

वैसे, ऐसा कुछ भी नहीं है जो हमें विभिन्न आयामों के लिए अलग-अलग तारों का उपयोग करने से रोकता है।