Tensorflow将LSTM的最终状态保存在dynamic_rnn中用于预测

我想保存 LSTM 的最终状态，以便在恢复模型时将其包含在内并可用于预测。如下所述，当我使用时，保护程序仅了解最终状态tf.assign。但是，这会引发错误（也将在下面解释）。

在训练期间，我总是将最终的 LSTM 状态反馈回网络，如中所述这个帖子 https://stackoverflow.com/questions/39112622/how-do-i-set-tensorflow-rnn-state-when-state-is-tuple-true。以下是代码的重要部分：

构建图表时：

            self.init_state = tf.placeholder(tf.float32, [
                self.n_layers, 2, self.batch_size, self.n_hidden
            ])

            state_per_layer_list = tf.unstack(self.init_state, axis=0)

            rnn_tuple_state = tuple([
                tf.contrib.rnn.LSTMStateTuple(state_per_layer_list[idx][0],
                                              state_per_layer_list[idx][1])

                for idx in range(self.n_layers)
            ])

            outputs, self.final_state = tf.nn.dynamic_rnn(
                cell, inputs=self.inputs, initial_state=rnn_tuple_state)

在训练期间：

        _current_state = np.zeros((self.n_layers, 2, self.batch_size,
                                   self.n_hidden))

            _train_step, _current_state, _loss, _acc, summary = self.sess.run(
                [
                    self.train_step, self.final_state,
                    self.merged
                ],
                feed_dict={self.inputs: _inputs,
                           self.labels:_labels, 
                           self.init_state: _current_state})

当我稍后从检查点恢复模型时，最终状态也不会恢复。如中所述这个帖子 https://stackoverflow.com/questions/39112622/how-do-i-set-tensorflow-rnn-state-when-state-is-tuple-true问题是 Saver 不知道新的状态。该帖子还提出了一个解决方案，基于tf.assign。遗憾的是，我无法使用建议的

            assign_op = tf.assign(self.init_state, _current_state)
            self.sess.run(assign_op)

因为 self.init state 不是一个变量而是一个占位符。我收到错误

AttributeError：“张量”对象没有属性“分配”

我已经尝试解决这个问题几个小时了，但我无法让它工作。

任何帮助表示赞赏！

EDIT:

我已将 self.init_state 更改为

            self.init_state = tf.get_variable('saved_state', shape=
            [self.n_layers, 2, self.batch_size, self.n_hidden])

            state_per_layer_list = tf.unstack(self.init_state, axis=0)

            rnn_tuple_state = tuple([
                tf.contrib.rnn.LSTMStateTuple(state_per_layer_list[idx][0],
                                              state_per_layer_list[idx][1])

                for idx in range(self.n_layers)
            ])

            outputs, self.final_state = tf.nn.dynamic_rnn(
                cell, inputs=self.inputs, initial_state=rnn_tuple_state)

在训练期间，我不为 self.init_state 提供值：

            _train_step, _current_state, _loss, _acc, summary = self.sess.run(
                [
                    self.train_step, self.final_state,
                    self.merged
                ],
                feed_dict={self.inputs: _inputs,
                           self.labels:_labels})

但是，我仍然无法运行分配操作。知道我得到

类型错误：预期 float32 传递给操作“分配”的参数“值”，得到 (LSTMStateTuple(c=array([[ 0.07291573, -0.06366599, -0.23425588, ..., 0.05307654,

为了保存最终状态，您可以创建一个单独的 TF 变量，然后在保存图形之前运行assignop 将最新状态分配给该变量，然后保存图形。您唯一需要记住的是在声明变量之前声明该变量Saver;否则它不会包含在图表中。

这里对此进行了详细讨论，包括工作代码：TF LSTM：从训练会话中保存状态以供以后的预测会话使用 https://stackoverflow.com/questions/43663795/tf-lstm-save-state-from-training-session-for-prediction-session-later

*** 更新：后续问题的答案：

看起来你正在使用BasicLSTMCell, with state_is_tuple=True。我之前提到的讨论使用了GRUCell with state_is_tuple=False。两者之间的细节有些不同，但总体方法可能相似，所以希望这对您有用：

在训练期间，您首先将零作为initial_state into dynamic_rnn然后继续将其自己的输出作为输入重新反馈initial_state。所以，我们的最后输出状态dynamic_rnncall 是您要保存以供以后使用的内容。由于它的结果是sess.run()调用，本质上它是一个 numpy 数组（不是张量，也不是占位符）。所以问题就是“如何将 numpy 数组与图中的其余变量一起保存为 Tensorflow 变量”。这就是为什么您将最终状态分配给其唯一目的的变量。

所以，代码是这样的：

    # GRAPH DEFINITIONS:
    state_in = tf.placeholder(tf.float32, [LAYERS, 2, None, CELL_SIZE], name='state_in')
    l = tf.unstack(state_in, axis=0)
    state_tup = tuple(
        [tf.nn.rnn_cell.LSTMStateTuple(l[idx][0], l[idx][1])
        for idx in range(NLAYERS)])
    #multicell = your BasicLSTMCell / MultiRNN definitions
    output, state_out = tf.nn.dynamic_rnn(multicell, X, dtype=tf.float32, initial_state=state_tup)

    savedState = tf.get_variable('savedState', shape=[LAYERS, 2, BATCHSIZE, CELL_SIZE])
    saver = tf.train.Saver(max_to_keep=1)

    in_state = np.zeros((LAYERS, 2, BATCHSIZE, CELL_SIZE))

    # TRAINING LOOP:
    feed_dict = {X: x, Y_: y_, batchsize: BATCHSIZE, state_in:in_state}
    _, out_state = sess.run([training_step, state_out], feed_dict=feed_dict)
    in_state = out_state

    # ONCE TRAINING IS OVER:
    assignOp = tf.assign(savedState, out_state)
    sess.run(assignOp)
    saver.save(sess, pathModel + '/my_model.ckpt')

    # RECOVERING IN A DIFFERENT PROGRAM:

    gInit = tf.global_variables_initializer().run()
    lInit = tf.local_variables_initializer().run()
    new_saver = tf.train.import_meta_graph(pathModel + 'my_model.ckpt.meta')
    new_saver.restore(sess, pathModel + 'my_model.ckpt')
    # retrieve State and get its LAST batch (latest obervarions)
    savedState = sess.run('savedState:0') # this is FULL state from training
    state = savedState[:,:,-1,:]  # -1 gets only the LAST batch of the state (latest seen observations)
    state = np.reshape(state, [state.shape[0], 2, -1, state.shape[2]]) #[LAYERS, 2, 1 (BATCH), SELL_SIZE]
    #x = .... (YOUR INPUTS)
    feed_dict = {'X:0': x, 'state_in:0':state}
    #PREDICTION LOOP:
    preds, state = sess.run(['preds:0', 'state_out:0'], feed_dict = feed_dict)
    # so now state will be re-fed into feed_dict with the next loop iteration

如前所述，这是一种对我来说很有效的修改方法GRUCell, where state_is_tuple = False。我调整了一下尝试一下BasicLSTMCell with state_is_tuple=True。它有效，但不如原始方法准确。我还不知道这是否只是因为对我来说 GRU 比 LSTM 更好还是出于其他原因。看看这是否适合你......

另请记住，正如您在恢复和预测代码中看到的那样，您的预测可能基于与训练循环不同的批量大小（我猜批量为 1？），因此您必须考虑如何处理您的恢复状态——只取最后一批？或者是其他东西？该代码仅采用保存状态的最后一层（即训练中的最新观察结果），因为这与我相关......