通过本文你将了解：
- 如何开发LSTM网络，把时序预测问题转述为回归问题。
- 针对时序问题使用窗口(window)和时间步（time step） 来开发 LSTM 网络。
- 在非常长序列中，如何使用保存了状态的LSTM网络进行开发和做预测。
对于标准的时序预测问题，我们将开发多个 LSTM 神经单元。下面的问题和所选择的配置都是为了说明问题，并不最优的。下面的例子正式的介绍如何开发属于自己的LSTM神经网络并解决时序预测问题。
时序预测问题是预测建模问题中的一个难点，不像回归预测那样，在输入变量中，时序也增加了序列中依赖的复杂性。有一种强大的神经网络专门处理时序依赖问题，我们称之为递归神经网络 GitCode信息数据平台 · 技术 递归神经网络 递归神经网络是一类用结构递归的方式构建的网络，比如说递归自编码机（Recursive Autoencoder），在自然语言处理的神经网络分析方法中用于解析语句。 参考：维基百科 由 Gatsby 贡献 查询内容 编辑术语 贡献术语 （RNN）。LSTM就是递归神经网络的一种，它能成功在深度学习中应用，主要是因为它的结构能够成功被训练。在这节课中，你将学习如何通过Keras GitCode信息数据平台 · 技术 Keras Keras是一个用Python编写的开源神经网络库，能够在TensorFlow、Microsoft Cognitive Toolkit、Theano或PlaidML之上运行[2][3]。Keras旨在快速实现深度神经网络，专注于用户友好、模块化和可扩展性，主要作者和维护者是Google工程师弗朗索瓦·肖莱。 参考：维基百科 由 Layyback 贡献 查询内容 编辑术语 贡献术语 深度学习库开发LSTM网络来解决时序预测问题。完成本节课之后，你了解如何实现和开发LSTM**网络来解决自己的时序问题以及其他的时序问题。
让我们开始吧。
1 LSTM网络用于回归
在上节中的国际航空乘客预测问题在这节课会重新思考一下，我们够将问题转述为回归问题，正如在上节课做的那样。换句话说，给定这个月乘客数量，得出下个月的乘客数量（单位为1000）。这个例子会复用上节课数据加载和数据预处理。特别是create_data() 函数。
LSTMs 神经网络对数据大小比较敏感，特别是使用 sigmoid（默认）和 tanh 激活函数。把数据规整在0-1之间，我们称之为正则化。我们能够通过来自 scikit-learn 库中的MinMaxScaler preprocessing来正则化数据。
# normalize the dataset
scaler = MinMaxScaler(feature_range=(0, 1))
dataset = scaler.fit_transform(dataset)
LSTM网络期望的输入数据**（X）** 是指定的某个格式：[samples,time steps,features]，我们预处理的数据形式为：[samples,features] ，对于每个样本我们将问题定义为时间步长。我们使用numpy.reshape() 可以把我们预处理的训练集和测试集转成我们期望的结构：
# reshape input to be [samples, time steps, features]
trainX = numpy.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
testX = numpy.reshape(testX, (testX.shape[0], 1, testX.shape[1]))
我们现在准备为整个问题设计并拟合我们的 LSTM 网络。这个网络拥有一个输入神经元的输入层，带有四个LSTM单元隐藏层以及预测一个输出值的输出层。在LSTM记忆单元中使用默认激活函数sigmoid，这个网络训练100次而且使用批处理大小为1。
# create and fit the LSTM network
model = Sequential()
model.add(LSTM(4, input_shape=(1, look_back)))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(trainX, trainY, epochs=100, batch_size=1, verbose=2)
为了完整性，下面是整个代码。
# LSTM for international airline passengers problem with regression framing
import math
import matplotlib.pyplot as plt
import numpy
from keras.layers import Dense
from keras.layers import LSTM
from keras.models import Sequential
from pandas import read_csv
from sklearn.metrics import mean_squared_error
from sklearn.preprocessing import MinMaxScaler
# convert an array of values into a dataset matrix
def create_dataset(dataset, look_back=1):
dataX, dataY = [], []
for i in range(len(dataset) - look_back - 1):
a = dataset[i:(i + look_back), 0]
dataX.append(a)
dataY.append(dataset[i + look_back, 0])
return numpy.array(dataX), numpy.array(dataY)
# fix random seed for reproducibility
numpy.random.seed(7)
# load the dataset
dataframe = read_csv('international-airline-passengers.csv', usecols=[1], engine='python',
skipfooter=3)
dataset = dataframe.values
dataset = dataset.astype('float32')
# normalize the dataset
scaler = MinMaxScaler(feature_range=(0, 1))
dataset = scaler.fit_transform(dataset)
# split into train and test sets
train_size = int(len(dataset) * 0.67)
test_size = len(dataset) - train_size
train, test = dataset[0:train_size, :], dataset[train_size:len(dataset), :]
# reshape into X=t and Y=t+1
look_back = 1
trainX, trainY = create_dataset(train, look_back)
testX, testY = create_dataset(test, look_back)
# reshape input to be [samples, time steps, features]
trainX = numpy.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
testX = numpy.reshape(testX, (testX.shape[0], 1, testX.shape[1]))
# create and fit the LSTM network
model = Sequential()
model.add(LSTM(4, input_shape=(1, look_back)))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(trainX, trainY, epochs=100, batch_size=1, verbose=2)
# make predictions
trainPredict = model.predict(trainX)
testPredict = model.predict(testX)
# invert predictions
trainPredict = scaler.inverse_transform(trainPredict)
trainY = scaler.inverse_transform([trainY])
testPredict = scaler.inverse_transform(testPredict)
testY = scaler.inverse_transform([testY])
# calculate root mean squared error
trainScore = math.sqrt(mean_squared_error(trainY[0], trainPredict[:, 0]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[0], testPredict[:, 0]))
print('Test Score: %.2f RMSE' % (testScore))
# shift train predictions for plotting
trainPredictPlot = numpy.empty_like(dataset)
trainPredictPlot[:, :] = numpy.nan
trainPredictPlot[look_back:len(trainPredict) + look_back, :] = trainPredict
# shift test predictions for plotting
testPredictPlot = numpy.empty_like(dataset)
testPredictPlot[:, :] = numpy.nan
testPredictPlot[len(trainPredict) + (look_back * 2) + 1:len(dataset) - 1, :] = testPredict
# plot baseline and predictions
plt.plot(scaler.inverse_transform(dataset))
plt.plot(trainPredictPlot)
plt.plot(testPredictPlot)
plt.show()
运行这个模型，得到如下的结果：
Epoch 96/100
- 0s - loss: 0.0020
Epoch 97/100
- 0s - loss: 0.0019
Epoch 98/100
- 0s - loss: 0.0019
Epoch 99/100
- 0s - loss: 0.0019
Epoch 100/100
- 0s - loss: 0.0019
Train Score: 22.34 RMSE
Test Score: 45.89 RMSE
我们能够看到，模型在训练集和测试集上的拟合的结果是不错的。
我们能够看到，模型在训练集得到23个乘客的误差（单位1000），在测试集上得到52个误差，也不算差。
2 使用窗口（Window）方法的LSTM回归
我们也能重述这个问题以至于多个时间步能够对下一时间预测，称之为窗口，其大小是根据问题而设置的。例如，给定当前时间**（t）** ，我们想在序列中预测下个时间**（t+1）** 的值，我们能够使用当前时间（t）和前两个时间（t-1和t-2） 作为输入变量。当问题转述为回归问题时，其输入变量为t-2，t-1，t和输出变量t+1。
上节课创建的 create_dataset() 函数，允许我们将 look_back 参数从1增加为3来创建时序问题格式。数据集的样例格式如下：
X1 X2 X3 Y
112 118 132 129
118 132 129 121
132 129 121 135
129 121 135 148
121 135 148 148
我们重新运行了上节课大窗口的例子，为了完整性，我们将大尺寸窗口的整个代码放在下面：
# LSTM for international airline passengers problem with window regression framing
import math
import matplotlib.pyplot as plt
import numpy
from keras.layers import Dense
from keras.layers import LSTM
from keras.models import Sequential
from pandas import read_csv
from sklearn.metrics import mean_squared_error
from sklearn.preprocessing import MinMaxScaler
# convert an array of values into a dataset matrix
def create_dataset(dataset, look_back=1):
dataX, dataY = [], []
for i in range(len(dataset) - look_back - 1):
a = dataset[i:(i + look_back), 0]
dataX.append(a)
dataY.append(dataset[i + look_back, 0])
return numpy.array(dataX), numpy.array(dataY)
# fix random seed for reproducibility
numpy.random.seed(7)
# load the dataset
dataframe = read_csv('international-airline-passengers.csv', usecols=[1], engine='python',
skipfooter=3)
dataset = dataframe.values
dataset = dataset.astype('float32')
# normalize the dataset
scaler = MinMaxScaler(feature_range=(0, 1))
dataset = scaler.fit_transform(dataset)
# split into train and test sets
train_size = int(len(dataset) * 0.67)
test_size = len(dataset) - train_size
train, test = dataset[0:train_size, :], dataset[train_size:len(dataset), :]
# reshape into X=t and Y=t+1
look_back = 3
trainX, trainY = create_dataset(train, look_back)
testX, testY = create_dataset(test, look_back)
# reshape input to be [samples, time steps, features]
trainX = numpy.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
testX = numpy.reshape(testX, (testX.shape[0], 1, testX.shape[1]))
# create and fit the LSTM network
model = Sequential()
model.add(LSTM(4, input_shape=(1, look_back)))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(trainX, trainY, epochs=100, batch_size=1, verbose=2)
# make predictions
trainPredict = model.predict(trainX)
testPredict = model.predict(testX)
# invert predictions
trainPredict = scaler.inverse_transform(trainPredict)
trainY = scaler.inverse_transform([trainY])
testPredict = scaler.inverse_transform(testPredict)
testY = scaler.inverse_transform([testY])
# calculate root mean squared error
trainScore = math.sqrt(mean_squared_error(trainY[0], trainPredict[:, 0]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[0], testPredict[:, 0]))
print('Test Score: %.2f RMSE' % (testScore))
# shift train predictions for plotting
trainPredictPlot = numpy.empty_like(dataset)
trainPredictPlot[:, :] = numpy.nan
trainPredictPlot[look_back:len(trainPredict) + look_back, :] = trainPredict
# shift test predictions for plotting
testPredictPlot = numpy.empty_like(dataset)
testPredictPlot[:, :] = numpy.nan
testPredictPlot[len(trainPredict) + (look_back * 2) + 1:len(dataset) - 1, :] = testPredict
# plot baseline and predictions
plt.plot(scaler.inverse_transform(dataset))
plt.plot(trainPredictPlot)
plt.plot(testPredictPlot)
plt.show()
运行上面例子得到下面的输出结果。
...
Epoch 95/100 0s - loss: 0.0021
Epoch 96/100 0s - loss: 0.0021
Epoch 97/100 0s - loss: 0.0021
Epoch 98/100 0s - loss: 0.0021
Epoch 99/100 0s - loss: 0.0022
Epoch 100/100 0s - loss: 0.0020
Train Score: 24.19 RMSE
Test Score: 58.03 RMSE
我们能够看到和上节课中的相比错误略有增加。窗口的大小和网络接口并没有调节，只是展示如何解决预测问题。
3 LSTM For Regression with Time Steps
你可能已经注意到，对于LSTM网络的数据预处理包括时间步长。有一些时序问题可能有不同的时间步长。例如，你已经有了导致失败点和点聚集的物理机器测量数据。每个事故是个样本，那么出现事故的观察值作为时间步，被观察的变量为特征。时间步长提供另外一种陈述时序问题的方法。像上面窗口的例子，我们把序列中的前时间步作为输入值来预测下个时间的输出值。
相反，我们把过去的观察值作为单独输出特征，这样的话，我们就能把一个输出特征作为一个时间步长，这样的确是一个更为准确问题架构。我们也能够在前面基于窗口的例子中使用同样的数据表示来这么做，除非当我们重整数据，那么我们设置这个列为时间步长维度，并且改变特征维度为1.例如：
# reshape input to be [samples, time steps, features]
trainX = numpy.reshape(trainX, (trainX.shape[0], trainX.shape[1], 1))
testX = numpy.reshape(testX, (testX.shape[0], testX.shape[1], 1))
为了完整性，下面列出了整个代码。
# LSTM for international airline passengers problem with time step regression framing
import math
import matplotlib.pyplot as plt
import numpy
from keras.layers import Dense
from keras.layers import LSTM
from keras.models import Sequential
from pandas import read_csv
from sklearn.metrics import mean_squared_error
from sklearn.preprocessing import MinMaxScaler
# convert an array of values into a dataset matrix
def create_dataset(dataset, look_back=1):
dataX, dataY = [], []
for i in range(len(dataset) - look_back - 1):
a = dataset[i:(i + look_back), 0]
dataX.append(a)
dataY.append(dataset[i + look_back, 0])
return numpy.array(dataX), numpy.array(dataY)
# fix random seed for reproducibility
numpy.random.seed(7)
# load the dataset
dataframe = read_csv('international-airline-passengers.csv', usecols=[1], engine='python',
skipfooter=3)
dataset = dataframe.values
dataset = dataset.astype('float32')
# normalize the dataset
scaler = MinMaxScaler(feature_range=(0, 1))
dataset = scaler.fit_transform(dataset)
# split into train and test sets
train_size = int(len(dataset) * 0.67)
test_size = len(dataset) - train_size
train, test = dataset[0:train_size, :], dataset[train_size:len(dataset), :]
# reshape into X=t and Y=t+1
look_back = 3
trainX, trainY = create_dataset(train, look_back)
testX, testY = create_dataset(test, look_back)
# reshape input to be [samples, time steps, features]
trainX = numpy.reshape(trainX, (trainX.shape[0], trainX.shape[1], 1))
testX = numpy.reshape(testX, (testX.shape[0], testX.shape[1], 1))
# create and fit the LSTM network
model = Sequential()
model.add(LSTM(4, input_shape=(look_back, 1)))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(trainX, trainY, epochs=100, batch_size=1, verbose=2)
# make predictions
trainPredict = model.predict(trainX)
testPredict = model.predict(testX)
# invert predictions
trainPredict = scaler.inverse_transform(trainPredict)
trainY = scaler.inverse_transform([trainY])
testPredict = scaler.inverse_transform(testPredict)
testY = scaler.inverse_transform([testY])
# calculate root mean squared error
trainScore = math.sqrt(mean_squared_error(trainY[0], trainPredict[:, 0]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[0], testPredict[:, 0]))
print('Test Score: %.2f RMSE' % (testScore))
# shift train predictions for plotting
trainPredictPlot = numpy.empty_like(dataset)
trainPredictPlot[:, :] = numpy.nan
trainPredictPlot[look_back:len(trainPredict) + look_back, :] = trainPredict
# shift test predictions for plotting
testPredictPlot = numpy.empty_like(dataset)
testPredictPlot[:, :] = numpy.nan
testPredictPlot[len(trainPredict) + (look_back * 2) + 1:len(dataset) - 1, :] = testPredict
# plot baseline and predictions
plt.plot(scaler.inverse_transform(dataset))
plt.plot(trainPredictPlot)
plt.plot(testPredictPlot)
plt.show()
运行上面的代码，得到下面的结果：
...
Epoch 95/100 1s - loss: 0.0021
Epoch 96/100 1s - loss: 0.0021
Epoch 97/100 1s - loss: 0.0021
Epoch 98/100 1s - loss: 0.0020
Epoch 99/100 1s - loss: 0.0021
Epoch 100/100 1s - loss: 0.0020
Train Score: 23.69 RMSE
Test Score: 58.88 RMSE
我们能够看到结果要比上个例子稍微好点，是输入数据的结构起了作用。
4 LSTM With Memory Between Batches.
LSTM 网络具有记忆功能，它能够记住整个长的序列。正常来说，拟合模型时，每次批处理训练后，网络内的状态会重置，每次也会调用model.predict() 或者 model.evaluate()。当我LSTM网络在Keras中被清除时，我们能够让LSTM层有状态来获得更加精准的控制。这就意味着他能够随着整个训练序列构来建状态，而且还能在我们需要的做预测时维持那个状态。
这需要当我们拟合网络时训练集不能打乱，它也需要每次暴露训练集后通过调model.reset_states() 函数显性重置网络状态。这就意味着在调 model.fit() 和 model.reset_states() 必须创建自己的外迭代循环。举个例子：
for i in range(100):
model.fit(trainX, trainY, epochs=1, batch_size=batch_size, verbose=2, shuffle=False)
model.reset_states()
最后，当LSTM 层构建好，stateful参数必须设置为True，不用指定输入维度，我们通过batch_input_shape参数传入批处理样本数量，样本的时间步数量和时间步中的特征数量。举个例子：
model.add(LSTM(4, batch_input_shape=(batch_size, time_steps, features), stateful=True))
当我们评估模型和做预测时，必须使用同样的批处理大小。例如：
model.predict(trainX, batch_size=batch_size)
先前的时间步长的例子适用于有状态的LSTM，下面提供按了完整的代码。
# LSTM for international airline passengers problem with memory
import math
import matplotlib.pyplot as plt
import numpy
from keras.layers import Dense
from keras.layers import LSTM
from keras.models import Sequential
from pandas import read_csv
from sklearn.metrics import mean_squared_error
from sklearn.preprocessing import MinMaxScaler
# convert an array of values into a dataset matrix
def create_dataset(dataset, look_back=1):
dataX, dataY = [], []
for i in range(len(dataset) - look_back - 1):
a = dataset[i:(i + look_back), 0]
dataX.append(a)
dataY.append(dataset[i + look_back, 0])
return numpy.array(dataX), numpy.array(dataY)
# fix random seed for reproducibility
numpy.random.seed(7)
# load the dataset
dataframe = read_csv('international-airline-passengers.csv', usecols=[1], engine='python',
skipfooter=3)
dataset = dataframe.values
dataset = dataset.astype('float32')
# normalize the dataset
scaler = MinMaxScaler(feature_range=(0, 1))
dataset = scaler.fit_transform(dataset)
# split into train and test sets
train_size = int(len(dataset) * 0.67)
test_size = len(dataset) - train_size
train, test = dataset[0:train_size, :], dataset[train_size:len(dataset), :]
# reshape into X=t and Y=t+1
look_back = 3
trainX, trainY = create_dataset(train, look_back)
testX, testY = create_dataset(test, look_back)
# reshape input to be [samples, time steps, features]
trainX = numpy.reshape(trainX, (trainX.shape[0], trainX.shape[1], 1))
testX = numpy.reshape(testX, (testX.shape[0], testX.shape[1], 1))
# create and fit the LSTM network
batch_size = 1
model = Sequential()
model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
for i in range(100):
model.fit(trainX, trainY, epochs=1, batch_size=batch_size, verbose=2, shuffle=False)
model.reset_states()
# make predictions
trainPredict = model.predict(trainX, batch_size=batch_size)
model.reset_states()
testPredict = model.predict(testX, batch_size=batch_size)
# invert predictions
trainPredict = scaler.inverse_transform(trainPredict)
trainY = scaler.inverse_transform([trainY])
testPredict = scaler.inverse_transform(testPredict)
testY = scaler.inverse_transform([testY])
# calculate root mean squared error
trainScore = math.sqrt(mean_squared_error(trainY[0], trainPredict[:, 0]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[0], testPredict[:, 0]))
print('Test Score: %.2f RMSE' % (testScore))
# shift train predictions for plotting
trainPredictPlot = numpy.empty_like(dataset)
trainPredictPlot[:, :] = numpy.nan
trainPredictPlot[look_back:len(trainPredict) + look_back, :] = trainPredict
# shift test predictions for plotting
testPredictPlot = numpy.empty_like(dataset)
testPredictPlot[:, :] = numpy.nan
testPredictPlot[len(trainPredict) + (look_back * 2) + 1:len(dataset) - 1, :] = testPredict
# plot baseline and predictions
plt.plot(scaler.inverse_transform(dataset))
plt.plot(trainPredictPlot)
plt.plot(testPredictPlot)
plt.show()
运行上面代码，得到如下结果：
...
Epoch 1/1 1s - loss: 0.0017
Epoch 1/1 1s - loss: 0.0017
Epoch 1/1 1s - loss: 0.0017
Epoch 1/1 1s - loss: 0.0017
Epoch 1/1 1s - loss: 0.0017
Epoch 1/1 1s - loss: 0.0016
Train Score: 20.74 RMSE
Test Score: 52.23 RMSE
我们能够看出，结果比有些好，比其他的有点差，模型需要更多的模块，可能还需要更多迭代周期来内化一些结构的问题。
5 Stacked LSTMs With Memory Between Batches
最后，我们将要看看大型LSTM的优点之一，当他嵌入深度网络结构中时，它们能够成功的训练。LSTM网络在Keras中用同样的方法嵌入进去，其他类型的层也能嵌入进去。另外一个必要的配置是在LSTM层之前的LSTM层必须返回这个序列，可以在层中设置return_sequences参数为True。在上个部分，我们扩展了有状态的LSTM，它有两层，如下：
model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True, return_sequences=True))
model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True))
为了完整性，整个代码在下面给出来了。
# Stacked LSTM for international airline passengers problem with memory
import math
import matplotlib.pyplot as plt
import numpy
from keras.layers import Dense
from keras.layers import LSTM
from keras.models import Sequential
from pandas import read_csv
from sklearn.metrics import mean_squared_error
from sklearn.preprocessing import MinMaxScaler
# convert an array of values into a dataset matrix
def create_dataset(dataset, look_back=1):
dataX, dataY = [], []
for i in range(len(dataset) - look_back - 1):
a = dataset[i:(i + look_back), 0]
dataX.append(a)
dataY.append(dataset[i + look_back, 0])
return numpy.array(dataX), numpy.array(dataY)
# fix random seed for reproducibility
numpy.random.seed(7)
# load the dataset
dataframe = read_csv('international-airline-passengers.csv', usecols=[1], engine='python',
skipfooter=3)
dataset = dataframe.values
dataset = dataset.astype('float32')
# normalize the dataset
scaler = MinMaxScaler(feature_range=(0, 1))
dataset = scaler.fit_transform(dataset)
# split into train and test sets
train_size = int(len(dataset) * 0.67)
test_size = len(dataset) - train_size
train, test = dataset[0:train_size, :], dataset[train_size:len(dataset), :]
# reshape into X=t and Y=t+1
look_back = 3
trainX, trainY = create_dataset(train, look_back)
testX, testY = create_dataset(test, look_back)
# reshape input to be [samples, time steps, features]
trainX = numpy.reshape(trainX, (trainX.shape[0], trainX.shape[1], 1))
testX = numpy.reshape(testX, (testX.shape[0], testX.shape[1], 1))
# create and fit the LSTM network
batch_size = 1
model = Sequential()
model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True,
return_sequences=True))
model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
for i in range(100):
model.fit(trainX, trainY, epochs=1, batch_size=batch_size, verbose=2, shuffle=False)
model.reset_states()
# make predictions
trainPredict = model.predict(trainX, batch_size=batch_size)
model.reset_states()
testPredict = model.predict(testX, batch_size=batch_size)
# invert predictions
trainPredict = scaler.inverse_transform(trainPredict)
trainY = scaler.inverse_transform([trainY])
testPredict = scaler.inverse_transform(testPredict)
testY = scaler.inverse_transform([testY])
# calculate root mean squared error
trainScore = math.sqrt(mean_squared_error(trainY[0], trainPredict[:, 0]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[0], testPredict[:, 0]))
print('Test Score: %.2f RMSE' % (testScore))
# shift train predictions for plotting
trainPredictPlot = numpy.empty_like(dataset)
trainPredictPlot[:, :] = numpy.nan
trainPredictPlot[look_back:len(trainPredict) + look_back, :] = trainPredict
# shift test predictions for plotting
testPredictPlot = numpy.empty_like(dataset)
testPredictPlot[:, :] = numpy.nan
testPredictPlot[len(trainPredict) + (look_back * 2) + 1:len(dataset) - 1, :] = testPredict
# plot baseline and predictions
plt.plot(scaler.inverse_transform(dataset))
plt.plot(trainPredictPlot)
plt.plot(testPredictPlot)
plt.show()
运行上面代码，得到如下结果：
...
Epoch 1/1 1s - loss: 0.0017
Epoch 1/1 1s - loss: 0.0017
Epoch 1/1 1s - loss: 0.0017
Epoch 1/1 1s - loss: 0.0017
Epoch 1/1 1s - loss: 0.0016
Train Score: 20.49 RMSE
Test Score: 56.35 RMSE
在数据集上的预测再一次变糟。再一次证据表明我们需要额外的训练周期。
总结
在这节课中，你已经学习了如何开发LSTM递归神经网络解决时序问题。特别是，你已经学到了：关于国际航空乘客的时序预测问题。
- 如何为回归问题和时序问题的窗口格式创建一个LSTM。
- 如何用时序问题的时间步形式创建LSTM。
- 如何用状态和嵌入带有状态的LSTM单元创建LSTM网络学习长时序。
下一步
在这节课中，你已经学习了如何使用LSTM递归神经网络解决时序预测问题，接下来，你将用发现LSTM网络的新技能，解决时序分类问题。
3万+
