टेन्सफोर्लो: लागत

Question

के लिए टेंसर की सूची मैं टेन्सर फ्लो में एलएसटीएम के साथ काम करने की कोशिश कर रहा हूं। मुझे एक ट्यूटोरियल ऑनलाइन मिला जहां अनुक्रमों का एक सेट लिया गया है और उद्देश्य कार्य एलएसटीएम और ज्ञात मूल्यों के अंतिम आउटपुट से बना है। हालांकि, मैं प्रत्येक आउटपुट से अपना उद्देश्य कार्य जानकारी का उपयोग करना चाहता हूं।

TypeError: List of Tensors when single Tensor expected 

कैसे: विशेष रूप से, मैं .:

cell = rnn_cell.BasicLSTMCell(num_units) 
inputs = [tf.placeholder(tf.float32,shape=[batch_size,input_size]) for _ in range(seq_len)] 
result = [tf.placeholder(tf.float32, shape=[batch_size,input_size]) for _ in range(seq_len)] 

W_o = tf.Variable(tf.random_normal([num_units,input_size], stddev=0.01))  
b_o = tf.Variable(tf.random_normal([input_size], stddev=0.01)) 

outputs, states = rnn.rnn(cell, inputs, dtype=tf.float32) 

losses = [] 

for i in xrange(len(outputs)): 
    final_transformed_val = tf.matmul(outputs[i],W_o) + b_o 
    losses.append(tf.nn.softmax(final_transformed_val)) 

cost = tf.reduce_mean(losses) 

कर इस त्रुटि में परिणाम है (यानी एक वाक्य में शब्दों में सभी पत्र जानें) LSTM दृश्यों के सेट जानने के लिए कोशिश कर रहा हूँ क्या मुझे इस मुद्दे को ठीक करना चाहिए? क्या tf.reduce_mean() टेंसर मानों की एक सूची में लेता है, या क्या कोई विशेष टेंसर ऑब्जेक्ट है जो उन्हें लेता है?

Answer 1

अपने कोड में, losses एक पायथन सूची है। टेंसरफ्लो का reduce_mean() एक एकल टेंसर की अपेक्षा करता है, पाइथन सूची नहीं।

losses = tf.reshape(tf.concat(1, losses), [-1, size]) 

जहां आकार आपके द्वारा सॉफ्टमैक्स ले रहे मूल्यों की संख्या है, जो आप चाहते हैं उसे करना चाहिए। देखें concat()

लेकिन, एक बात मैं अपने कोड है कि थोड़ा अजीब लगता है, में नोटिस आप अपने इनपुट के लिए प्लेसहोल्डर की एक सूची है कि जबकि the TensorFlow Tutorial में कोड आदानों के लिए एक आदेश 3 टेन्सर का उपयोग करता है। आपका इनपुट ऑर्डर 2 टेंसर की एक सूची है। मैं ट्यूटोरियल में कोड को देखने की अनुशंसा करता हूं, क्योंकि यह लगभग वही करता है जो आप पूछ रहे हैं।

उस ट्यूटोरियल में मुख्य फ़ाइलों में से एक here है। विशेष रूप से, लाइन 13 9 वह जगह है जहां वे अपनी लागत बनाते हैं। आपके इनपुट के संबंध में, लाइन 90 और 9 1 हैं जहां इनपुट और लक्ष्य प्लेसहोल्डर्स सेट हैं। उन 2 लाइनों में मुख्य टेकवे यह है कि प्लेसहोल्डर की सूची के बजाय एक संपूर्ण अनुक्रम एक प्लेसहोल्डर में पारित किया जाता है।

ptb_word_lm.py फ़ाइल में लाइन 120 देखें, यह देखने के लिए कि वे कहां अपना सम्मेलन करते हैं।

Answer 2

कार्य उदाहरण के लिए, जाँच notebook:

import tensorflow as tf 
from tensorflow.models.rnn import rnn, rnn_cell 
print(tf.__version__) 
#> 0.8.0 

batch_size = 2 
output_size = input_size = 2 
seq_len  = 10 
num_units = 2 

cell = rnn_cell.BasicLSTMCell(num_units) 
inputs = [tf.placeholder(tf.float32, shape=[batch_size,input_size ]) for _ in xrange(seq_len)] 
result = [tf.placeholder(tf.float32, shape=[batch_size,output_size]) for _ in xrange(seq_len)] 

W_o = tf.Variable(tf.random_normal([num_units,input_size], stddev=0.01))  
b_o = tf.Variable(tf.random_normal([input_size],   stddev=0.01)) 

outputs, states = rnn.rnn(cell, inputs, dtype=tf.float32) 

losses = [] 

for i in xrange(seq_len): 
    final_transformed_val = tf.matmul(outputs[i],W_o) + b_o 
    losses.append(tf.squared_difference(result[i],final_transformed_val)) 

losses = tf.reshape(tf.concat(1, losses), [-1, seq_len]) 
cost = tf.reduce_mean(losses) 

कार्रवाई में यह देखने के लिए, आप एक hacky तरह से ग्राफ फ़ीड कर सकते हैं:

import matplotlib.pyplot as plt 
import numpy as np 

step = tf.train.AdamOptimizer(learning_rate=0.01).minimize(cost) 
sess = tf.InteractiveSession() 

sess.run(tf.initialize_all_variables()) 

costs = [] 

# EXAMPLE 
# Learn cumsum over each sequence in x 
# | t  | 0 | 1 | 2 | 3 | 4 | ...| 
# |----------|---|---|---|---|----|----| 
# | x[:,0,0] | 1 | 1 | 1 | 1 | 1 | ...| 
# | x[:,0,1] | 1 | 1 | 1 | 1 | 1 | ...| 
# |   | | | | | | | 
# | y[:,0,0] | 1 | 2 | 3 | 4 | 5 | ...| 
# | y[:,0,1] | 1 | 2 | 3 | 4 | 5 | ...| 

n_iterations = 300 
for _ in xrange(n_iterations): 
    x = np.random.uniform(0,1,[seq_len,batch_size,input_size]) 
    y = np.cumsum(x,axis=0) 

    x_list = {key: value for (key, value) in zip(inputs, x)} 
    y_list = {key: value for (key, value) in zip(result, y)} 

    err,_ = sess.run([cost, step], feed_dict=dict(x_list.items()+y_list.items())) 
    costs.append(err) 

plt.plot(costs) 
plt.show() 

tensorflow-शुरुआत के रूप में मैं अभी तक आरएनएन को संभालने का एक एकीकृत तरीका/सर्वोत्तम अभ्यास तरीका नहीं मिला है, लेकिन जैसा ऊपर बताया गया है, मुझे यकीन है कि इसकी अनुशंसा नहीं की जाती है। स्निपेट के लिए धन्यवाद, एक बहुत अच्छा परिचय के रूप में अपनी लिपि पसंद आया। इसके अलावा, w.r.g से implementation of scan and RNN-tuple-friendliness पर कुछ चीजें चल रही हैं इसलिए सावधान रहें