Python 中使用长短期记忆网络进行时间序列预测

作者： Jason Brownlee 于 2020年8月28日发表在时间序列深度学习 710

长短期记忆（LSTM）循环神经网络有望学习长序列的观测值。

它似乎是时间序列预测的完美匹配，事实上，它确实可能如此。

在本教程中，您将学习如何为单步单变量时间序列预测问题开发LSTM预测模型。

完成本教程后，您将了解：

如何为预测问题开发性能基线。
如何为单步时间序列预测设计鲁棒的测试框架。
如何准备数据、开发和评估用于时间序列预测的LSTM循环神经网络。

通过我新书《时间序列预测深度学习》来启动您的项目，其中包括分步教程以及所有示例的Python源代码文件。

让我们开始吧。

更新2017年5月：修正了invert_scale()函数中的错误，感谢Max。
2019 年 4 月更新：更新了数据集链接。

Time Series Forecasting with the Long Short-Term Memory Network in Python

Python 中使用长短期记忆网络进行时间序列预测
照片由Matt MacGillivray拍摄，保留部分权利。

教程概述

这是一个很大的主题，我们将涵盖很多内容。准备好了。

本教程分为9个部分；它们是

洗发水销售数据集
测试设置
持久性模型预测
LSTM数据准备
LSTM模型开发
LSTM预测
完整的LSTM示例
开发可靠的结果
教程扩展

Python 环境

本教程假设您已安装Python SciPy环境。您可以使用Python 2或3进行本教程的学习。

您必须安装 Keras（2.0 或更高版本），并使用 TensorFlow 或 Theano 后端。

本教程还假定您已安装 scikit-learn、Pandas、NumPy 和 Matplotlib。

如果您在环境方面需要帮助，请参阅此帖子

如何使用 Anaconda 设置用于机器学习和深度学习的 Python 环境

时间序列深度学习需要帮助吗？

立即参加我为期7天的免费电子邮件速成课程（附示例代码）。

点击注册，同时获得该课程的免费PDF电子书版本。

洗发水销售数据集

此数据集描述了 3 年期间洗发水月销量。

单位是销售计数，共有 36 个观测值。原始数据集归功于 Makridakis、Wheelwright 和 Hyndman (1998)。

下载数据集.

将数据集下载到您当前的目录中，并命名为“shampoo-sales.csv”。

以下示例加载并创建加载数据集的图表。

# 加载并绘制数据集

from pandas import read_csv

from pandas import datetime

from matplotlib import pyplot

# 加载数据集

def parser(x):

return datetime.strptime('190'+x, '%Y-%m')

series = read_csv('shampoo-sales.csv', header=0, parse_dates=[0], index_col=0, squeeze=True, date_parser=parser)

# 总结前几行

print(series.head())

# 线图

series.plot()

pyplot.show()

运行该示例将数据集作为 Pandas Series 加载并打印前 5 行。

月份

1901-01-01 266.0

1901-02-01 145.9

1901-03-01 183.1

1901-04-01 119.3

1901-05-01 180.3

名称：销售额，数据类型：float64

然后创建该系列的线图，显示出明显的上升趋势。

Line Plot of Monthly Shampoo Sales Dataset

月度洗发水销量数据集的折线图

实验测试设置

我们将把洗发水销售数据集分为两部分：训练集和测试集。

前两年的数据将用于训练数据集，剩下的一年数据将用于测试集。

例如

# 分割数据为训练集和测试集

X = series.values

train, test = X[0:-12], X[-12:]

模型将使用训练数据集进行开发，并对测试数据集进行预测。

将使用滚动预测场景，也称为前向模型验证。

测试数据集的每个时间步将逐一进行。模型将用于对该时间步进行预测，然后将从测试集中获取实际期望值，并将其提供给模型用于下一个时间步的预测。

例如

# 步进验证

history = [x for x in train]

predictions = list()

for i in range(len(test)):

# 进行预测...

这模拟了现实世界场景，其中每个月都会有新的洗发水销售观察值，并用于预测下个月。

最后，将收集测试数据集上的所有预测，并计算一个误差分数来总结模型的技能。根均方误差（RMSE）将被使用，因为它会惩罚较大的误差，并产生一个与预测数据单位相同的分数，即月度洗发水销量。

例如

from sklearn.metrics import mean_squared_error

rmse = sqrt(mean_squared_error(test, predictions))

print('RMSE: %.3f' % rmse)

持久性模型预测

具有线性增长趋势的时间序列的一个良好基线预测是持久性预测。

持久性预测是指使用前一个时间步（t-1）的观测值来预测当前时间步（t）的观测值。

