tensorflow RNN

Question

से अंतिम मान्य आउटपुट मान कैसे चुनें I अलग-अलग लंबाई वाले अनुक्रमों के बैचों पर एक एलएसटीएम सेल प्रशिक्षण दे रहा हूं। tf.nn.rnn में बहुत सुविधाजनक पैरामीटर sequence_length है, लेकिन इसे कॉल करने के बाद, मुझे नहीं पता कि बैच में प्रत्येक आइटम के आखिरी बार चरण के साथ आउटपुट पंक्तियों को कैसे चुनें।

मेरे कोड मूल रूप से इस प्रकार है:

lstm_cell = tf.nn.rnn_cell.LSTMCell(num_lstm_units, input_size) 
lstm_outputs, state = tf.nn.rnn(lstm_cell, input_list, dtype=tf.float32, sequence_length=sequence_lengths) 

lstm_outputs हर बार कदम पर LSTM उत्पादन के साथ एक सूची है। हालांकि, मेरे बैच में प्रत्येक आइटम की एक अलग लंबाई होती है, और इसलिए मैं अपने बैच में प्रत्येक आइटम के लिए वैध अंतिम एलएसटीएम आउटपुट युक्त एक टेंसर बनाना चाहता हूं।

मैं numpy अनुक्रमण इस्तेमाल कर सकते हैं, तो मैं बस कुछ इस तरह करना होगा:

all_outputs = tf.pack(lstm_outputs) 
last_outputs = all_outputs[sequence_lengths, tf.range(batch_size), :] 

लेकिन यह पता चला है कि समय के लिए tensorflow इसका समर्थन नहीं करता शुरू (मैं feature request के बारे में पता कर रहा हूँ) ।

तो, मैं इन मूल्यों को कैसे प्राप्त कर सकता हूं?

Answer 1

प्रश्न में जुड़े फीचर अनुरोध पृष्ठ पर दानी द्वारा एक और स्वीकार्य कामकाज प्रकाशित किया गया था। इसे टेंसर का मूल्यांकन करने की आवश्यकता नहीं है, जो एक बड़ा प्लस है।

मुझे यह tensorflow 0.8 के साथ काम करने के लिए मिला।

def extract_last_relevant(outputs, length): 
    """ 
    Args: 
     outputs: [Tensor(batch_size, output_neurons)]: A list containing the output 
      activations of each in the batch for each time step as returned by 
      tensorflow.models.rnn.rnn. 
     length: Tensor(batch_size): The used sequence length of each example in the 
      batch with all later time steps being zeros. Should be of type tf.int32. 

    Returns: 
     Tensor(batch_size, output_neurons): The last relevant output activation for 
      each example in the batch. 
    """ 
    output = tf.transpose(tf.pack(outputs), perm=[1, 0, 2]) 
    # Query shape. 
    batch_size = tf.shape(output)[0] 
    max_length = int(output.get_shape()[1]) 
    num_neurons = int(output.get_shape()[2]) 
    # Index into flattened array as a workaround. 
    index = tf.range(0, batch_size) * max_length + (length - 1) 
    flat = tf.reshape(output, [-1, num_neurons]) 
    relevant = tf.gather(flat, index) 
    return relevant 

Answer 2

यह सबसे अच्छा समाधान नहीं है लेकिन आप अपने आउटपुट का मूल्यांकन कर सकते हैं, फिर नतीजे प्राप्त करने के लिए नमी इंडेक्सिंग का उपयोग करें और उस से टेंसर वैरिएबल बनाएं? यह एक स्टॉप अंतर के रूप में काम कर सकता है जब तक कि tensorflow इस सुविधा को प्राप्त नहीं करता है। जैसे

all_outputs = session.run(lstm_outputs, feed_dict={'your inputs'}) 
last_outputs = all_outputs[sequence_lengths, tf.range(batch_size), :] 
use_this_as_an_input_to_new_tensorflow_op = tf.constant(last_outputs) 

Answer 3

आप केवल अंतिम वैध उत्पादन में रुचि रखते हैं आप राज्य tf.nn.rnn() द्वारा दिया पर विचार करें कि वह हमेशा टपल (ग, ज) जहाँ c पिछले राज्य है के माध्यम से इसे पुनः प्राप्त कर सकते हैं: यहाँ कोड है और एच अंतिम आउटपुट है।

lstm_cell = tf.nn.rnn_cell.LSTMCell(num_lstm_units, input_size) 
lstm_outputs, state = tf.nn.rnn(lstm_cell, input_list, dtype=tf.float32, sequence_length=sequence_lengths) 
last_output = state[1]