当您在RNN的最后一层中有return_sequences时，您不能使用简单的Dense层，而应使用TimeDistributed。

这是一段示例代码，可能会对其他人有所帮助。

单词= keras.layers.Input（batch_shape =（None，self.maxSequenceLength），名称=“输入”）

    # Build a matrix of size vocabularySize x EmbeddingDimension 
    # where each row corresponds to a "word embedding" vector.
    # This layer will convert replace each word-id with a word-vector of size Embedding Dimension.
    embeddings = keras.layers.embeddings.Embedding(self.vocabularySize, self.EmbeddingDimension,
        name = "embeddings")(words)
    # Pass the word-vectors to the LSTM layer.
    # We are setting the hidden-state size to 512.
    # The output will be batchSize x maxSequenceLength x hiddenStateSize
    hiddenStates = keras.layers.GRU(512, return_sequences = True, 
                                        input_shape=(self.maxSequenceLength,
                                        self.EmbeddingDimension),
                                        name = "rnn")(embeddings)
    hiddenStates2 = keras.layers.GRU(128, return_sequences = True, 
                                        input_shape=(self.maxSequenceLength, self.EmbeddingDimension),
                                        name = "rnn2")(hiddenStates)

    denseOutput = TimeDistributed(keras.layers.Dense(self.vocabularySize), 
        name = "linear")(hiddenStates2)
    predictions = TimeDistributed(keras.layers.Activation("softmax"), 
        name = "softmax")(denseOutput)  

    # Build the computational graph by specifying the input, and output of the network.
    model = keras.models.Model(input = words, output = predictions)
    # model.compile(loss='kullback_leibler_divergence', \
    model.compile(loss='sparse_categorical_crossentropy', \
        optimizer = keras.optimizers.Adam(lr=0.009, \
            beta_1=0.9,\
            beta_2=0.999, \
            epsilon=None, \
            decay=0.01, \
            amsgrad=False))

作为对已接受答案的补充，此答案显示了keras行为以及如何获得每张照片。

一般Keras行为

标准keras内部处理总是如下图所示（其中我使用features=2 ，压力和温度作为示例）：

在此图中，我将步骤数增加到5，以避免与其他维度混淆。

对于此示例：

• 我们有N个油箱
• 我们每小时花费5个小时采取措施（时间步长）
• 我们测量了两个功能：
  • 压力P
  • 温度T

然后，我们的输入数组应为(N,5,2) ：

        [     Step1      Step2      Step3      Step4      Step5
Tank A:    [[Pa1,Ta1], [Pa2,Ta2], [Pa3,Ta3], [Pa4,Ta4], [Pa5,Ta5]],
Tank B:    [[Pb1,Tb1], [Pb2,Tb2], [Pb3,Tb3], [Pb4,Tb4], [Pb5,Tb5]],
  ....
Tank N:    [[Pn1,Tn1], [Pn2,Tn2], [Pn3,Tn3], [Pn4,Tn4], [Pn5,Tn5]],
        ]

滑动窗输入

通常，LSTM层应该处理整个序列。划分窗口可能不是最好的主意。该层具有有关序列前进过程的内部状态。 Windows消除了学习长序列的可能性，从而将所有序列限制为窗口大小。

在窗口中，每个窗口都是一个较长的原始序列的一部分，但是Keras会将它们视为独立的序列：

        [     Step1    Step2    Step3    Step4    Step5
Window  A:  [[P1,T1], [P2,T2], [P3,T3], [P4,T4], [P5,T5]],
Window  B:  [[P2,T2], [P3,T3], [P4,T4], [P5,T5], [P6,T6]],
Window  C:  [[P3,T3], [P4,T4], [P5,T5], [P6,T6], [P7,T7]],
  ....
        ]

请注意，在这种情况下，最初只有一个序列，但是您将其划分为许多序列以创建窗口。

“什么是序列”的概念是抽象的。重要的部分是：

• 您可以批量处理许多单独的序列
• 使序列成为序列的原因是它们是逐步演化的（通常是时间步长）

通过“单层”实现每种情况

实现许多标准：

您可以使用return_sequences=True通过一个简单的LSTM层实现很多对很多：

outputs = LSTM(units, return_sequences=True)(inputs)

#output_shape -> (batch_size, steps, units)

实现多对一：

