Python 理解Tensorflow LSTM输入形状

我有一个数据集X，它包含N=4000个样本，每个样本包含d=2个特征（连续值），跨越t=10个时间步。在时间步骤11，我还拥有每个样本的相应“标签”，它们也是连续值

目前，我的数据集的形状为X:[4000,20]，Y:[4000]

我想使用TensorFlow训练一个LSTM来预测Y（回归）的值，给定之前10个d特征的输入，但我在TensorFlow中实现这一点很困难

目前我面临的主要问题是理解TensorFlow期望如何格式化输入。我见过各种各样的例子，比如，但是这些例子处理的是一大串连续的时间序列数据。我的数据是不同的样本，每个样本都是独立的时间序列。

状态：

输入

：RNN输入。如果

time\u major==False

（默认值），则这必须是一个形状张量：

[batch\u size，max\u time，…]

，或此类元素的嵌套元组

在您的情况下，这意味着输入的形状应为

[batch\u size，10,2]

。不要一次对所有4000个序列进行训练，而是在每次训练迭代中只使用

batch\u size

其中的许多序列。类似于以下内容的操作应该有效（为清晰起见，添加了重塑）：

从中，

输出

的形状将为

[批次大小，10256]

，即每个时间步一个256输出<代码>状态将是一组形状[批量大小，256]。您可以根据以下公式预测最终值，每个序列对应一个值：

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由

单元格决定。输出大小分别为<代码>单元格。状态大小

。当创建如上所述的

LSTMCell

时，它们是相同的。另请参见。

（此答案“addreses”解决了当direct np.Reformate（）无法按我们的需要组织最终数组时的问题。如果我们想直接将其组织为3D np.Reformate，则可以，但请注意输入的最终组织）

在我个人尝试最终解决RNN输入形状的问题时，我将给出我个人的解释

在我的情况下（我认为许多其他人可能在他们的功能矩阵中有这种组织模式），大多数外部博客“没有帮助”。让我们尝试一下如何为RNN将2D特征矩阵转换为3D形状的矩阵

假设我们在特征矩阵中有这样一种组织类型：我们有5个观察值（即行-我认为这是最符合逻辑的术语），在每一行中，每个时间步有2个特征（我们有2个时间步），如下所示：

（df

df

是为了更好地从视觉上理解我的话）

现在，我们将使用这些值来处理它们。这里的问题是，RNN将“timestep”维度合并到它们的输入中，因为它们的架构性质。我们可以将该维度想象为按照我们拥有的时间步数，将2D数组一个接一个地堆叠起来。在这种情况下，我们有两个时间步；所以我们将有两个二维数组堆叠：一个用于timestep1，后面一个用于timestep2

实际上，在我们需要进行的3D输入中，我们仍然有5次观察。问题是，我们需要以不同的方式安排它们：RNN将获取第一个数组（即timestep1）的第一行（或指定的批，但我们在这里将保持简单）和第二个堆叠数组（即timestep2）的第一行。然后是第二行…直到最后一行（在我们的示例中是第五行）。因此，在每个时间步的每一行中，我们需要有两个特性，当然，在不同的数组中分开，每个特性对应于它的时间步。让我们看看这些数字

为了便于理解，我将制作两个数组。请记住，由于我们在df中的组织方案，您可能已经注意到，我们需要将前两列（即时间步1的功能1和2）作为堆栈的第一个数组，将最后两列（即第三列和第四列）作为堆栈的第二个数组，最终一切都有意义

In [7]: arrStack1 = arr[:,0:2]                                                       

In [8]: arrStack1                                                                    
Out[8]: 
array([[3, 7],
       [7, 0],
       [2, 0],
       [3, 9],
       [1, 2]])

In [9]: arrStack2 = arr[:,2:4]                                                       

In [10]: arrStack2                                                                   
Out[10]: 
array([[4, 4],
       [6, 0],
       [2, 4],
       [3, 4],
       [3, 0]])

最后，我们需要做的唯一一件事是堆叠两个数组（“一个在另一个后面”），就好像它们是同一最终结构的一部分：

In [11]: arrfinal3D = np.stack([arrStack1, arrStack2])                               

In [12]: arrfinal3D                                                                  
Out[12]: 
array([[[3, 7],
        [7, 0],
        [2, 0],
        [3, 9],
        [1, 2]],

       [[4, 4],
        [6, 0],
        [2, 4],
        [3, 4],
        [3, 0]]])

In [13]: arrfinal3D.shape                                                            
Out[13]: (2, 5, 2)

就是这样：考虑到2D特征矩阵的组织，我们已经准备好将特征矩阵输入RNN单元

（关于所有这些，您可以使用一个班轮：

In [14]: arrfinal3D_1 = np.stack([arr[:,0:2], arr[:,2:4]])                           

In [15]: arrfinal3D_1                                                                
Out[15]: 
array([[[3, 7],
        [7, 0],
        [2, 0],
        [3, 9],
        [1, 2]],

       [[4, 4],
        [6, 0],
        [2, 4],
        [3, 4],
        [3, 0]]])

---

感谢您的回复！我将很快尝试这个方法，并让您知道它是否解决了我的问题。但有一个问题：256在tf.nn.rnn_cell.LSTMCell（256，state_is_tuple=True）中到底指的是什么？我已经阅读了文档，该值被称为n_单位。这是否意味着时间步数？即LSTM单元的内存？对不起，我知道这是原始问题的扩展。每个序列中的时间步数由您在

tf.nn.dynamic\nsequence_length

参数给出de>。256表示LSTM的内部状态的大小，该状态在每个时间步长上都会更新。@fwalch问题：您是否希望完全连接的预测层具有

num\u outputs=batch\u size

？然后在批处理中的每个时间序列的末尾都有一个预测？@engineer如果完全连接的层已输出put shape

[batch\u size，num\u outputs]

，即

num\u outputs

是批处理中每个条目的输出数。您好，我正在尝试实现与您所做的非常类似的操作，希望您能给我一些提示，因为tensorflow对我来说仍然令人难以置信。对于您的设置，inp是如何实现的

In [11]: arrfinal3D = np.stack([arrStack1, arrStack2])                               

In [12]: arrfinal3D                                                                  
Out[12]: 
array([[[3, 7],
        [7, 0],
        [2, 0],
        [3, 9],
        [1, 2]],

       [[4, 4],
        [6, 0],
        [2, 4],
        [3, 4],
        [3, 0]]])

In [13]: arrfinal3D.shape                                                            
Out[13]: (2, 5, 2)

In [14]: arrfinal3D_1 = np.stack([arr[:,0:2], arr[:,2:4]])                           

In [15]: arrfinal3D_1                                                                
Out[15]: 
array([[[3, 7],
        [7, 0],
        [2, 0],
        [3, 9],
        [1, 2]],

       [[4, 4],
        [6, 0],
        [2, 4],
        [3, 4],
        [3, 0]]])