tensorflow batch_matmul कैसे काम करता है?

टेन्सफोर्लो के पास batch_matmul नामक एक फ़ंक्शन है जो उच्च आयामी टेंसर को गुणा करता है। लेकिन मुझे यह समझने में कठिनाई हो रही है कि यह कैसे काम करता है, शायद आंशिक रूप से क्योंकि मुझे इसे देखने में कठिनाई हो रही है।tensorflow batch_matmul कैसे काम करता है?

मुझे क्या करना चाहते हैं एक 3 डी टेन्सर के प्रत्येक टुकड़ा द्वारा एक मैट्रिक्स गुणा है, लेकिन मैं काफी समझ में नहीं आता क्या टेन्सर एक के आकार है। ज़ेड सबसे आंतरिक आयाम है? निम्न में से कौन सा सही है?

मैं सबसे पहले सही होने के लिए पसंद करेंगे - यह मेरे लिए सबसे सहज और आसान है .eval() उत्पादन में देखने के लिए। लेकिन मुझे संदेह है कि दूसरा सही है।

Tensorflow का कहना है कि batch_matmul करता है:

out[..., :, :] = matrix(x[..., :, :]) * matrix(y[..., :, :])

कि क्या मतलब है? मेरे उदाहरण के संदर्भ में इसका क्या अर्थ है? क्या गुणा किया जा रहा है? और मुझे एक 3 डी टेंसर क्यों मिल रहा है जिस तरह से मुझे उम्मीद थी?

स्रोत

2015-12-09 Alex Lenail