使用完全相同的图层，keras将执行完全相同的内部预处理，但是当您使用return_sequences=False （或简单地忽略此参数）时，keras将自动放弃最后一步的步骤：

outputs = LSTM(units)(inputs)

#output_shape -> (batch_size, units) --> steps were discarded, only the last was returned

实现一对多

现在，仅keras LSTM层不支持此功能。您将必须创建自己的策略来重复步骤。有两种好的方法：

• 通过重复张量创建恒定的多步输入
• 使用stateful=True重复执行一个步骤的输出，并将其用作下一步的输入（需要output_features == input_features ）

一对多与重复向量

为了适应喀拉拉邦的标准行为，我们需要分步进行输入，因此，我们只需重复输入所需的长度即可：

outputs = RepeatVector(steps)(inputs) #where inputs is (batch,features)
outputs = LSTM(units,return_sequences=True)(outputs)

#output_shape -> (batch_size, steps, units)

了解有状态=真

现在出现stateful=True一种可能用法（除了避免加载无法同时容纳计算机内存的数据）

有状态允许我们分阶段输入序列的“部分”。区别在于：

• 在stateful=False ，第二批包含完整的新序列，与第一批无关
• 在stateful=True ，第二批继续第一批，扩展了相同的序列。

这就像在Windows中划分序列一样，有两个主要区别：

• 这些窗户不叠加！
• stateful=True将看到这些窗口作为单个长序列连接

在stateful=True ，每个新批次将被解释为继续前一个批次（直到您调用model.reset_states() ）。

• 批次2中的序列1将继续批次1中的序列1。
• 批次2中的序列2将继续批次1中的序列2。
• 批次2中的序列n将继续批次1中的序列n。

输入示例，批次1包含步骤1和2，批次2包含步骤3至5：

                   BATCH 1                           BATCH 2
        [     Step1      Step2        |    [    Step3      Step4      Step5
Tank A:    [[Pa1,Ta1], [Pa2,Ta2],     |       [Pa3,Ta3], [Pa4,Ta4], [Pa5,Ta5]],
Tank B:    [[Pb1,Tb1], [Pb2,Tb2],     |       [Pb3,Tb3], [Pb4,Tb4], [Pb5,Tb5]],
  ....                                |
Tank N:    [[Pn1,Tn1], [Pn2,Tn2],     |       [Pn3,Tn3], [Pn4,Tn4], [Pn5,Tn5]],
        ]                                  ]

注意批次1和批次2中的储罐对齐！这就是为什么我们需要shuffle=False （当然，除非我们仅使用一个序列）。

您可以无限期地具有任意数量的批次。 （对于每批中具有可变长度，请使用input_shape=(None,features) 。

一对多与有状态= True

对于我们这里的情况，每批将仅使用1步，因为我们希望获得一个输出步并将其作为输入。

请注意，图片中的行为不是由stateful=True引起的。我们将在下面的手动循环中强制执行该操作。在此示例中， stateful=True是“允许”我们停止序列，操纵我们想要的并从我们停止的位置继续进行的操作。

老实说，对于这种情况，重复方法可能是更好的选择。但是由于我们要研究的是stateful=True ，所以这是一个很好的例子。最好的使用方法是下一个“多对多”案例。

层：

outputs = LSTM(units=features, 
               stateful=True, 
               return_sequences=True, #just to keep a nice output shape even with length 1
               input_shape=(None,features))(inputs) 
    #units = features because we want to use the outputs as inputs
    #None because we want variable length

#output_shape -> (batch_size, steps, units) 

现在，我们将需要一个手动循环进行预测：

input_data = someDataWithShape((batch, 1, features))

#important, we're starting new sequences, not continuing old ones:
model.reset_states()

output_sequence = []
last_step = input_data
for i in steps_to_predict:

    new_step = model.predict(last_step)
    output_sequence.append(new_step)
    last_step = new_step

 #end of the sequences
 model.reset_states()

有状态=真对多对多

现在，在这里，我们得到了一个非常不错的应用程序：给定一个输入序列，尝试预测其未来未知的步骤。

我们使用的方法与上述“一对多”方法相同，不同之处在于：

• 我们将使用序列本身作为目标数据，向前迈出一步
• 我们知道序列的一部分（因此我们放弃了这部分结果）。

图层（与上面相同）：

outputs = LSTM(units=features, 
               stateful=True, 
               return_sequences=True, 
               input_shape=(None,features))(inputs) 
    #units = features because we want to use the outputs as inputs
    #None because we want variable length