我们可以通过采用训练数据中的最后一个观测值和通过前向验证累积的历史来实施这一点，并使用它来预测当前时间步。

例如

1 2	# 进行预测 yhat = history[-1]

我们将把所有预测累积在一个数组中，以便它们可以直接与测试数据集进行比较。

以下列表是关于洗发水销量数据集的持久性预测模型的完整示例。

from pandas import read_csv

from pandas import datetime

from sklearn.metrics import mean_squared_error

from math import sqrt

from matplotlib import pyplot

# 加载数据集

def parser(x):

return datetime.strptime('190'+x, '%Y-%m')

series = read_csv('shampoo-sales.csv', header=0, parse_dates=[0], index_col=0, squeeze=True, date_parser=parser)

# 分割数据为训练集和测试集

X = series.values

train, test = X[0:-12], X[-12:]

# 步进验证

history = [x for x in train]

predictions = list()

for i in range(len(test)):

# 进行预测

predictions.append(history[-1])

# 观测

history.append(test[i])

# 报告表现

rmse = sqrt(mean_squared_error(test, predictions))

print('RMSE: %.3f' % rmse)

# 观测值与预测值的线图

pyplot.plot(test)

pyplot.plot(predictions)

pyplot.show()

注意：由于算法或评估程序的随机性，或数值精度的差异，您的结果可能会有所不同。请考虑运行示例几次并比较平均结果。

运行该示例将打印出测试数据集上的预测的RMSE，大约为136个（月度洗发水销量）。

1	RMSE: 136.761

还将创建一个测试数据集（蓝色）与预测值（橙色）进行比较的折线图，在上下文中显示持久性模型的预测。

Persistence Forecast of Observed vs Predicted for Shampoo Sales Dataset

洗发水销量数据集的观测值与预测值对比的持久性预测

有关时间序列预测的持久性模型的更多信息，请参阅此帖

如何使用 Python 为时间序列预测制作基线预测

现在我们有了数据集的性能基线，我们可以开始为数据开发LSTM模型。

需要 LSTM 帮助进行序列预测吗？

参加我的免费7天电子邮件课程，了解6种不同的LSTM架构（附代码）。

点击注册，同时获得该课程的免费PDF电子书版本。

LSTM数据准备

在我们使用 LSTM 模型拟合数据集之前，我们必须转换数据。

本节分为三个步骤

将时间序列转换为监督学习问题
转换时间序列数据使其平稳。
将观测值转换为特定的比例。

将时间序列转换为监督学习

Keras中的LSTM模型假设您的数据已划分为输入（X）和输出（y）部分。

对于时间序列问题，我们可以通过使用最后一个时间步（t-1）的观测值作为输入，当前时间步（t）的观测值作为输出来实现这一点。

我们可以使用Pandas中的shift()函数来实现这一点，该函数将使序列中的所有值向下移动指定的位数。我们需要移动1位，这将成为输入变量。时间序列按原样将成为输出变量。

然后，我们可以将这两个序列连接起来，创建一个准备好进行监督学习的DataFrame。向下移动的序列将在顶部有一个新的位置，没有值。我们将用0值替换这些NaN值，LSTM模型必须学习这些值作为“序列的开始”或“这里没有数据”，因为在此数据集中未观察到销量为零的月份。

下面的代码定义了一个名为timeseries_to_supervised()的辅助函数。它接受原始时间序列数据的NumPy数组和一个滞后值或要创建和用作输入的移位序列的数量。

# 将序列构造成监督学习问题

def timeseries_to_supervised(data, lag=1):

df = DataFrame(data)

columns = [df.shift(i) for i in range(1, lag+1)]

columns.append(df)

df = concat(columns, axis=1)

df.fillna(0, inplace=True)

return df

我们可以用加载的洗发水销量数据集来测试这个函数，并将其转换为一个监督学习问题。

from pandas import read_csv

from pandas import datetime

from pandas import DataFrame

from pandas import concat

# 将序列构造成监督学习问题

def timeseries_to_supervised(data, lag=1):

df = DataFrame(data)

columns = [df.shift(i) for i in range(1, lag+1)]

columns.append(df)

df = concat(columns, axis=1)

df.fillna(0, inplace=True)

return df

# 加载数据集

def parser(x):

return datetime.strptime('190'+x, '%Y-%m')

series = read_csv('shampoo-sales.csv', header=0, parse_dates=[0], index_col=0, squeeze=True, date_parser=parser)

# 转换为监督学习

X = series.values

supervised = timeseries_to_supervised(X, 1)

print(supervised.head())

