मैं टेंसरफ्लो में आयाम त्रुटि को कैसे ठीक करूं?

Question

मैं अपने डेटा पर ट्यूटोरियल के विशेषज्ञ भाग को लागू करने की कोशिश कर रहा हूं लेकिन मैं आयाम त्रुटियों में चल रहा हूं। त्रुटि तक पहुंचने वाला कोड यहां दिया गया है।

def weight_variable(shape): 
    initial = tf.truncated_normal(shape, stddev=0.1) 
    return tf.Variable(initial) 

def bias_variable(shape): 
    initial = tf.constant(0.1, shape=shape) 
    return tf.Variable(initial) 

def conv2d(x, W): 
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME') 

def max_pool_2x2(x): 
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], 
         strides=[1, 2, 2, 1], padding='SAME') 

W_conv1 = weight_variable([1, 8, 1, 4]) 
b_conv1 = bias_variable([4]) 

x_image = tf.reshape(tf_in, [-1,2,8,1]) 

h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1) 
h_pool1 = max_pool_2x2(h_conv1) 

और फिर जब मैं इस आदेश को चलाने का प्रयास:

W_conv2 = weight_variable([1, 4, 4, 8]) 
b_conv2 = bias_variable([8]) 

h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2) 
h_pool2 = max_pool_2x2(h_conv2) 

मैं निम्नलिखित त्रुटियाँ मिलती है:

ValueError        Traceback (most recent call last) 
<ipython-input-41-7ab0d7765f8c> in <module>() 
     3 
     4 h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2) 
----> 5 h_pool2 = max_pool_2x2(h_conv2) 

ValueError: ('filter must not be larger than the input: ', 'Filter: [', Dimension(2), 'x', Dimension(2), '] ', 'Input: [', Dimension(1), 'x', Dimension(4), '] ') 

बस कुछ पृष्ठभूमि जानकारी, डेटा है कि मैं काम कर रहा हूँ के लिए एक सीएसवी फ़ाइल है जहां प्रत्येक पंक्ति में 10 फीचर्स और 1 खाली कॉलम होता है जो 1 या 0 हो सकता है। जो मैं प्राप्त करने की कोशिश कर रहा हूं वह खाली कॉलम में एक संभावना है जो कॉलम 1 के बराबर होगा।

Answer 1

आपको इनपुट को आकार देना होगा ताकि यह प्रशिक्षण टेंसर और आउटपुट दोनों के साथ संगत हो। यदि आप इनपुट लंबाई 1 है, तो आपका आउटपुट लंबाई 1 होना चाहिए (लंबाई आयाम के लिए प्रतिस्थापित है)।

आप हूँ-

def conv2d(x, W): 
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME') 

def max_pool_2x2(x): 
    return tf.nn.max_pool(x, ksize=[1, 1, 1, 1], 
        strides=[1, 1, 1, 1], padding='SAME') 

सूचना काम कर रहे जब मैं कैसे प्रगति और [1, 1, 1, 1] को ksize बदल दिया है। यह आउटपुट को 1 आयामी इनपुट से मेल करेगा और सड़क के नीचे त्रुटियों को रोक देगा।

आप अपना वजन चर को परिभाषित कर रहे हैं (नीचे दिए गए कोड को देखें) -

def weight_variable(shape): 
    initial = tf.truncated_normal(shape, stddev=0.1) 
    return tf.Variable(initial) 

def bias_variable(shape): 
    initial = tf.constant(0.1, shape=shape) 
    return tf.Variable(initial) 

आप पहले 2 नंबर सुविधा टेन्सर है कि आप अपने मॉडल को प्रशिक्षित करने का उपयोग कर रहे के अनुरूप बनाने के लिए करने जा रहे हैं , अंतिम दो संख्या अनुमानित आउटपुट का आयाम होगा (इनपुट के आयाम के समान)।

W_conv1 = weight_variable([1, 10, 1, 1]) 
b_conv1 = bias_variable([1]) 

सूचना शुरुआत दर्शाता है कि सुविधा टेन्सर एक 1x10 सुविधा टेन्सर होने जा रहा है में [1, 10,; अंतिम दो संख्या 1, 1] इनपुट और आउटपुट टेंसर/भविष्यवाणियों के आयामों से मेल खाते हैं।

जब आप अपने x_foo टेन्सर,, (मैं इसे x_ फोन [x प्रधानमंत्री]) आप जो भी कारण के लिए, मध्यम में तरह तथाकथित

x_ = tf.reshape(x, [-1,1,10,1]) 

सूचना इसे परिभाषित करने की 1 और 10 है नयी आकृति प्रदान ...1,10,...। एक बार फिर, ये संख्या आपके फीचर टेंसर के आयाम से मेल खाते हैं।

प्रत्येक पूर्वाग्रह चर के लिए, आप पहले परिभाषित चर की अंतिम संख्या चुनते हैं। उदाहरण के लिए, यदि W_conv1 = weight_variable([1, 10, 1, 1]) ऐसा दिखाई देता है, तो आप अंतिम संख्या लेते हैं और इसे अपने पूर्वाग्रह चर में डाल देते हैं ताकि यह इनपुट के आयामों से मेल खा सके। ऐसा किया जाता है- b_conv1 = bias_variable([1])।

यदि आपको और स्पष्टीकरण की आवश्यकता है तो कृपया नीचे टिप्पणी करें।

Answer 2

फ़िल्टर के लिए आप जिन आयामों का उपयोग कर रहे हैं वे छिपी हुई परत के आउटपुट से मेल नहीं खाते हैं।

मुझे देखने दो कि मैं आपको समझ गया हूं: आपका इनपुट 8 विशेषताओं से बना है, और आप इसे 2x4 मैट्रिक्स में दोबारा बदलना चाहते हैं, है ना?

weight_variable([1, 8, 1, 4]) के साथ बनाए गए वजन एक चैनल में 1x8 इनपुट की अपेक्षा करते हैं, और 4 चैनलों (या छुपी इकाइयों) में 1x8 आउटपुट उत्पन्न करते हैं। आप जिस फ़िल्टर का उपयोग कर रहे हैं वह 2x2 वर्गों में इनपुट को साफ़ करता है। हालांकि, वजन के परिणाम 1x8 है, इसलिए वे मेल नहीं खाएंगे।

आप

x_image = tf.reshape(tf_in, [-1,2,4,1]) 

के रूप में इनपुट नयी आकृति प्रदान करना चाहिए अब, आपके इनपुट वास्तव में 1x8 के बजाय 2x4 है। फिर आपको 2x4 आउटपुट से निपटने के लिए वजन आकार को (2, 4, 1, hidden_units) में बदलने की आवश्यकता है। यह 2x4 आउटपुट भी उत्पन्न करेगा, और 2x2 फ़िल्टर अब लागू किया जा सकता है।

उसके बाद, फ़िल्टर वजन के आउटपुट से मेल खाता है। यह भी ध्यान रखें कि आपको अपने दूसरे वजन मैट्रिक्स का आकार weight_variable([2, 4, hidden_units, hidden2_units])