सशर्त ग्राफ कि व्यापक सवाल तक पहुँचता टेन्सर आकार

Question

पहले:

• यह tensorflow साथ एक सशर्त ग्राफ निर्माण करने के लिए संभव है?
• यदि हां, स्वचालित ढाल-कैल्श्यूशन करें और कार्यान्वित अनुकूलक इसके साथ काम करते हैं?
• क्या मैं एक टेंसर के आकार तक पहुंच सकता हूं और इसे "अगर" स्थिति और "I में रेंज()" लूप के साथ उपयोग करने के लिए एक पूर्णांक में बदल सकता हूं?

मेरा वास्तविक उपयोग मामला यह है कि मैं परिवर्तनीय टेंसर लंबाई के साथ 1 डी रूपांतरण करना चाहता हूं। इसके लिए मुझे सबसे पहले एक कथन की आवश्यकता होती है जो केवल लंबाई को बड़ा होने पर केवल रूपांतरण को निष्पादित करता है। तब मेरे पास एक लूप है जो दृढ़ संकल्प के लिए टेंसर के माध्यम से जाता है। समस्या यह है कि यह कोड:

for i in range(tf.shape(tensor)[0]): 

काम नहीं करता है क्योंकि रेंज ऑपरेटर को पूर्णांक की आवश्यकता होती है। क्या मैं इसे किसी भी तरह पूर्णांक में बदल सकता हूं?

अंत मैं adagrad के साथ इस मॉडल को प्रशिक्षित करना चाहते हैं, या तो स्वचालित भेदभाव या पहले से ही लागू किया अनुकूलक के साथ

---

संपादित करें:

इस -1 डी घुमाव जो बाद में पहले हो जाएगा मेरे मॉडल में दो परतों का। प्रकार त्रुटियां लूप के प्रत्येक संस्करण के पीछे होती हैं जो एक

import tensorflow as tf 
import numpy as np 

def convolve(s, Tl, Tr, b): 

    if (tf.shape(s)[0] == 1): 
     return s 

    sum = 0 

    # for i in range(tf.shape(s)[0] - 1): # error: TypeError: range() integer end argument expected, got Tensor 
    # for i in range(s._shape._dims[0]._value - 1): # error: TypeError: unsupported operand type(s) for -: 'NoneType' and 'int' 
    for i in range(s.get_shape().as_list()[0] - 1): # error: TypeError: unsupported operand type(s) for -: 'NoneType' and 'int' 

     sum += tf.tanh(tf.matmul(Tl,s[i]) + tf.matmul(Tr, s[i+1]) + b) 

    return sum 

ModelSize = 3 

# tensor to be convolved 
s = tf.placeholder("float", shape = [None, ModelSize]) 

# initialise weights 
Tl = tf.Variable(tf.random_normal(shape=[ModelSize,ModelSize], stddev = 0.1)) 
Tr = tf.Variable(tf.random_normal(shape=[ModelSize,ModelSize], stddev = 0.1)) 
b = tf.Variable(tf.random_normal(shape=[ModelSize], stddev = 0.1)) 

#convolution 
s_convolved = convolve(s, Tl, Tr, b) 

# initialise variables. 
init = tf.initialize_all_variables() 

# run graph 
sess = tf.Session() 
sess.run(init) 

# test data 
s_dataLong = np.random.random((2,5,ModelSize)) 
s_dataShort = np.random.random((2,1,ModelSize)) 

for s_dataPart in s_dataLong: 
    print sess.run(s_convolved, feed_dict = {s : s_dataPart}) 

for s_dataPart in s_dataShort: 
    print sess.run(s_convolved, feed_dict = {s : s_dataPart}) 

Answer 1

मैं आपको प्रत्येक प्रश्न को अलग-अलग लिखने की सलाह देता हूं। अन्यथा यह बहुत व्यापक के रूप में बंद हो जाएगा।

मैं केवल आपके तीसरे प्रश्न का उत्तर दे सकता हूं। प्रोग्रामर को टेंसर का आकार कैसे प्राप्त करें। आप shape to get the shape of the tensor का सही ढंग से उपयोग कर रहे हैं, लेकिन ग्राफ को चलाने से पहले आप अभी भी परिणाम नहीं प्राप्त कर सकते हैं (मेरे explanation here देखें)। करने के लिए

print a._shape._dims[0]._value 
print a._shape._dims[1]._value 

:

a = tf.truncated_normal([2, 3], mean=0.0, stddev=0.02, dtype=tf.float32, seed=1) 
b = tf.shape(a) 
sess = tf.Session() 
print sess.run(b) # will give you [2 3] 

बदसूरत तरह से है कि मैं ग्राफ चलने के बिना, स्थिरांक से आकार पाने के लिए मिल गया है की तरह कुछ (वास्तव में नहीं जानता कि क्यों आप इसे की आवश्यकता होगी) करना है एक चर से आकार मिलता है, आप यह कर सकते हैं:

weights = tf.Variable(tf.random_normal([784, 200], stddev=0.35)) 
print weights.get_shape().as_list() 

एक और तरीका है मूल्यांकन से पहले एक टेन्सर के आकार तक पहुँचने के लिए है: tf.Tensor.get_shape()