运行该示例将打印出新的监督学习问题的前5行。

0 0

0 0.000000 266.000000

1 266.000000 145.899994

2 145.899994 183.100006

3 183.100006 119.300003

4 119.300003 180.300003

有关将时间序列问题转换为监督学习问题的更多信息，请参阅帖子

将时间序列预测作为监督学习

将时间序列转换为平稳

洗发水销量数据集不是平稳的。

这意味着数据中存在依赖于时间的结构。特别是，数据存在增长趋势。

平稳数据更容易建模，并且很可能产生更具技能的预测。

趋势可以从观测值中移除，然后添加到预测值中，以便将预测值恢复到原始尺度并计算可比较的误差分数。

移除趋势的标准方法是对数据进行差分。也就是说，将当前观测值（t）减去前一个时间步（t-1）的观测值。这消除了趋势，我们得到的是差分序列，或者说观测值随时间步长的变化。

我们可以使用Pandas中的diff()函数自动实现这一点。或者，我们可以获得更精细地控制并编写自己的函数来实现这一点，在这种情况下，后者因其灵活性而更受青睐。

下面的函数称为difference()，它计算差分序列。请注意，序列中的第一个观测值被跳过了，因为没有之前的观测值可以用来计算差分值。

# 创建差分序列

def difference(dataset, interval=1):

diff = list()

for i in range(interval, len(dataset)):

value = dataset[i] - dataset[i - interval]

diff.append(value)

return Series(diff)

我们还需要反转这个过程，以便将对差分序列进行的预测值恢复到原始尺度。

下面的函数称为inverse_difference()，它反转了这个操作。

# 反转差分值

def inverse_difference(history, yhat, interval=1):

return yhat + history[-interval]

我们可以像下面这样，通过对整个序列进行差分，然后将其恢复到原始尺度来测试这些函数

from pandas import read_csv

from pandas import datetime

from pandas import Series

# 创建差分序列

def difference(dataset, interval=1):

diff = list()

for i in range(interval, len(dataset)):

value = dataset[i] - dataset[i - interval]

diff.append(value)

return Series(diff)

# 反转差分值

def inverse_difference(history, yhat, interval=1):

return yhat + history[-interval]

# 加载数据集

def parser(x):

return datetime.strptime('190'+x, '%Y-%m')

series = read_csv('shampoo-sales.csv', header=0, parse_dates=[0], index_col=0, squeeze=True, date_parser=parser)

print(series.head())

# 转换为平稳

differenced = difference(series, 1)

print(differenced.head())

# 反向转换

inverted = list()

for i in range(len(differenced)):

value = inverse_difference(series, differenced[i], len(series)-i)

inverted.append(value)

inverted = Series(inverted)

print(inverted.head())

运行该示例，首先打印加载数据的前5行，然后是差分序列的前5行，最后是反转差分操作后的前5行。

请注意，原始数据集的第一个观测值已从反转差分数据中移除。除此之外，最后一组数据与预期的第一组数据匹配。

月份

1901-01-01 266.0

1901-02-01 145.9

1901-03-01 183.1

1901-04-01 119.3

1901-05-01 180.3

名称：销售额，数据类型：float64

0 -120.1

1 37.2

2 -63.8

3 61.0

4 -11.8

dtype: float64

0 145.9

1 183.1

2 119.3

3 180.3

4 168.5

dtype: float64

有关使时间序列平稳和差分的更多信息，请参阅帖子

将时间序列转换为比例

与其他神经网络一样，LSTM期望数据在网络使用的激活函数的范围内。

LSTM的默认激活函数是双曲正切（tanh），它输出介于-1和1之间的值。这是时间序列数据的首选范围。

为了使实验公平，必须在训练数据集上计算缩放系数（最小值和最大值），并将它们应用于测试数据集和任何预测。这是为了避免用测试数据集的知识污染实验，这可能会给模型带来微小的优势。

我们可以使用MinMaxScaler类将数据集转换为[-1, 1]范围。与其他scikit-learn的转换类一样，它要求数据以矩阵格式提供，包含行和列。因此，我们必须在转换之前重塑我们的NumPy数组。

例如

# 缩放转换

X = series.values

X = X.reshape(len(X), 1, X.shape[1])

scaler = MinMaxScaler(feature_range=(-1, 1))

scaler = scaler.fit(X)

scaled_X = scaler.transform(X)

同样，我们必须对预测值进行反向缩放，将它们恢复到原始尺度，以便可以解释结果并计算可比较的误差分数。

1 2	# 反向转换 inverted_X = scaler.inverse_transform(scaled_X)

将所有这些内容放在一起，下面的示例转换了洗发水销量数据的比例。

