Machine Learning Mastery LSTM 教程（六）
如何在 Keras 中为截断 BPTT 准备序列预测
原文：
machinelearningmastery.com/truncated-backpropagation-through-time-in-keras/
循环神经网络能够在序列预测问题中学习跨越多个时间步的时间依赖性。
诸如长短期记忆或 LSTM 网络的现代循环神经网络使用称为反向传播时间的反向传播算法的变体进行训练。该算法已被进一步修改以提高具有非常长序列的序列预测问题的效率，并且被称为截断反向传播。
使用 Truncated Backpropagation Through Time 训练像 LSTM 这样的循环神经网络时的一个重要配置参数是决定使用多少次步进作为输入。也就是说，如何将非常长的输入序列分成子序列以获得最佳表现。
在这篇文章中，您将发现 6 种不同的方法，您可以使用 Keras 在 Python 中使用截断反向传播通过时间来分割非常长的输入序列以有效地训练循环神经网络。
阅读这篇文章后，你会知道：
- 通过时间截断反向传播是什么以及如何在 Python 深度学习库 Keras 中实现它。
- 输入时间步数的选择究竟如何影响循环神经网络中的学习。
- 您可以使用 6 种不同的技术来分割非常长的序列预测问题，以充分利用截断反向传播时间训练算法。
让我们开始吧。
如何准备 Keras 中截断反向传播的序列预测 照片由Giò，保留一些权利。
通过时间截断反向传播
反向传播是用于更新神经网络中的权重的训练算法，以便最小化预期输出和给定输入的预测输出之间的误差。
对于观察之间存在顺序依赖性的序列预测问题，使用循环神经网络代替经典前馈神经网络。使用 Backpropagation 算法的变体训练循环神经网络，该算法称为 Backpropagation Through Time，简称 BPTT。
实际上，BPTT 展开循环神经网络并在整个输入序列上向后传播误差，一次一个步骤。然后用累积的梯度更新权重。
对于输入序列很长的问题，BPTT 可能很难训练复现神经网络。除了速度之外，在很多时间步长上累积梯度会导致值缩小到零，或者最终溢出或爆炸的值增长。
BPTT 的修改是限制在后向传递中使用的时间步数，并且实际上估计用于更新权重的梯度而不是完全计算它。
这种变化称为截断反向传播时间或 TBPTT。
TBPTT 训练算法有两个参数：
- k1 ：定义正向传递给网络显示的时间步数。
- k2 ：定义在向后传球上估计梯度时要查看的时间步数。
因此，当考虑如何配置训练算法时，我们可以使用符号 TBPTT（k1，k2），其中 k1 = k2 = n，其中 n 是经典非截断 BPTT 的输入序列长度。
TBPTT 配置对 RNN 序列模型的影响
像 LSTM 这样的现代循环神经网络可以使用它们的内部状态来记忆很长的输入序列。如超过数千次的步骤。
这意味着 TBPTT 的配置不一定通过选择时间步长来定义您正在优化的网络内存。您可以选择何时将网络的内部状态与用于更新网络权重的机制分开重置。
相反，TBPTT 参数的选择会影响网络如何估计用于更新权重的误差梯度。更一般地，配置定义了可以考虑网络来对序列问题建模的时间步数。
我们可以正式说明这样的事情：
yhat(t) = f(X(t), X(t-1), X(t-2), ... X(t-n))
在那里是特定时间步长的输出，f（...）是循环神经网络近似的关系，而 X（t）是特定时间步长的观察。
它在概念上与在时间序列问题上训练的多层感知机上的窗口大小相似（但在实践中完全不同），或者与 ARIMA 等线性时间序列模型的 p 和 q 参数相似。 TBPTT 定义了训练期间模型输入序列的范围。
Keras 实现 TBPTT
Keras 深度学习库提供了 TBPTT 的实现，用于训练复现神经网络。
实现比上面列出的一般版本更受限制。
具体地，k1 和 k2 值彼此相等并固定。
- TBPTT（k1，k2），其中 k1 = k2
这是通过训练诸如长短期记忆网络或 LSTM 之类的循环神经网络所需的固定大小的三维输入来实现的。
LSTM 期望输入数据具有尺寸：样本，时间步和特征。
它是此输入格式的第二个维度，即时间步长，用于定义用于序列预测问题的前向和后向传递的时间步数。
因此，在为 Keras 中的序列预测问题准备输入数据时，必须仔细选择指定的时间步数。
时间步的选择将影响两者：
- 在前进过程中积累的内部状态。
- 梯度估计用于更新后向传递的权重。
请注意，默认情况下，每次批量后都会重置网络的内部状态，但可以通过使用所谓的有状态 LSTM 并手动调用重置操作来实现对内部状态重置的更明确控制。
有关 Keras 中有状态 LSTM 的更多信息，请参阅帖子：
在 Keras 中准备 TBPTT 的序列数据
分解序列数据的方式将定义 BPTT 前向和后向传递中使用的时间步数。
因此，您必须仔细考虑如何准备训练数据。
本节列出了您可以考虑的 6 种技术。
1.使用数据原样
如果每个序列中的时间步数是适度的，例如几十或几百步，则可以按原样使用输入序列。
已经提出 TBPTT 的实际限制为约 200 至 400 倍步。
如果序列数据小于或等于此范围，则可以将序列观察值重新整形为输入数据的时间步长。
例如，如果您有一个包含 25 个时间步长的 100 个单变量序列的集合，则可以将其重新整形为 100 个样本，25 个时间步长和 1 个特征或[100,25,1]。
2.朴素的数据拆分
如果您有很长的输入序列，例如数千次步，您可能需要将长输入序列分成多个连续的子序列。
这将需要在 Keras 中使用有状态 LSTM，以便在子序列的输入上保持内部状态，并且仅在真正更充分的输入序列的末尾处重置。
例如，如果您有 100 个输入序列的 50,000 个步骤，那么每个输入序列可以分为 100 个子步骤，500 个步骤。一个输入序列将变为 100 个样本，因此 100 个原始样本将变为 10,000。 Keras 输入的维数为 10,000 个样本，500 个步骤和 1 个特征或[10000,500,1]。需要注意保持每 100 个子序列的状态，并在每 100 个样本之后明确地或通过使用 100 的批量大小重置内部状态。
将整个序列整齐地划分为固定大小的子序列的划分是优选的。全序列因子（子序列长度）的选择是任意的，因此称为“朴素数据分裂”。
将序列分成子序列不考虑关于用于估计用于更新权重的误差梯度的合适数量的时间步的域信息。
3.特定于域的数据拆分
可能很难知道提供错误梯度的有用估计所需的正确时间步数。
我们可以使用朴素的方法（上面）快速获得模型，但模型可能远未优化。
或者，我们可以使用特定于域的信息来估计在学习问题时与模型相关的时间步数。
例如，如果序列问题是回归时间序列，则可能对自相关和部分自相关图的检查可以通知选择时间步数。
如果序列问题是自然语言处理问题，可能输入序列可以按句子分割然后填充到固定长度，或者根据域中的平均句子长度进行分割。
广泛思考并考虑您可以使用哪些特定于您的域的知识将序列拆分为有意义的块。
4.系统数据拆分（例如网格搜索）
您可以系统地为序列预测问题评估一组不同的子序列长度，而不是猜测适当数量的时间步长。
您可以对每个子序列长度执行网格搜索，并采用导致平均表现最佳的模型的配置。
如果您正在考虑这种方法，请注意一些注意事项：
- 从作为整个序列长度因子的子序列长度开始。
- 如果探索不是整个序列长度因子的子序列长度，则使用填充和掩蔽。
- 考虑使用稍微过度规定的网络（更多的存储单元和更多的训练时期）来解决问题，以帮助排除网络容量作为实验的限制。
- 获取每个不同配置的多次运行（例如 30）的平均表现。
如果计算资源不是限制，则建议对不同时间步数进行系统调查。
5.使用 TBPTT 严重依靠内部状态（1,1）
您可以将序列预测问题重新表述为每个时间步一个输入和一个输出。
例如，如果您有 100 个 50 次步长的序列，则每个时间步长将成为新的样本。 100 个样本将变为 5,000。三维输入将变为 5,000 个样本，1 个时间步长和 1 个特征，或[5000,1,1]。
同样，这将要求在序列的每个时间步长内保留内部状态，并在每个实际序列的末尾重置（50 个样本）。
这将把学习序列预测问题的负担放在循环神经网络的内部状态上。根据问题的类型，它可能比网络可以处理的更多，并且预测问题可能无法学习。
个人经验表明，这种表述可能适用于需要记忆序列的预测问题，但是当结果是过去观察的复杂函数时表现不佳。
6.解耦前向和后向序列长度
Keras 深度学习库用于支持通过时间截断反向传播的前向和后向传递的解耦的时间步长数。
实质上，k1 参数可以通过输入序列上的时间步数来指定，而 k2 参数可以通过 LSTM 层上的“truncate_gradient”参数来指定。
这不再受支持，但有一些愿望将此功能重新添加到库中。虽然有证据表明出于效率原因，确切地说为什么它被移除尚不清楚。
你可以在 Keras 探索这种方法。一些想法包括：
- 安装并使用支持“truncate_gradient”参数的旧版 Keras 库（大约 2015 年）。
- 在 Keras 中扩展 LSTM 层实现以支持“truncate_gradient”类型行为。
也许有可用于 Keras 的第三方扩展支持此行为。 如果您发现任何问题，请在下面的评论中告诉我们。
摘要
在这篇文章中，您了解了如何准备序列预测问题数据，以有效利用 Python 深度学习库 Keras 中的截断反向传播时间训练算法。
具体来说，你学到了：
- 如何通过时间截断反向传播以及如何在 Keras 中实现它。
- 如何在 TBPTT 环境中使用非常长的输入序列重新分析或分割数据。
- 如何系统地研究 Keras 中的不同 TBPTT 配置。
你有任何问题吗？ 在下面的评论中提出您的问题，我会尽力回答。
如何在将 LSTM 用于训练和预测时使用不同的批量大小
原文：
machinelearningmastery.com/use-different-batch-sizes-training-predicting-python-keras/
Keras 使用快速符号数学库作为后端，例如 TensorFlow 和 Theano。
使用这些库的缺点是，无论您是在训练网络还是做出预测，数据的形状和大小都必须预先定义并保持不变。
在序列预测问题上，可能需要在训练网络时使用大批量大小，并且在做出预测时使用批量大小为 1 以便预测序列中的下一步骤。
在本教程中，您将了解如何解决此问题，甚至在训练和预测期间使用不同的批量大小。
完成本教程后，您将了解：
- 如何设计简单的序列预测问题并开发 LSTM 来学习它。
- 如何改变在线和基于批量的学习和预测的 LSTM 配置。
- 如何改变用于训练的批量大小与用于预测的批量大小。
让我们开始吧。
如何使用不同的批量大小进行 Python 的训练和预测与 Keras 照片由 steveandtwyla ，保留一些权利。
教程概述
本教程分为 6 个部分，如下所示：
- 批量大小
- 序列预测问题描述
- LSTM 模型和变化的批量大小
- 解决方案 1：在线学习（批量大小= 1）
- 解决方案 2：批量预测（批量大小= N）
- 解决方案 3：复制权重
教程环境
假设 Python 2 或 3 环境已安装并正常工作。
这包括 SciPy 与 NumPy 和 Pandas。必须使用 TensorFlow 或 Keras 后端安装 Keras 2.0 或更高版本。
有关设置 Python 环境的帮助，请参阅帖子：
批量大小
使用 Keras 的一个好处是它建立在象征性数学库之上，如 TensorFlow 和 Theano，可实现快速高效的计算。大型神经网络需要这样做。
使用这些高效库的一个缺点是您必须预先定义数据的范围。具体来说，批量大小。
批量大小限制在可以执行权重更新之前要显示给网络的样本数。当使用拟合模型做出预测时，会施加同样的限制。
具体而言，在拟合模型时使用的批量大小控制着您一次必须进行多少次预测。
当您希望一次进行与训练期间使用的批量大小相同的数字预测时，这通常不是问题。
当您希望进行的预测少于批量大小时，这确实会成为一个问题。例如，您可以获得批量较大的最佳结果，但需要在时间序列或序列问题等方面对一次观察做出预测。
这就是为什么在将网络拟合到训练数据时可能需要具有与在对测试数据或新输入数据做出预测时不同的批量大小的原因。
在本教程中，我们将探索解决此问题的不同方法。
序列预测问题描述
我们将使用简单的序列预测问题作为上下文来演示在训练和预测之间改变批量大小的解决方案。
序列预测问题为不同的批量大小提供了一个很好的案例，因为您可能希望批量大小等于训练期间的训练数据集大小（批量学习），并且在对一步输出做出预测时批量大小为 1。
序列预测问题涉及学习预测以下 10 步序列中的下一步：
[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
我们可以在 Python 中创建这个序列，如下所示：
length = 10
sequence = [i/float(length) for i in range(length)]
print(sequence)
运行该示例打印我们的序列：
[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
我们必须将序列转换为监督学习问题。这意味着当 0.0 显示为输入模式时，网络必须学会将下一步预测为 0.1。
我们可以使用 Pandas shift（） 函数在 Python 中执行此操作，如下所示：
from pandas import concat
from pandas import DataFrame
# create sequence
length = 10
sequence = [i/float(length) for i in range(length)]
# create X/y pairs
df = DataFrame(sequence)
df = concat([df, df.shift(1)], axis=1)
df.dropna(inplace=True)
print(df)
运行该示例显示所有输入和输出对。
1 0.1 0.0
2 0.2 0.1
3 0.3 0.2
4 0.4 0.3
5 0.5 0.4
6 0.6 0.5
7 0.7 0.6
8 0.8 0.7
9 0.9 0.8
我们将使用称为长短期记忆网络的循环神经网络来学习序列。因此，我们必须将输入模式从 2D 数组（1 列 9 行）转换为由[_ 行，时间步长，列 _]组成的 3D 数组，其中时间步长为 1，因为我们只有一个时间步长观察每一行。
我们可以使用 NumPy 函数 reshape（） 执行此操作，如下所示：
from pandas import concat
from pandas import DataFrame
# create sequence
length = 10
sequence = [i/float(length) for i in range(length)]
# create X/y pairs
df = DataFrame(sequence)
df = concat([df, df.shift(1)], axis=1)
df.dropna(inplace=True)
# convert to LSTM friendly format
values = df.values
X, y = values[:, 0], values[:, 1]
X = X.reshape(len(X), 1, 1)
print(X.shape, y.shape)
运行该示例创建X和y数组，准备与 LSTM 一起使用并打印其形状。
(9, 1, 1) (9,)
LSTM 模型和变化的批量大小
在本节中，我们将针对该问题设计 LSTM 网络。
训练批量大小将覆盖整个训练数据集（批量学习），并且将一次一个地做出预测（一步预测）。我们将证明虽然模型能够解决问题，但一步预测会导致错误。
我们将使用适合 1000 个时期的 LSTM 网络。
权重将在每个训练时期结束时更新（批量学习），这意味着批量大小将等于训练观察的数量（9）。
对于这些实验，我们将需要对 LSTM 的内部状态何时更新进行细粒度控制。通常 LSTM 状态在 Keras 的每个批次结束时被清除，但是我们可以通过使 LSTM 有状态并且调用 model.reset_state（） 来手动管理该状态来控制它。这将在后面的章节中提到。
网络有一个输入，一个隐藏层有 10 个单元，一个输出层有 1 个单元。默认的 tanh 激活函数用于 LSTM 单元，而线性激活函数用于输出层。
使用有效的 ADAM 优化算法将均方误差优化函数用于该回归问题。
以下示例配置并创建网络。
# configure network
n_batch = len(X)
n_epoch = 1000
n_neurons = 10
# design network
model = Sequential()
model.add(LSTM(n_neurons, batch_input_shape=(n_batch, X.shape[1], X.shape[2]), stateful=True))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
我们将网络适合每个时期的所有示例，并在每个时期结束时手动重置网络状态。
# fit network
for i in range(n_epoch):
model.fit(X, y, epochs=1, batch_size=n_batch, verbose=1, shuffle=False)
model.reset_states()
最后，我们将一次预测序列中的每个步骤。
这需要批量大小为 1，这与用于适合网络的批量大小 9 不同，并且在运行示例时将导致错误。
# online forecast
for i in range(len(X)):
testX, testy = X[i], y[i]
testX = testX.reshape(1, 1, 1)
yhat = model.predict(testX, batch_size=1)
print('>Expected=%.1f, Predicted=%.1f' % (testy, yhat))
下面是完整的代码示例。
from pandas import DataFrame
from pandas import concat
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
# create sequence
length = 10
sequence = [i/float(length) for i in range(length)]
# create X/y pairs
df = DataFrame(sequence)
df = concat([df, df.shift(1)], axis=1)
df.dropna(inplace=True)
# convert to LSTM friendly format
values = df.values
X, y = values[:, 0], values[:, 1]
X = X.reshape(len(X), 1, 1)
# configure network
n_batch = len(X)
n_epoch = 1000
n_neurons = 10
# design network
model = Sequential()
model.add(LSTM(n_neurons, batch_input_shape=(n_batch, X.shape[1], X.shape[2]), stateful=True))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
# fit network
for i in range(n_epoch):
model.fit(X, y, epochs=1, batch_size=n_batch, verbose=1, shuffle=False)
model.reset_states()
# online forecast
for i in range(len(X)):
testX, testy = X[i], y[i]
testX = testX.reshape(1, 1, 1)
yhat = model.predict(testX, batch_size=1)
print('>Expected=%.1f, Predicted=%.1f' % (testy, yhat))
运行该示例可以很好地匹配模型，并在做出预测时导致错误。
报告的错误如下：
ValueError: Cannot feed value of shape (1, 1, 1) for Tensor 'lstm_1_input:0', which has shape '(9, 1, 1)'
解决方案 1：在线学习（批量大小= 1）
该问题的一个解决方案是使用在线学习来拟合模型。
这是批量大小设置为值 1 并且在每个训练示例之后更新网络权重的位置。
这可以具有更快学习的效果，但也会增加学习过程的不稳定性，因为权重随着每批次而变化很大。
尽管如此，这将使我们能够对问题进行一步预测。唯一需要做的更改是将n_batch设置为 1，如下所示：
n_batch = 1
完整的代码清单如下。
from pandas import DataFrame
from pandas import concat
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
# create sequence
length = 10
sequence = [i/float(length) for i in range(length)]
# create X/y pairs
df = DataFrame(sequence)
df = concat([df, df.shift(1)], axis=1)
df.dropna(inplace=True)
# convert to LSTM friendly format
values = df.values
X, y = values[:, 0], values[:, 1]
X = X.reshape(len(X), 1, 1)
# configure network
n_batch = 1
n_epoch = 1000
n_neurons = 10
# design network
model = Sequential()
model.add(LSTM(n_neurons, batch_input_shape=(n_batch, X.shape[1], X.shape[2]), stateful=True))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
# fit network
for i in range(n_epoch):
model.fit(X, y, epochs=1, batch_size=n_batch, verbose=1, shuffle=False)
model.reset_states()
# online forecast
for i in range(len(X)):
testX, testy = X[i], y[i]
testX = testX.reshape(1, 1, 1)
yhat = model.predict(testX, batch_size=1)
print('>Expected=%.1f, Predicted=%.1f' % (testy, yhat))
运行该示例将打印 9 个预期结果和正确的预测。
>Expected=0.0, Predicted=0.0
>Expected=0.1, Predicted=0.1
>Expected=0.2, Predicted=0.2
>Expected=0.3, Predicted=0.3
>Expected=0.4, Predicted=0.4
>Expected=0.5, Predicted=0.5
>Expected=0.6, Predicted=0.6
>Expected=0.7, Predicted=0.7
>Expected=0.8, Predicted=0.8
解决方案 2：批量预测（批量大小= N）
另一种解决方案是批量生产所有预测。
这意味着我们在模型使用方式上可能非常有限。
我们必须立即使用所有预测，或者只保留第一个预测并丢弃其余的预测。
我们可以通过预测批量大小等于训练批量大小来调整批量预测的示例，然后枚举预测批次，如下所示：
# batch forecast
yhat = model.predict(X, batch_size=n_batch)
for i in range(len(y)):
print('>Expected=%.1f, Predicted=%.1f' % (y[i], yhat[i]))
下面列出了完整的示例。
from pandas import DataFrame
from pandas import concat
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
# create sequence
length = 10
sequence = [i/float(length) for i in range(length)]
# create X/y pairs
df = DataFrame(sequence)
df = concat([df, df.shift(1)], axis=1)
df.dropna(inplace=True)
# convert to LSTM friendly format
values = df.values
X, y = values[:, 0], values[:, 1]
X = X.reshape(len(X), 1, 1)
# configure network
n_batch = len(X)
n_epoch = 1000
n_neurons = 10
# design network
model = Sequential()
model.add(LSTM(n_neurons, batch_input_shape=(n_batch, X.shape[1], X.shape[2]), stateful=True))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
# fit network
for i in range(n_epoch):
model.fit(X, y, epochs=1, batch_size=n_batch, verbose=1, shuffle=False)
model.reset_states()
# batch forecast
yhat = model.predict(X, batch_size=n_batch)
for i in range(len(y)):
print('>Expected=%.1f, Predicted=%.1f' % (y[i], yhat[i]))
运行该示例将打印预期和正确的预测值。
>Expected=0.0, Predicted=0.0
>Expected=0.1, Predicted=0.1
>Expected=0.2, Predicted=0.2
>Expected=0.3, Predicted=0.3
>Expected=0.4, Predicted=0.4
>Expected=0.5, Predicted=0.5
>Expected=0.6, Predicted=0.6
>Expected=0.7, Predicted=0.7
>Expected=0.8, Predicted=0.8
解决方案 3：复制权重
更好的解决方案是使用不同的批量大小进行训练和预测。
执行此操作的方法是从拟合网络复制权重，并使用预先训练的权重创建新网络。
我们可以使用 Keras API 中的 get_weights（） 和 set_weights（） 函数轻松完成此操作，如下所示：
# re-define the batch size
n_batch = 1
# re-define model
new_model = Sequential()
new_model.add(LSTM(n_neurons, batch_input_shape=(n_batch, X.shape[1], X.shape[2]), stateful=True))
new_model.add(Dense(1))
# copy weights
old_weights = model.get_weights()
new_model.set_weights(old_weights)
这将创建一个以批量大小为 1 编译的新模型。然后，我们可以使用此新模型进行一步预测：
# online forecast
for i in range(len(X)):
testX, testy = X[i], y[i]
testX = testX.reshape(1, 1, 1)
yhat = new_model.predict(testX, batch_size=n_batch)
print('>Expected=%.1f, Predicted=%.1f' % (testy, yhat))
The complete example is listed below.
from pandas import DataFrame
from pandas import concat
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
# create sequence
length = 10
sequence = [i/float(length) for i in range(length)]
# create X/y pairs
df = DataFrame(sequence)
df = concat([df, df.shift(1)], axis=1)
df.dropna(inplace=True)
# convert to LSTM friendly format
values = df.values
X, y = values[:, 0], values[:, 1]
X = X.reshape(len(X), 1, 1)
# configure network
n_batch = 3
n_epoch = 1000
n_neurons = 10
# design network
model = Sequential()
model.add(LSTM(n_neurons, batch_input_shape=(n_batch, X.shape[1], X.shape[2]), stateful=True))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
# fit network
for i in range(n_epoch):
model.fit(X, y, epochs=1, batch_size=n_batch, verbose=1, shuffle=False)
model.reset_states()
# re-define the batch size
n_batch = 1
# re-define model
new_model = Sequential()
new_model.add(LSTM(n_neurons, batch_input_shape=(n_batch, X.shape[1], X.shape[2]), stateful=True))
new_model.add(Dense(1))
# copy weights
old_weights = model.get_weights()
new_model.set_weights(old_weights)
# compile model
new_model.compile(loss='mean_squared_error', optimizer='adam')
# online forecast
for i in range(len(X)):
testX, testy = X[i], y[i]
testX = testX.reshape(1, 1, 1)
yhat = new_model.predict(testX, batch_size=n_batch)
print('>Expected=%.1f, Predicted=%.1f' % (testy, yhat))
运行该示例将打印预期的值，并再次正确预测值。
>Expected=0.0, Predicted=0.0
>Expected=0.1, Predicted=0.1
>Expected=0.2, Predicted=0.2
>Expected=0.3, Predicted=0.3
>Expected=0.4, Predicted=0.4
>Expected=0.5, Predicted=0.5
>Expected=0.6, Predicted=0.6
>Expected=0.7, Predicted=0.7
>Expected=0.8, Predicted=0.8
摘要
在本教程中，您了解了如何通过相同的网络来改变用于训练和预测的批量大小的需求。
具体来说，你学到了：
- 如何设计简单的序列预测问题并开发 LSTM 来学习它。
- 如何改变在线和基于批量的学习和预测的 LSTM 配置。
- 如何改变用于训练的批量大小与用于预测的批量大小。
您对批量大小有任何疑问吗？ 在下面的评论中提出您的问题，我会尽力回答。
