# 深度学习入门系列20：LSTM递归神经网络解决国际航空乘客预测问题

技术人Howzit 2021-11-17 11:02:54 380 收藏
分类专栏： 深度学习入门 文章标签： 深度学习 神经网络 lstm 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c_he_n/article/details/121373283
版权
深度学习入门 专栏收录该内容
20 篇文章 3 订阅
订阅专栏

通过本文你将了解：

- 如何开发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网络的新技能，解决时序分类问题。

技术人Howzit
关注 关注

- 1
  点赞
- 踩
- 0
  评论
- 0
  收藏
- 一键三连

- 扫一扫，分享海报

专栏目录
StockPredictionRNN, 基于LSTM 递归神经网络的高频交易价格预测.zip
09-18
StockPredictionRNN, 基于LSTM 递归神经网络的高频交易价格预测 StockPredictionRNN基于LSTM 递归神经网络的高频交易价格预测我们尝试利用长期记忆的递归神经网络来预测高频股票价格的价格。 这个程序实现了从 for ...
深度学习100例-循环神经网络（LSTM）实现股票预测 | 第10天
K同学啊
10-24 3万+
文章目录一、前言二、LSTM的是什么三、准备工作1.设置GPU2.设置相关参数3.加载数据四、数据预处理1.归一化2.时间戳函数五、构建模型六、激活模型七、训练模型八、结果可视化1.绘制loss图2.预测3.评估 一、前言 今天是第10天，我们将使用LSTM完成股票开盘价格的预测，最后的R2可达到0.74，相对传统的RNN的0.72提高了两个百分点。 我的环境： 语言环境：Python3.6.5 编译器：jupyter notebook 深度学习环境：TensorFlow2.4.1 来自专栏：【深度学习
插入表情
添加代码片
还能输入1000个字符
MV-LSTM:用于预测和解释多变量时间序列的多变量LSTM 递归神经网络-源码
05-24
多变量LSTM当前神经网络用于多变量时间序列的预测和解释 郭，田，陶林和Nino Antulov-Fantulin。 “在多变量数据上探索可解释的LSTM 神经网络。” 国际机器学习会议（ICML）。 2019。 郭涛，林涛，卢Y.自回归外生...
基于LSTM算法的航空发动机寿命预测
03-10
对于航空发动机寿命预测问题，它的难点在于特征数数多，而且特征也是传感器所收集到的数据，传感器一般带有噪声，会造成拟合过程中的不准确性，设计一个多变量输入，单变量输出的预测模型，而RNN（循环神经网络）是...