from pandas import read_csv

from pandas import datetime

from pandas import Series

from sklearn.preprocessing import MinMaxScaler

# 加载数据集

def parser(x):

return datetime.strptime('190'+x, '%Y-%m')

series = read_csv('shampoo-sales.csv', header=0, parse_dates=[0], index_col=0, squeeze=True, date_parser=parser)

print(series.head())

# 缩放转换

X = series.values

X = X.reshape(len(X), 1, X.shape[1])

scaler = MinMaxScaler(feature_range=(-1, 1))

scaler = scaler.fit(X)

scaled_X = scaler.transform(X)

scaled_series = Series(scaled_X[:, 0])

print(scaled_series.head())

# 反向转换

inverted_X = scaler.inverse_transform(scaled_X)

inverted_series = Series(inverted_X[:, 0])

print(inverted_series.head())

运行该示例，首先打印加载数据的前5行，然后是缩放数据的前5行，最后是反转缩放转换后的前5行，这与原始数据匹配。

月份

1901-01-01 266.0

1901-02-01 145.9

1901-03-01 183.1

1901-04-01 119.3

1901-05-01 180.3

名称：销售额，数据类型：float64

0 -0.478585

1 -0.905456

2 -0.773236

3 -1.000000

4 -0.783188

dtype: float64

0 266.0

1 145.9

2 183.1

3 119.3

4 180.3

dtype: float64

现在我们知道如何为LSTM网络准备数据，我们可以开始开发我们的模型。

LSTM模型开发

长短期记忆网络（LSTM）是一种循环神经网络（RNN）的类型。

这种类型网络的优点在于它可以学习和记忆长序列，并且不依赖于预先指定的窗口滞后观测值作为输入。

在Keras中，这被称为有状态，并且涉及在定义LSTM层时将“stateful”参数设置为“True”。

默认情况下，Keras中的LSTM层在批次数据之间保持状态。数据批次是训练数据集中固定数量的行，它定义了在更新网络权重之前要处理多少模式。LSTM层在批次之间的状态默认被清除，因此我们必须使LSTM有状态。这使我们能够精细地控制LSTM层何时被清除状态，通过调用reset_states()函数。

LSTM层期望输入是一个矩阵，其维度为：[样本数, 时间步数, 特征数]。

样本数：这些是领域中的独立观测值，通常是数据行。
时间步数：这些是给定观测值的给定变量的独立时间步。
特征数：这些是在观测时观测到的独立度量。

我们在如何为网络构建洗发水销量数据集方面有一些灵活性。我们将保持简单，并将问题构建为原始序列中的每个时间步都是一个单独的样本，具有一个时间步和一个特征。

鉴于训练数据集定义为X输入和y输出，它必须被重塑为样本/时间步/特征格式，例如

1 2	X, y = train[:, 0:-1], train[:, -1] X = X.reshape(X.shape[0], 1, X.shape[1])

输入数据的形状必须在LSTM层中使用“batch_input_shape”参数指定，该参数是一个元组，指定了每批读取的预期观测数、时间步数和特征数。

批次大小通常远小于总样本数。它与训练轮数一起定义了网络学习数据的速度（权重更新的频率）。

定义LSTM层的最后一个导入参数是神经元数量，也称为内存单元或块的数量。这是一个相对简单的问题，1到5之间的数字应该足够了。

下面的行创建了一个单一的LSTM隐藏层，该层还通过“batch_input_shape”参数指定了对输入层的期望。

1	layer = LSTM(neurons, batch_input_shape=(batch_size, X.shape[1], X.shape[2]), stateful=True)

网络需要在输出层有一个神经元，并使用线性激活来预测下一个时间步的洗发水销量。

一旦网络被指定，它必须使用后端数学库（如TensorFlow或Theano）编译成一个有效的符号表示。

在编译网络时，我们必须指定一个损失函数和一个优化算法。我们将使用“mean_squared_error”作为损失函数，因为它与我们感兴趣的RMSE非常接近，并且使用高效的ADAM优化算法。

使用Sequential Keras API来定义网络，下面的代码片段创建并编译了网络。

model = Sequential()

model.add(LSTM(neurons, batch_input_shape=(batch_size, X.shape[1], X.shape[2]), stateful=True))

model.add(Dense(1))

model.compile(loss='mean_squared_error', optimizer='adam')

编译后，可以将其拟合到训练数据。由于网络是状态保持的，我们必须控制何时重置内部状态。因此，我们必须手动管理训练过程，一次一个 epoch，跨越所需的 epoch 数量。