[tf.batch_matmul अब उपलब्ध नहीं है] (http://stackoverflow.com/a/ 43819275/1090562) –

आप इसे बैच में प्रत्येक प्रशिक्षण उदाहरण पर एक matmul करने के रूप में कल्पना कर सकते हैं।

उदाहरण के लिए, आप निम्नलिखित आयामों के साथ दो tensors अगर:

a.shape = [100,2,5] 
b.shape = [100,5,2]

और आप एक batch.matmul करना (ए, बी), अपने उत्पादन आकार होगा [100,2,2] ।

100 आपके बैच आकार है, अन्य दो आयाम आपके डेटा के आयाम हैं।

स्रोत

2015-12-09 16:53:52 Daniela

मुझे लगता है कि आप केवल आंशिक रूप से इस सवाल का जवाब दे रहे हैं। विशेष रूप से, आपके उदाहरण में बी का पहला आयाम 100 क्यों होना चाहिए? क्या होगा यदि मेरे पास एक टेंसर ए है, जो उदाहरणों का एक बैच है, और मैं उनमें से प्रत्येक पर नमूना ऑपरेशन लागू करना चाहता हूं, यानी मैं उनमें से प्रत्येक को बी से गुणा करना चाहता हूं, जो [5, 2] है। Tf.tile के साथ इसे पूरा करने का एकमात्र तरीका है? और यदि नहीं, तो batch_matmul के आउटपुट को कैसे परिभाषित किया जाता है? –

@AlexLenail: मेरे पास एक ही प्रश्न है - मैं 2 डी टेंसर की स्पष्ट टाइलिंग के बिना 2 डी टेंसर द्वारा 3 डी टेंसर को गुणा करना चाहता हूं। क्या आपको कोई जवाब मिला? – ahmadh

matmul –

-1

यह क्रमशः पहले आयाम पर विभाजन की तरह है, गुणा करें और उन्हें वापस संगत करें। यदि आप 2 डी द्वारा 3 डी करना चाहते हैं, तो आप इसे फिर से बदल सकते हैं, गुणा कर सकते हैं, और फिर से दोबारा बदल सकते हैं। अर्थात। [100, 2, 5] -> [200, 5] -> [200, 2] -> [100, 2, 2]

स्रोत

2016-05-28 16:42:54 Saurfang

अब आप टीएसफ़ोर्लो 0.11 से शुरू होने वाले tf.einsum का उपयोग करके इसे कर सकते हैं। 0 आरसी 0।

उदाहरण के लिए,

M1 = tf.Variable(tf.random_normal([2,3,4])) 
M2 = tf.Variable(tf.random_normal([5,4])) 
N = tf.einsum('ijk,lk->ijl',M1,M2)

यह एम 1 में हर बैच (2 बैचों) में हर फ्रेम (3 फ्रेम) के साथ मैट्रिक्स M2 गुणा।

उत्पादन होता है:

[array([[[ 0.80474716, -1.38590837, -0.3379252 , -1.24965811], 
     [ 2.57852983, 0.05492432, 0.23039417, -0.74263287], 
     [-2.42627382, 1.70774114, 1.19503212, 0.43006262]], 

     [[-1.04652011, -0.32753903, -1.26430523, 0.8810069 ], 
     [-0.48935518, 0.12831448, -1.30816901, -0.01271309], 
     [ 2.33260512, -1.22395933, -0.92082584, 0.48991606]]], dtype=float32), 
array([[ 1.71076882, 0.79229093, -0.58058828, -0.23246667], 
     [ 0.20446332, 1.30742455, -0.07969904, 0.9247328 ], 
     [-0.32047141, 0.66072595, -1.12330854, 0.80426538], 
     [-0.02781649, -0.29672042, 2.17819595, -0.73862702], 
     [-0.99663496, 1.3840003 , -1.39621222, 0.77119476]], dtype=float32), 
array([[[ 0.76539308, 2.77609682, -1.79906654, 0.57580602, -3.21205115], 
     [ 4.49365759, -0.10607499, -1.64613271, 0.96234947, -3.38823152], 
     [-3.59156275, 2.03910899, 0.90939498, 1.84612727, 3.44476724]], 

     [[-1.52062428, 0.27325237, 2.24773455, -3.27834225, 3.03435063], 
     [ 0.02695178, 0.16020992, 1.70085776, -2.8645196 , 2.48197317], 
     [ 3.44154787, -0.59687197, -0.12784094, -2.06931567, -2.35522676]]], dtype=float32)]

मैं सत्यापित किया है, गणित सही है।

स्रोत

2016-10-03 01:54:33 xuancong84

द्वारा समर्थित प्रसारण तंत्र का उपयोग करें बस एक छोटा सा संदेह, 'tf.einsum() '' batch_matmul(), matmul() 'जैसी अन्य विधियों की तुलना में तेज़ या धीमा है? मैं tensorflow में एक tensordot उत्पाद को कार्यान्वित करना चाहता हूं, लेकिन केवल 'einsum()' विधि केवल इसका समर्थन करने के लिए प्रतीत होता है और बाकी तरीकों को कुछ पुनः बदलने और फिर से प्रक्रियाओं को आकार देने की आवश्यकता होती है, इसलिए मैं जानना चाहता हूं कि यह 'einsum() का उपयोग करने के लिए प्रभावी है या नहीं। ' – pikachuchameleon

-1

इस विशेष उत्तर का उत्तर tf.scan फ़ंक्शन का उपयोग कर रहा है।

तो एक = [5,3,2] 5 बैच के प्रत्येक बैच में #dimension, 3X2 चटाई के साथ
और ख = [2,3] # एक निरंतर मैट्रिक्स प्रत्येक नमूने

साथ गुणा किया जा करने के लिए तो def fn (a, x): वापसी tf.matmul (x, b)

प्रारंभकर्ता = tf.Variable (tf।random_number (3,3))

एच = tf.scan (एफ एन, आउटपुट, प्रारंभकर्ता)

इस ज सभी outputs स्टोर करेगा।

स्रोत

2016-12-13 09:22:03

सबसे पहले tf.batch_matmul()removed था और अब उपलब्ध नहीं था। अब आप tf.matmul() उपयोग करने के लिए लगता है:

आदानों,, मैट्रिक्स (या रैंक> 2 की tensors, मैट्रिक्स की बैचों का प्रतिनिधित्व) होना चाहिए मिलान भीतरी आयामों के साथ संभवतः स्थानांतरण के बाद।

तो चलो मान लेते हैं तो आप निम्न कोड डालते हैं:

import tensorflow as tf 
batch_size, n, m, k = 10, 3, 5, 2 
A = tf.Variable(tf.random_normal(shape=(batch_size, n, m))) 
B = tf.Variable(tf.random_normal(shape=(batch_size, m, k))) 
tf.matmul(A, B)

अब आप आकार (batch_size, n, k) के टेन्सर प्राप्त होगा। यहां क्या हो रहा है यहाँ है। मान लें कि आपके पास batch_size मैट्रिस nxm और batch_size मैट्रिस mxk है। अब उनमें से प्रत्येक जोड़ी के लिए आप nxm X mxk की गणना करते हैं जो आपको nxk मैट्रिक्स देता है। आपके पास batch_size होगा।

सूचना है कि कुछ इस तरह भी मान्य है:

A = tf.Variable(tf.random_normal(shape=(a, b, n, m))) 
B = tf.Variable(tf.random_normal(shape=(a, b, m, k))) 
tf.matmul(A, B)

और आप एक आकार दे देंगे (a, b, n, k)

स्रोत

2017-05-06 10:22:52

tensorflow batch_matmul कैसे काम करता है?

उत्तर

संबंधित मुद्दे