45 岁程序员求助：技术体系全精通，却连个面试通知都收不到…
最新发布
Java白叔的博客
11-18 45
最近，在网上看到这样一个留言，引发了程序员这个圈子不少的轰动。“我是一名软件开发人员，今年 45 岁，精通各种技术体系……而我辞职回家半年后再回来寻找工作机会的时候，却发现连个面试机会都很难得到。”具体提问，截图如下：当一个 45 岁的中年男人，需要被生活逼到何种境地，才能鼓起勇气公开在网上求助说出自己的无奈。这一刻，中年程序员的不易，体现的淋漓尽致曾经，铁饭碗是专门形容形容那些工作稳定、收入无忧的岗位，然而，在时代的浪潮下，所谓的铁饭碗也在逐一被打破，而这位 45 岁的大哥，就是一
基于LSTM 递归神经网络的番茄目标产量时间序列预测.pdf
09-26
基于LSTM 递归神经网络的番茄目标产量时间序列预测.pdf
股票价格预测器：建立LSTM 递归神经网络来预测股票市场价格-源码
02-04
股票价格预测器：建立LSTM 递归神经网络来预测股票市场价格
基于LSTM时间递归神经网络的短期电力负荷预测.pdf
09-25
基于LSTM时间递归神经网络的短期电力负荷预测.pdf
深度学习：人工智能长期短期记忆（LSTM）卷积神经网络（CNN）递归神经网络（RNN）Resnet50残留网络-源码
02-26
深度学习 该文件夹包含我的各种AI和机器学习项目的深度学习模型。 长短期记忆（LSTM）卷积神经网络（CNN）ResNet50
pred-rnn：PredRNN：使用时空LSTM进行预测性学习的递归神经网络-源码
02-03
PredRNN 包含PyTorch的纸张实现- PredRNN：使用时空LSTM进行预测性学习的递归神经网络 数据集 移动MNIST数据集可在下载 建筑
LSTM进阶：使用LSTM进行多维多步的时间序列预测
小EZ的博客
05-17 5万+
各位朋友大家好，今天来讲一下LSTM时间序列的预测进阶。 现在我总结一下常用的LSTM时间序列预测： 1.单维单步（使用前两步预测后一步） 可以看到trainX的shape为 (5,2) trainY为(5,1) 在进行训练的过程中要将trainX reshape为 (5,2,1)(LSTM的输入为 [samples, timesteps, features] 这里的timesteps为...
简单粗暴LSTM：LSTM进行时间序列预测
热门推荐
小EZ的博客
12-14 10万+
使用LSTM进行时间序列预测 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界...
拓端tecdat|使用Python中Keras的LSTM 递归神经网络进行时间序列预测
大数据部落
01-21 1112
时间序列预测问题是预测建模问题中的一种困难类型。 与回归预测建模不同，时间序列还增加了输入变量之间序列依赖的复杂性。
基于LSTM的股票预测模型_python实现_超详细
zxm_的博客
07-05 6万+
文章目录一、背景二、主要技术介绍1、RNN模型2、LSTM模型3、控制门工作原理四、代码实现五、案例分析六、参数设置七、结论 一、背景 近年来，股票预测还处于一个很热门的阶段，因为股票市场的波动十分巨大，随时可能因为一些新的政策或者其他原因，进行大幅度的波动，导致自然人股民很难对股票进行投资盈利。因此本文想利用现有的模型与算法，对股票价格进行预测，从而使自然人股民可以自己对股票进行预测。 理论上，...
深度学习-42:深度递归神经网络(Recursive NN,RNN)
智能多媒体
10-14 1万+
深度学习-42:深度递归神经网络(Recursive NN,RNN) 深度学习原理与实践(开源图书)-总目录 递归神经网络(Recursive NN,RNN)通过带有树状相似的神经网络结构来递归复杂的深度网络。本质上，递归神经网络是对循环神经网络(Recurrent Neural Network)的一个有效扩展，他们具有不同的计算图。 递归神经网络(Recursive NN)和循环神经网络(R...
神经网络 LSTM 时间预测
08-03
详细的LSTM代码， 附带数据。 RNN全称循环神经网络（Recurrent Neural Networks），是用来处理序列数据的。在传统的神经网络模型中，从输入层到隐含层...但是这种普通的神经网络对于很多关于时间序列的问题却无能无力。
BugAI：基于AI的错误预测的深度学习模型（长期短期记忆（LSTM），递归神经网络（RNN），卷积神经网络（CNN））-源码
02-23
布加 深度学习模型（长期短期记忆（LSTM），递归神经网络（RNN），卷积神经网络（CNN））用于基于AI的错误预测。此外，还使用了其他机器学习模型，例如SVM，oneClassClassifier，isolationForest。
递归神经网络预测Google股票价格：我尝试使用LSTM 预测Google股票价格-源码
02-03
递归神经网络预测Google股票价格 我试图使用LSTM 预测Google股票价格 长短期记忆（LSTM）单元（或块）是递归神经网络（RNN）层的构建单元。 由LSTM单元组成的RNN通常称为LSTM 网络。 常见的LSTM单元由单元，输入门，...
【深度学习论文翻译】基于LSTM 深度神经网络的时间序列预测（Time Series Prediction Using LSTM Deep Neural Networks）
水亦心的博客
04-03 7339
目录 一、前言 二、摘要 三、什么是LSTM 神经元？ 四、简单正弦波示例 五、 不那么简单的股票市场 六、多维LSTM 预测 七、结论 一、前言 最近需要用到时间序列，在网上也找到了一篇相关的文章及源代码，在此分享给大家。 1.文章原文：https://www.altumintelligence.com/articles/a/Time-Series-Prediction-Usin...
深度学习-43:长短时记忆神经网络(LSTM)
智能多媒体
10-14 2万+
深度学习-43:长短时记忆神经网络(LSTM) 深度学习原理与实践(开源图书)-总目录 长短时记忆神经网络(Long Short-term Memory Networks,LSTM)是一种 RNN 特殊的类型，可以学习长期依赖信息。LSTM 由 Hochreiter &amp;amp;amp;amp;amp; Schmidhuber (1997) 提出，并在近期被 Alex Graves 进行了改良和推广。STM 通过刻意的...
深度学习笔记2：关于LSTM 神经网络输入输出的理解
陆撄宁的博客
04-02 7475
我们在理解RNN或者LSTM的时候，对它们的输入和输出的维度都很迷惑，下面是我结合代码和网上的一些资料进行理解 正常的全连接层网络拓扑是这样的： 有输入层、隐层和输出层，隐层中有神经元，图中每个参数都跟全部的神经元有链接。 接下来看下LSTM的拓扑图： ...
©️2021 CSDN 皮肤主题: 创作都市 设计师:CSDN官方博客 返回首页
技术人Howzit CSDN认证博客专家 CSDN认证企业博客

76
  原创

1万+
  周排名

1万+
  总排名

5万+
  访问

  等级

1335
  积分

28
  粉丝

38
  获赞

70
  评论

129
  收藏

私信
关注

### 热门文章

- Android基础知识之菜鸟也能抓日志-adb抓取anr和普通日志 4958
- Fragment中不执行onActivityResult(); 4540
- WoMic虚拟麦克风技术剖析 3186
- Android 基础知识之 VelocityTracker使用（提供手指速度计算，可用于笔迹优化哦） 3109
- 白话算法-递归算法以及斐波那契数列递归优化算法 2993

### 分类专栏

- 深度学习入门 20篇
- 工具 2篇
- 鸿蒙
- TensorFlow Lite 2篇
- 思维 2篇
- 组件化 2篇
- MVVM 1篇
- 设计模式随笔 4篇
- 数据结构与算法 3篇
- Android 36篇
- 算法与数据结构 4篇
- 随笔记坑 1篇
- 设计模式 4篇
- python 2篇
- Mysql 1篇

### 最新评论

### 您愿意向朋友推荐“博客详情页”吗？

- 强烈不推荐
- 不推荐
- 一般般
- 推荐
- 强烈推荐

提交

### 最新文章

- 深度学习入门系列19：基于窗口（window）的多层感知器解决时序问题
- 深度学习必备三种基本绘图技能
- 分享一个用pad作为扩展屏软件，特别好用。

2021年 34篇
2020年 9篇
2019年 14篇
2018年 18篇
2015年 1篇

### 目录

### 分类专栏

- 深度学习入门 20篇
- 工具 2篇
- 鸿蒙
- TensorFlow Lite 2篇
- 思维 2篇
- 组件化 2篇
- MVVM 1篇
- 设计模式随笔 4篇
- 数据结构与算法 3篇
- Android 36篇
- 算法与数据结构 4篇
- 随笔记坑 1篇
- 设计模式 4篇
- python 2篇
- Mysql 1篇

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、C币套餐、付费专栏及课程。

余额充值