默认情况下，epoch 中的样本在暴露给网络之前会被打乱。同样，这对于 LSTM 是不理想的，因为我们希望网络在学习跨观测序列时能够建立状态。我们可以通过将“shuffle”设置为“False“来禁用样本的打乱。

默认情况下，网络会在每个 epoch 结束时报告有关模型学习进度和技能的大量调试信息。我们可以通过将“verbose”参数设置为“0“级别来禁用此功能。

然后，我们可以在训练 epoch 结束时重置内部状态，为下一次训练迭代做好准备。

下面是一个手动将网络拟合到训练数据的循环。

for i in range(nb_epoch):

model.fit(X, y, epochs=1, batch_size=batch_size, verbose=0, shuffle=False)

model.reset_states()

将所有这些结合起来，我们可以定义一个名为 fit_lstm() 的函数来训练并返回一个 LSTM 模型。作为参数，它接受监督学习格式的训练数据集、批量大小、 epoch 数量和神经元数量。

def fit_lstm(train, batch_size, nb_epoch, neurons):

X, y = train[:, 0:-1], train[:, -1]

X = X.reshape(X.shape[0], 1, X.shape[1])

model = Sequential()

model.add(LSTM(neurons, batch_input_shape=(batch_size, X.shape[1], X.shape[2]), stateful=True))

model.add(Dense(1))

model.compile(loss='mean_squared_error', optimizer='adam')

for i in range(nb_epoch):

model.fit(X, y, epochs=1, batch_size=batch_size, verbose=0, shuffle=False)

model.reset_states()

return model

批量大小必须设置为 1。这是因为它必须是训练集和测试集大小的因子。

模型上的 predict() 函数也受到批量大小的限制；在那里，它必须设置为 1，因为我们有兴趣对测试数据进行一步预测。

在本教程中，我们不会调整网络参数；相反，我们将使用以下配置，通过一些试错法找到的配置：

批量大小：1
Epoch：3000
神经元：4

作为本教程的扩展，您可能想探索不同的模型参数，看看是否可以提高性能。

更新：尝试 1500 个 epoch 和 1 个神经元，性能可能会更好！

接下来，我们将看看如何使用已拟合的 LSTM 模型来进行一步预测。

LSTM预测

一旦 LSTM 模型拟合到训练数据，就可以用于进行预测。

同样，我们也有一些灵活性。我们可以选择在所有训练数据上拟合模型一次，然后从测试数据中一次一个时间步长进行预测（我们称之为固定方法），或者我们可以每次在测试数据的时间步长上重新拟合模型或更新模型，因为测试数据中的新观测值可用（我们称之为动态方法）。

在本教程中，我们将采用固定方法，因为它更简单，尽管我们预计动态方法将带来更好的模型技能。

要进行预测，我们可以调用模型上的 predict() 函数。这需要一个 3D NumPy 数组作为输入参数。在这种情况下，它将是一个包含一个值的数组，即前一个时间步长的观测值。

predict() 函数返回一个预测数组，每个输入行一个。由于我们提供单个输入，输出将是一个包含一个值的 2D NumPy 数组。

我们可以将此行为捕获在名为 forecast() 的函数中，如下所示。给定一个已拟合的模型、拟合模型时使用的批量大小（例如 1）以及来自测试数据的一行，该函数将从测试行中分离出输入数据，对其进行重塑，并将预测作为一个浮点值返回。

def forecast(model, batch_size, row):

X = row[0:-1]

X = X.reshape(1, 1, len(X))

yhat = model.predict(X, batch_size=batch_size)

return yhat[0,0]

在训练期间，内部状态会在每个 epoch 后重置。在预测期间，我们不希望在预测之间重置内部状态。实际上，我们希望模型在预测测试数据集中的每个时间步长时都能建立状态。

这引出了一个问题：在预测测试数据集之前，网络的初始状态应该是什么？

在本教程中，我们将通过对训练数据集中的所有样本进行预测来播种状态。理论上，内部状态应该设置好，以便预测下一个时间步长。

现在我们拥有了拟合洗发水销量数据集的 LSTM 网络模型并评估其性能的所有要素。

在下一节中，我们将把所有这些要素结合起来。

完整的LSTM示例

本节将拟合一个 LSTM 到洗发水销量数据集并评估模型。

这将涉及整合前面各节的所有元素。它们很多，所以让我们回顾一下：

从 CSV 文件加载数据集。
转换数据集，使其适合 LSTM 模型，包括：
1. 将数据转换为监督学习问题。
2. 将数据转换为平稳。
3. 将数据转换为尺度为 -1 到 1。
将状态保持的 LSTM 网络模型拟合到训练数据。
在测试数据上评估静态 LSTM 模型。
报告预测的性能。

