Tensorflow LSTM इनपुट आकार

Question

को समझना मैं एक डाटासेट एक्स एन = 4000 नमूने होते हैं जो है, प्रत्येक नमूने घ = 2 सुविधाओं (निरंतर मान) वापस फैले टी = 10 समय कदम के होते हैं। मेरे पास प्रत्येक नमूने के संबंधित 'लेबल्स' भी हैं जो समय 11 पर निरंतर मूल्य हैं।

इस समय मेरा डेटासेट आकार एक्स में है: [4000,20], वाई: [4000]।

मैं डीएस (रिग्रेशन) के मूल्य की भविष्यवाणी करने के लिए टेंसरफ्लो का उपयोग करके एलएसटीएम को प्रशिक्षित करना चाहता हूं, डी सुविधाओं के 10 पिछले इनपुट दिए गए हैं, लेकिन मुझे टेंसरफ्लो में इसे लागू करने में कठिन समय हो रहा है।

इस समय मेरी मुख्य समस्या यह समझ रही है कि कैसे टेंसरफ्लो इनपुट को स्वरूपित करने की अपेक्षा कर रहा है। मैंने this जैसे विभिन्न उदाहरण देखे हैं, लेकिन ये उदाहरण निरंतर समय श्रृंखला डेटा की एक बड़ी स्ट्रिंग से निपटते हैं। मेरा डेटा अलग-अलग नमूने हैं, प्रत्येक एक स्वतंत्र समय श्रृंखला है।

Answer 1

documentation of tf.nn.dynamic_rnn कहता है:

inputs: RNN आदानों। यदि time_major == False (डिफ़ॉल्ट), यह आकार का एक टेंसर होना चाहिए: [batch_size, max_time, ...], या ऐसे तत्वों का घोंसला वाला टुपल होना चाहिए।

आपके मामले में, इसका मतलब है कि इनपुट में [batch_size, 10, 2] का आकार होना चाहिए। एक बार में सभी 4000 अनुक्रमों पर प्रशिक्षण के बजाय, आप प्रत्येक प्रशिक्षण पुनरावृत्ति में केवल batch_size का उपयोग करेंगे। ,

batch_size = 32 
# batch_size sequences of length 10 with 2 values for each timestep 
input = get_batch(X, batch_size).reshape([batch_size, 10, 2]) 
# Create LSTM cell with state size 256. Could also use GRUCell, ... 
# Note: state_is_tuple=False is deprecated; 
# the option might be completely removed in the future 
cell = tf.nn.rnn_cell.LSTMCell(256, state_is_tuple=True) 
outputs, state = tf.nn.dynamic_rnn(cell, 
            input, 
            sequence_length=[10]*batch_size, 
            dtype=tf.float32) 

documentation से, outputs आकार [batch_size, 10, 256] का हो जाएंगे, यानी एक-एक timestep के लिए 256 उत्पादन: निम्नलिखित की तरह कुछ काम करना चाहिए (जोड़ा स्पष्टता के लिए नयी आकृति प्रदान)। state आकार [batch_size, 256] के tuple होगा। आप अपने अंतिम मूल्य, प्रत्येक दृश्य के लिए एक का अनुमान लगा सकते है कि से:

predictions = tf.contrib.layers.fully_connected(state.h, 
               num_outputs=1, 
               activation_fn=None) 
loss = get_loss(get_batch(Y).reshape([batch_size, 1]), predictions) 

संख्या 256 outputs और state के आकार में cell.output_size resp से निर्धारित होता है। cell.state_size। ऊपर की तरह LSTMCell बनाते समय, ये वही हैं। LSTMCell documentation भी देखें।