#output_shape -> (batch_size, steps, units) 

训练：

我们将训练模型来预测序列的下一步：

totalSequences = someSequencesShaped((batch, steps, features))
    #batch size is usually 1 in these cases (often you have only one Tank in the example)

X = totalSequences[:,:-1] #the entire known sequence, except the last step
Y = totalSequences[:,1:] #one step ahead of X

#loop for resetting states at the start/end of the sequences:
for epoch in range(epochs):
    model.reset_states()
    model.train_on_batch(X,Y)

预测：

我们预测的第一阶段涉及“调整状态”。这就是为什么即使我们已经知道序列的这一部分，我们也要再次预测整个序列：

model.reset_states() #starting a new sequence
predicted = model.predict(totalSequences)
firstNewStep = predicted[:,-1:] #the last step of the predictions is the first future step

现在我们像一对多情况一样进入循环。但是请不要在这里重置状态！ 。我们希望模型知道序列的哪一步（并且由于上面我们所做的预测，它知道它在第一步）

output_sequence = [firstNewStep]
last_step = firstNewStep
for i in steps_to_predict:

    new_step = model.predict(last_step)
    output_sequence.append(new_step)
    last_step = new_step

 #end of the sequences
 model.reset_states()

在以下答案和文件中使用了这种方法：

• 使用LSTM预测时间序列的多个正向时间步长
• 如何使用Keras模型预测未来的日期或事件？
• https://github.com/danmoller/TestRepo/blob/master/TestBookLSTM.ipynb

实现复杂的配置

在上面的所有示例中，我展示了“一层”的行为。

当然，您可以在彼此之上堆叠许多层，而不必全部遵循相同的模式，然后创建自己的模型。

出现的一个有趣的例子是“自动编码器”，它具有“多对一个编码器”，后跟“一对多”解码器：

编码器：

inputs = Input((steps,features))

#a few many to many layers:
outputs = LSTM(hidden1,return_sequences=True)(inputs)
outputs = LSTM(hidden2,return_sequences=True)(outputs)    

#many to one layer:
outputs = LSTM(hidden3)(outputs)

encoder = Model(inputs,outputs)

解码器：

使用“重复”方法；

inputs = Input((hidden3,))

#repeat to make one to many:
outputs = RepeatVector(steps)(inputs)

#a few many to many layers:
outputs = LSTM(hidden4,return_sequences=True)(outputs)

#last layer
outputs = LSTM(features,return_sequences=True)(outputs)

decoder = Model(inputs,outputs)

自动编码器：

inputs = Input((steps,features))
outputs = encoder(inputs)
outputs = decoder(outputs)

autoencoder = Model(inputs,outputs)

fit(X,X)训练fit(X,X)

补充说明

如果您想了解有关LSTM中如何计算步骤的详细信息，或者有关上述stateful=True情况的详细信息，则可以在此答案中阅读更多内容： 对“了解Keras LSTM”的怀疑

首先，你选择伟大的教程（ 1 ， 2 ）开始。

什么是时间步长 ：X.shape中的Time-steps==3 （描述数据形状）表示有三个粉红色框。由于在Keras中，每个步骤都需要输入，因此绿色框的数量通常应等于红色框的数量。除非您破解结构。

多对多与多对一 ：在keras中，初始化LSTM或GRU或SimpleRNN时有一个return_sequences参数。当return_sequences为False （默认情况下）时，如图所示，它是多对一的。它的返回形状是(batch_size, hidden_unit_length) ，表示最后一个状态。当return_sequences为True ，则是很多对很多 。其返回形状为(batch_size, time_step, hidden_unit_length)

features参数是否相关 ：Feature参数的意思是“您的红框有多大”或每步的输入尺寸是多少。例如，如果要根据8种市场信息进行预测，则可以使用feature==8生成数据。

有状态 ：您可以查找源代码 。初始化状态时，如果stateful==True ，则将最后一次训练的状态用作初始状态，否则将生成新状态。我尚未开启stateful 。但是，我不同意的是，当stateful==True时， batch_size只能为1。

当前，您将使用收集的数据生成数据。将您的库存信息以流的形式显示，而不是等待一天收集所有顺序的图像，而是想在网络训练/预测时在线生成输入数据。如果您有400只股票共享同一网络，则可以设置batch_size==400 。