关于示例的一些注意事项：

缩放和反向缩放行为已移至 scale() 和 invert_scale() 函数中，以保持简洁。
测试数据使用从训练数据拟合的缩放器进行缩放，这是必需的，以确保测试数据的 min/max 值不会影响模型。
为了方便起见，调整了数据转换的顺序，首先使数据平稳，然后转换为监督学习问题，最后进行缩放。
为了方便起见，在将数据拆分为训练集和测试集之前，对整个数据集进行了差分。我们也可以在步进验证期间收集观测值并逐个进行差分。我为了可读性而放弃了这一点。

完整的示例如下所示。

from pandas import DataFrame
from pandas import Series
from pandas import concat
from pandas import read_csv
from pandas import datetime
from sklearn.metrics import mean_squared_error
from sklearn.preprocessing import MinMaxScaler
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from math import sqrt
from matplotlib import pyplot
import numpy

# date-time parsing function for loading the dataset
def parser(x):
	return datetime.strptime('190'+x, '%Y-%m')

# frame a sequence as a supervised learning problem
def timeseries_to_supervised(data, lag=1):
	df = DataFrame(data)
	columns = [df.shift(i) for i in range(1, lag+1)]
	columns.append(df)
	df = concat(columns, axis=1)
	df.fillna(0, inplace=True)
	return df

# create a differenced series
def difference(dataset, interval=1):
	diff = list()
	for i in range(interval, len(dataset)):
		value = dataset[i] - dataset[i - interval]
		diff.append(value)
	return Series(diff)

# invert differenced value
def inverse_difference(history, yhat, interval=1):
	return yhat + history[-interval]

# scale train and test data to [-1, 1]
def scale(train, test):
	# fit scaler
	scaler = MinMaxScaler(feature_range=(-1, 1))
	scaler = scaler.fit(train)
	# transform train
	train = train.reshape(train.shape[0], train.shape[1])
	train_scaled = scaler.transform(train)
	# transform test
	test = test.reshape(test.shape[0], test.shape[1])
	test_scaled = scaler.transform(test)
	return scaler, train_scaled, test_scaled

# inverse scaling for a forecasted value
def invert_scale(scaler, X, value):
	new_row = [x for x in X] + [value]
	array = numpy.array(new_row)
	array = array.reshape(1, len(array))
	inverted = scaler.inverse_transform(array)
	return inverted[0, -1]

# fit an LSTM network to training data
def fit_lstm(train, batch_size, nb_epoch, neurons):
	X, y = train[:, 0:-1], train[:, -1]
	X = X.reshape(X.shape[0], 1, X.shape[1])
	model = Sequential()
	model.add(LSTM(neurons, batch_input_shape=(batch_size, X.shape[1], X.shape[2]), stateful=True))
	model.add(Dense(1))
	model.compile(loss='mean_squared_error', optimizer='adam')
	for i in range(nb_epoch):
		model.fit(X, y, epochs=1, batch_size=batch_size, verbose=0, shuffle=False)
		model.reset_states()
	return model

# make a one-step forecast
def forecast_lstm(model, batch_size, X):
	X = X.reshape(1, 1, len(X))
	yhat = model.predict(X, batch_size=batch_size)
	return yhat[0,0]

# load dataset
series = read_csv('shampoo-sales.csv', header=0, parse_dates=[0], index_col=0, squeeze=True, date_parser=parser)

# transform data to be stationary
raw_values = series.values
diff_values = difference(raw_values, 1)

# transform data to be supervised learning
supervised = timeseries_to_supervised(diff_values, 1)
supervised_values = supervised.values

# split data into train and test-sets
train, test = supervised_values[0:-12], supervised_values[-12:]

# transform the scale of the data
scaler, train_scaled, test_scaled = scale(train, test)

# fit the model
lstm_model = fit_lstm(train_scaled, 1, 3000, 4)
# forecast the entire training dataset to build up state for forecasting
train_reshaped = train_scaled[:, 0].reshape(len(train_scaled), 1, 1)
lstm_model.predict(train_reshaped, batch_size=1)

# walk-forward validation on the test data
predictions = list()
for i in range(len(test_scaled)):
	# make one-step forecast
	X, y = test_scaled[i, 0:-1], test_scaled[i, -1]
	yhat = forecast_lstm(lstm_model, 1, X)
	# invert scaling
	yhat = invert_scale(scaler, X, yhat)
	# invert differencing
	yhat = inverse_difference(raw_values, yhat, len(test_scaled)+1-i)
	# store forecast
	predictions.append(yhat)
	expected = raw_values[len(train) + i + 1]
	print('Month=%d, Predicted=%f, Expected=%f' % (i+1, yhat, expected))

