tensorflow
1D दृढ़ संकल्प का उपयोग करना

मूल उदाहरण

अद्यतन: TensorFlow अब संस्करण r0.11 के बाद से 1D कन्वेंशन का समर्थन करता है, tf.nn.conv1d का उपयोग कर।

लंबाई 10 और आयाम 16 इनपुट के साथ एक मूल उदाहरण पर विचार करें। बैच का आकार 32 । इसलिए हमारे पास इनपुट आकार [batch_size, 10, 16] साथ एक प्लेसहोल्डर है।

batch_size = 32
x = tf.placeholder(tf.float32, [batch_size, 10, 16])

फिर हम चौड़ाई 3 के साथ एक फ़िल्टर बनाते हैं, और हम 16 चैनल इनपुट के रूप में लेते हैं, और आउटपुट भी 16 चैनल।

filter = tf.zeros([3, 16, 16])  # these should be real values, not 0

अंत में हम एक स्ट्राइड और एक गद्दी के साथ tf.nn.conv1d लागू tf.nn.conv1d :

• stride : पूर्णांक s
• गद्दी : यह 2D की तरह काम करता है, आप SAME और VALID बीच चयन कर सकते हैं। SAME ही इनपुट लंबाई का उत्पादन करेगा, जबकि VALID शून्य पैडिंग नहीं जोड़ेगा।

हमारे उदाहरण के लिए हम एक स्ट्राइड 2 लेते हैं, और एक वैध पैडिंग।

output = tf.nn.conv1d(x, filter, stride=2, padding="VALID")

आउटपुट का आकार [batch_size, 4, 16] होना चाहिए।
padding="SAME" , हमारे पास [batch_size, 5, 16] का आउटपुट आकार होता।

TensorFlow के पिछले संस्करणों के लिए, आप इनपुट्स की ऊँचाई और फ़िल्टर को 1 सेट करते समय केवल 2D कनवल्शन का उपयोग कर सकते हैं।

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

`हाथ से 1 डी कन्वेंशन की गणना करने के लिए, आप इनपुट पर अपने कर्नेल को स्लाइड करते हैं, तत्व-वार गुणाओं की गणना करते हैं और उन्हें योग करते हैं।

सबसे आसान तरीका पैडिंग = 0, स्ट्राइड = 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

TF का conv1d फ़ंक्शन बैचों में दीक्षांतों की गणना करता है, इसलिए TF में ऐसा करने के लिए, हमें सही प्रारूप में डेटा प्रदान करने की आवश्यकता है (डॉक्टर बताते हैं कि इनपुट [batch, in_width, in_channels] होना चाहिए, यह बताता है कि कर्नेल को कैसे देखना चाहिए। पसंद)। इसलिए

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

print i, '\n', k, '\n'

data   = tf.reshape(i, [1, int(i.shape[0]), 1], name='data')
kernel = tf.reshape(k, [int(k.shape[0]), 1, 1], name='kernel')

print data, '\n', kernel, '\n'

res = tf.squeeze(tf.nn.conv1d(data, kernel, 1, 'VALID'))
with tf.Session() as sess:
    print sess.run(res)

जो आपको वही उत्तर देगा जिसकी हमने पहले गणना की थी: [ 8. 11. 7. 9. 4.]

पैडिंग के साथ बातचीत

पैडिंग एपेंड को बताने और कुछ मूल्य के साथ अपने इनपुट को प्रस्तुत करने का एक फैंसी तरीका है। अधिकांश मामलों में यह मान 0 है, और यही कारण है कि ज्यादातर लोग इसे शून्य-गद्दी का नाम देते हैं। TF समर्थन 'VALID' और 'SAME' शून्य-गद्दी, मनमाने ढंग से पैडिंग के लिए आपको tf.pad () का उपयोग करने की आवश्यकता है। 'वैलिड' पैडिंग का मतलब बिल्कुल भी पैडिंग नहीं है, जहां एक ही मतलब है कि आउटपुट में इनपुट का आकार समान होगा। आइए एक ही उदाहरण पर padding=1 साथ कनवल्शन की गणना करें (ध्यान दें कि हमारे कर्नेल के लिए यह 'SAME' पैडिंग है)। ऐसा करने के लिए, हम शुरुआत / अंत में अपने सरणी को 1 शून्य के साथ जोड़ते हैं: input = [0, 1, 0, 2, 3, 0, 1, 1, 0] ।

यहाँ आप देख सकते हैं कि आपको हर चीज़ को पुनर्गणना करने की आवश्यकता नहीं है: सभी तत्व पहले / अंतिम एक को छोड़कर समान हैं:

• 1 = 0 * 2 + 1 * 1 + 0 * 3
• 3 = 1 * 2 + 1 * 1 + 0 * 3

इसलिए परिणाम [1, 8, 11, 7, 9, 4, 3] जो TF के साथ गणना के समान है:

res = tf.squeeze(tf.nn.conv1d(data, kernel, 1, 'SAME'))
with tf.Session() as sess:
    print sess.run(res)

प्रगति के साथ बातचीत

स्लाइडिंग करते समय स्ट्राइड आपको तत्वों को छोड़ने की अनुमति देता है। हमारे सभी पिछले उदाहरणों में हमने 1 तत्व को स्लेज किया था, अब आप एक बार में s तत्वों को स्लाइड कर सकते हैं। क्योंकि हम पिछले उदाहरण का उपयोग करेंगे, एक चाल है: n तत्वों द्वारा फिसलने 1 तत्व द्वारा फिसलने के बराबर है और प्रत्येक n-th तत्व का चयन करता है।

इसलिए अगर हम अपने पिछले उदाहरण का उपयोग padding=1 और stride को 2 में बदलते हैं, तो आप बस पिछला परिणाम लेते हैं [1, 8, 11, 7, 9, 4, 3] और प्रत्येक 2-nd तत्व को छोड़ दें, जिसके परिणामस्वरूप परिणाम आएगा [1, 11, 9, 3] । आप इसे निम्न तरीके से TF में कर सकते हैं:

res = tf.squeeze(tf.nn.conv1d(data, kernel, 2, 'SAME'))
with tf.Session() as sess:
    print sess.run(res)