# report performance
rmse = sqrt(mean_squared_error(raw_values[-12:], predictions))
print('Test RMSE: %.3f' % rmse)
# line plot of observed vs predicted
pyplot.plot(raw_values[-12:])
pyplot.plot(predictions)
pyplot.show()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

from pandas import DataFrame

from pandas import Series

从 pandas 导入 concat

from pandas import read_csv

from pandas import datetime

from sklearn.metrics import mean_squared_error

从 sklearn.预处理导入 MinMaxScaler

from keras.models import Sequential

from keras.layers import Dense

从 keras.layers 导入 LSTM

from math import sqrt

from matplotlib import pyplot

import numpy

# 用于加载数据集的日期时间解析函数

def parser(x):

return datetime.strptime('190'+x, '%Y-%m')

# 将序列构造成监督学习问题

def timeseries_to_supervised(data, lag=1):

df = DataFrame(data)

columns = [df.shift(i) for i in range(1, lag+1)]

columns.append(df)

df = concat(columns, axis=1)

df.fillna(0, inplace=True)

return df

# 创建差分序列

def difference(dataset, interval=1):

diff = list()

for i in range(interval, len(dataset)):

value = dataset[i] - dataset[i - interval]

diff.append(value)

return Series(diff)

# 反转差分值

def inverse_difference(history, yhat, interval=1):

return yhat + history[-interval]

# 将训练和测试数据缩放到 [-1, 1]

def scale(train, test):

# 拟合缩放器

scaler = MinMaxScaler(feature_range=(-1, 1))

scaler = scaler.fit(train)

# 转换训练集

train = train.reshape(train.shape[0], train.shape[1])

train_scaled = scaler.transform(train)

# 转换测试集

test = test.reshape(test.shape[0], test.shape[1])

test_scaled = scaler.transform(test)

return scaler, train_scaled, test_scaled

# 预测值的逆缩放

def invert_scale(scaler, X, value):

new_row = [x for x in X] + [value]

array = numpy.array(new_row)

array = array.reshape(1, len(array))

inverted = scaler.inverse_transform(array)

return inverted[0, -1]

# 训练一个 LSTM 网络

def fit_lstm(train, batch_size, nb_epoch, neurons):

X, y = train[:, 0:-1], train[:, -1]

X = X.reshape(X.shape[0], 1, X.shape[1])

model = Sequential()

model.add(LSTM(neurons, batch_input_shape=(batch_size, X.shape[1], X.shape[2]), stateful=True))

model.add(Dense(1))

model.compile(loss='mean_squared_error', optimizer='adam')

for i in range(nb_epoch):

model.fit(X, y, epochs=1, batch_size=batch_size, verbose=0, shuffle=False)

model.reset_states()

return model

# 进行一步预测

def forecast_lstm(model, batch_size, X):

X = X.reshape(1, 1, len(X))

yhat = model.predict(X, batch_size=batch_size)

return yhat[0,0]

# 加载数据集

series = read_csv('shampoo-sales.csv', header=0, parse_dates=[0], index_col=0, squeeze=True, date_parser=parser)

# 将数据转换为平稳

raw_values = series.values

diff_values = difference(raw_values, 1)

# 将数据转换为监督学习

supervised = timeseries_to_supervised(diff_values, 1)

supervised_values = supervised.values

# 将数据分为训练集和测试集

train, test = supervised_values[0:-12], supervised_values[-12:]

# 转换数据尺度

scaler, train_scaled, test_scaled = scale(train, test)

# 拟合模型

lstm_model = fit_lstm(train_scaled, 1, 3000, 4)

# 预测整个训练数据集以建立预测状态

train_reshaped = train_scaled[:, 0].reshape(len(train_scaled), 1, 1)

lstm_model.predict(train_reshaped, batch_size=1)

# 对测试数据进行步进验证

predictions = list()

for i in range(len(test_scaled)):

# 进行一步预测

X, y = test_scaled[i, 0:-1], test_scaled[i, -1]

yhat = forecast_lstm(lstm_model, 1, X)

# 反转缩放

yhat = invert_scale(scaler, X, yhat)

# 反转差分

yhat = inverse_difference(raw_values, yhat, len(test_scaled)+1-i)

# 存储预测

predictions.append(yhat)

expected = raw_values[len(train) + i + 1]

print('Month=%d, Predicted=%f, Expected=%f' % (i+1, yhat, expected))

# 报告表现

rmse = sqrt(mean_squared_error(raw_values[-12:], predictions))

print('Test RMSE: %.3f' % rmse)

# 观测值与预测值的线图

pyplot.plot(raw_values[-12:])

pyplot.plot(predictions)

pyplot.show()

运行示例会打印测试数据集中 12 个月的预期值和预测值。

注意：由于算法或评估程序的随机性，或数值精度的差异，您的结果可能会有所不同。请考虑运行示例几次并比较平均结果。

示例还会打印所有预测的 RMSE。该模型显示月度洗发水销量 RMSE 为 71.721，这比达到 136.761 销量 RMSE 的持久性模型要好。

Month=1, Predicted=351.582196, Expected=339.700000

Month=2, Predicted=432.169667, Expected=440.400000

Month=3, Predicted=378.064505, Expected=315.900000

Month=4, Predicted=441.370077, Expected=439.300000

Month=5, Predicted=446.872627, Expected=401.300000

Month=6, Predicted=514.021244, Expected=437.400000

Month=7, Predicted=525.608903, Expected=575.500000

Month=8, Predicted=473.072365, Expected=407.600000

Month=9, Predicted=523.126979, Expected=682.000000

Month=10, Predicted=592.274106, Expected=475.300000

Month=11, Predicted=589.299863, Expected=581.300000

Month=12, Predicted=584.149152, Expected=646.900000

Test RMSE: 71.721

还会创建一个测试数据（蓝色）与预测值（橙色）的折线图，为模型技能提供背景。

Line Plot of LSTM Forecast vs Expected Values

LSTM 预测与预期值折线图

作为附注，您可以进行一个快速实验，以建立对测试框架以及所有转换和反向转换的信任。

注释掉在步进验证中拟合 LSTM 模型的行。

1	yhat = forecast_lstm(lstm_model, 1, X)

并替换为以下内容：

yhat = y

这应该会产生一个具有完美技能的模型（例如，一个将预期结果作为模型输出的模型）。

结果应如下所示，表明如果 LSTM 模型可以完美地预测序列，则反向转换和误差计算将正确显示它。

Month=1, Predicted=339.700000, Expected=339.700000

Month=2, Predicted=440.400000, Expected=440.400000

Month=3, Predicted=315.900000, Expected=315.900000

Month=4, Predicted=439.300000, Expected=439.300000

Month=5, Predicted=401.300000, Expected=401.300000

Month=6, Predicted=437.400000, Expected=437.400000

Month=7, Predicted=575.500000, Expected=575.500000

Month=8, Predicted=407.600000, Expected=407.600000

Month=9, Predicted=682.000000, Expected=682.000000

Month=10, Predicted=475.300000, Expected=475.300000

Month=11, Predicted=581.300000, Expected=581.300000

Month=12, Predicted=646.900000, Expected=646.900000

Test RMSE: 0.000

开发可靠的结果

神经网络的一个难题是它们在不同的初始条件下会产生不同的结果。

一种方法可能是固定 Keras 使用的随机数种子以确保结果可复现。另一种方法是通过不同的实验设置来控制随机初始条件。

我们可以重复上一节的实验多次，然后取平均 RMSE 作为配置在平均情况下对未见数据的预期性能的指示。

这通常称为多次重复或多次重启。

我们可以将模型拟合和步进验证包装在一个固定次数的重复循环中。每次迭代都会记录该次运行的 RMSE。然后我们可以总结 RMSE 分数的分布。

# 重复实验

repeats = 30

error_scores = list()

for r in range(repeats):

# 拟合模型

lstm_model = fit_lstm(train_scaled, 1, 3000, 4)

# 预测整个训练数据集以建立预测状态

train_reshaped = train_scaled[:, 0].reshape(len(train_scaled), 1, 1)

lstm_model.predict(train_reshaped, batch_size=1)

# walk-forward validation on the test data

predictions = list()

for i in range(len(test_scaled)):

# 进行一步预测

X, y = test_scaled[i, 0:-1], test_scaled[i, -1]

yhat = forecast_lstm(lstm_model, 1, X)

# 反转缩放

yhat = invert_scale(scaler, X, yhat)

# 反转差分

yhat = inverse_difference(raw_values, yhat, len(test_scaled)+1-i)

# 存储预测

predictions.append(yhat)

# 报告性能

rmse = sqrt(mean_squared_error(raw_values[-12:], predictions))

print('%d) Test RMSE: %.3f' % (r+1, rmse))

error_scores.append(rmse)

数据准备与之前相同。

我们将使用 30 次重复，因为这足以提供良好的 RMSE 分数分布。