基于 Keras 的 Python 中 LSTM 循環神經網絡的時間序列預測 · Machine Learning Mastery 博客文章翻譯

# 基于 Keras 的 Python 中 LSTM 循環神經網絡的時間序列預測 > 原文： [https://machinelearningmastery.com/time-series-prediction-lstm-recurrent-neural-networks-python-keras/](https://machinelearningmastery.com/time-series-prediction-lstm-recurrent-neural-networks-python-keras/) 時間序列預測問題是一種難以預測的建模問題。與回歸預測建模不同，時間序列還增加了輸入變量之間序列依賴性的復雜性。設計用于處理序列依賴性的強大類型的神經網絡稱為[循環神經網絡](http://machinelearningmastery.com/crash-course-recurrent-neural-networks-deep-learning/)。長短期內存網絡或 LSTM 網絡是一種用于深度學習的循環神經網絡，因為可以成功訓練非常大的架構。在本文中，您將了解如何使用 Keras 深度學習庫在 Python 中開發 LSTM 網絡，以解決演示時間序列預測問題。完成本教程后，您將了解如何為您自己的時間序列預測問題和其他更常見的序列問題實現和開發 LSTM 網絡。你會知道： * 關于國際航空公司乘客時間序列預測問題。 * 如何開發 LSTM 網絡用于基于回歸，窗口和時間步長的時間序列預測問題的框架。 * 如何使用 LSTM 網絡開發和預測，這些網絡在很長的序列中維護狀態（內存）。在本教程中，我們將針對標準時間序列預測問題開發許多 LSTM。 LSTM 網絡的問題和所選配置僅用于演示目的，僅用于優化。這些示例將向您展示如何為時間序列預測建模問題開發自己的不同結構的 LSTM 網絡。讓我們開始吧。 * **2016 年 10 月更新**：在每個示例中計算 RMSE 的方式出錯。報告的 RMSE 是完全錯誤的。現在，RMSE 直接根據預測計算，RMSE 和預測圖都以原始數據集為單位。使用 Keras 1.1.0，TensorFlow 0.10.0 和 scikit-learn v0.18 評估模型。感謝所有指出這個問題的人，以及 Philip O'Brien 幫助指出修復的問題。 * **2017 年 3 月更新**：更新了 Keras 2.0.2，TensorFlow 1.0.1 和 Theano 0.9.0 的示例。 * **2017 年 4 月更新**：有關時間序列預測的更完整和更好解釋的 LSTM 教程，請參閱 Python 中的長期短期記憶網絡[時間序列預測。](http://machinelearningmastery.com/time-series-forecasting-long-short-term-memory-network-python/) ### 更新了 LSTM 時間序列預測帖子：這篇文章中的例子非常陳舊，我有更好的例子可用于在時間序列中使用 LSTM，請參閱： 1. [用于單變量時間序列預測的 LSTM](https://machinelearningmastery.com/time-series-forecasting-long-short-term-memory-network-python/) 2. [多變量時間序列預測的 LSTM](https://machinelearningmastery.com/multivariate-time-series-forecasting-lstms-keras/) 3. [用于多步時間序列預測的 LSTM](https://machinelearningmastery.com/multi-step-time-series-forecasting-long-short-term-memory-networks-python/) ![Time Series Prediction with LSTM Recurrent Neural Networks in Python with Keras](https://img.kancloud.cn/4e/7e/4e7ef2a818c4823b9e57816d10573413_640x427.jpg) 時間序列預測與 LSTM 循環神經網絡在 Python 與 Keras 照片由 [Margaux-Marguerite Duquesnoy](https://www.flickr.com/photos/124559226@N08/15792381395/) ，保留一些權利。 ## 問題描述我們將在這篇文章中討論的問題是國際航空公司乘客預測問題。這是一個問題，在一年零一個月的情況下，任務是以 1,000 為單位預測國際航空公司乘客的數量。數據范圍從 1949 年 1 月到 1960 年 12 月，或 12 年，有 144 個觀測值。該數據集可從 [DataMarket 網頁免費下載，作為 CSV 下載](https://datamarket.com/data/set/22u3/international-airline-passengers-monthly-totals-in-thousands-jan-49-dec-60#!ds=22u3&display=line)，文件名為“ _international-airline-passengers.csv_ ”。下面是該文件前幾行的示例。 ```py "Month","International airline passengers: monthly totals in thousands. Jan 49 ? Dec 60" "1949-01",112 "1949-02",118 "1949-03",132 "1949-04",129 "1949-05",121 ``` 我們可以使用 Pandas 庫輕松加載此數據集。鑒于每個觀察以一個月的相同間隔分開，我們對日期不感興趣。因此，當我們加載數據集時，我們可以排除第一列。下載的數據集還有頁腳信息，我們可以將 **skipfooter** 參數排除到 **pandas.read_csv（）**為 3 頁腳行設置為 3。加載后，我們可以輕松繪制整個數據集。下面列出了加載和繪制數據集的代碼。 ```py import pandas import matplotlib.pyplot as plt dataset = pandas.read_csv('international-airline-passengers.csv', usecols=[1], engine='python', skipfooter=3) plt.plot(dataset) plt.show() ``` 隨著時間的推移，您可以看到數據集中的上升趨勢。您還可以看到數據集的某些周期性，可能與北半球度假期相對應。 ![Plot of the Airline Passengers Dataset](https://img.kancloud.cn/a6/ab/a6ab6b3ed20c8ccc87827a2b08d8769c_800x600.jpg) 航空公司乘客數據集的情節我們將保持簡單并按原樣處理數據。通常，研究各種數據準備技術以重新調整數據并使其靜止是一個好主意。 ## 長短期記憶網絡長期短期記憶網絡或 LSTM 網絡是一種循環神經網絡，使用反向傳播時間訓練并克服消失的梯度問題。因此，它可用于創建大型循環網絡，這些網絡又可用于解決機器學習中的困難序列問題并實現最先進的結果。 LSTM 網絡具有通過層連接的存儲塊，而不是神經元。塊具有使其比經典神經元更聰明的組件和用于最近序列的存儲器。塊包含管理塊狀態和輸出的門。塊對輸入序列進行操作，并且塊內的每個門使用 S 形激活單元來控制它們是否被觸發，使狀態的改變和流過塊的信息的添加成為條件。一個單元內有三種類型的門： * **忘記門**：有條件地決定從塊中丟棄的信息。 * **輸入門**：有條件地決定輸入中的哪些值來更新存儲器狀態。 * **輸出門**：根據輸入和塊的存儲器有條件地決定輸出內容。每個單元就像一個小型狀態機，其中單元的門具有在訓練過程中學習的權重。您可以看到如何通過一層 LSTM 實現復雜的學習和記憶，并且不難想象高階抽象如何與多個這樣的層分層。 ## LSTM 回歸網絡我們可以將問題表述為回歸問題。也就是說，考慮到本月乘客人數（以千人為單位），下個月的乘客人數是多少？我們可以編寫一個簡單的函數將我們的單列數據轉換為兩列數據集：第一列包含本月的（t）乘客數，第二列包含下個月的（t + 1）乘客數，可以預測。在我們開始之前，讓我們首先導入我們打算使用的所有函數和類。這假設一個工作的 SciPy 環境安裝了 Keras 深度學習庫。 ```py import numpy import matplotlib.pyplot as plt import pandas import math from keras.models import Sequential from keras.layers import Dense from keras.layers import LSTM from sklearn.preprocessing import MinMaxScaler from sklearn.metrics import mean_squared_error ``` 在我們做任何事情之前，最好修復隨機數種子以確保我們的結果可重復。 ```py # fix random seed for reproducibility numpy.random.seed(7) ``` 我們還可以使用上一節中的代碼將數據集作為 Pandas 數據幀加載。然后，我們可以從數據幀中提取 NumPy 數組，并將整數值轉換為浮點值，這些值更適合使用神經網絡進行建模。 ```py # load the dataset dataframe = pandas.read_csv('international-airline-passengers.csv', usecols=[1], engine='python', skipfooter=3) dataset = dataframe.values dataset = dataset.astype('float32') ``` LSTM 對輸入數據的比例敏感，特別是在使用 sigmoid（默認）或 tanh 激活函數時。將數據重新調整到 0 到 1 的范圍是一種很好的做法，也稱為標準化。我們可以使用 scikit-learn 庫中的 **MinMaxScaler** 預處理類輕松地規范化數據集。 ```py # normalize the dataset scaler = MinMaxScaler(feature_range=(0, 1)) dataset = scaler.fit_transform(dataset) ``` 在我們對數據建模并估計模型在訓練數據集上的技能之后，我們需要了解模型在新的看不見的數據上的技能。對于正常的分類或回歸問題，我們將使用交叉驗證來執行此操作。對于時間序列數據，值的序列很重要。我們可以使用的一種簡單方法是將有序數據集拆分為訓練和測試數據集。下面的代碼計算分裂點的索引，并將數據分成訓練數據集，其中 67％的觀測值可用于訓練我們的模型，剩余的 33％用于測試模型。 ```py # 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),:] print(len(train), len(test)) ``` 現在我們可以定義一個函數來創建一個新的數據集，如上所述。該函數有兩個參數：**數據集**，它是我們想要轉換為數據集的 NumPy 數組，以及 **look_back** ，它是之前使用的時間步數輸入變量來預測下一個時間段 - 在這種情況下默認為 1。此默認值將創建一個數據集，其中 X 是給定時間（t）的乘客數量，Y 是下次乘客的數量（t + 1）。它可以配置，我們將在下一節中構建一個不同形狀的數據集。 ```py # 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) ``` 讓我們看一下這個函數對數據集第一行的影響（為了清晰起見，以非標準化形式顯示）。 ```py X Y 112 118 118 132 132 129 129 121 121 135 ``` 如果將前 5 行與上一節中列出的原始數據集樣本進行比較，則可以在數字中看到 X = t 和 Y = t + 1 模式。讓我們使用這個函數來準備訓練和測試數據集以進行建模。 ```py # 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) ``` LSTM 網絡期望輸入數據（X）以以下形式提供特定的陣列結構： _[樣本，時間步長，特征]_ 。目前，我們的數據形式為：[_ 樣本，特征 _]，我們將問題定為每個樣本的一個時間步長。我們可以使用 **numpy.reshape（）**將準備好的訓練和測試輸入數據轉換為預期結構，如下所示： ```py # 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 網絡來解決這個問題。網絡具有帶有 1 個輸入的可見層，帶有 4 個 LSTM 塊或神經元的隱藏層，以及進行單個值預測的輸出層。默認的 sigmoid 激活函數用于 LSTM 塊。對網絡進行 100 個迭代的訓練，并使用 1 的批量大小。 ```py # 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) ``` 一旦模型擬合，我們就可以估計模型在訓練和測試數據集上的表現。這將為我們提供新模型的比較點。請注意，我們在計算錯誤分數之前反轉預測，以確保以與原始數據相同的單位報告表現（每月數千名乘客）。 ```py # 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)) ``` 最后，我們可以使用模型為訓練和測試數據集生成預測，以獲得模型技能的直觀指示。由于數據集的準備方式，我們必須改變預測，使它們在 x 軸上與原始數據集對齊。準備好后，繪制數據，以藍色顯示原始數據集，以綠色顯示訓練數據集的預測，以及以紅色顯示未見測試數據集的預測。 ```py # 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() ``` 我們可以看到該模型在擬合訓練和測試數據集方面做得非常出色。 ![LSTM Trained on Regression Formulation of Passenger Prediction Problem](https://img.kancloud.cn/d7/18/d718ec3ed28a8d3c773b2c3abb0352bb_800x600.jpg) LSTM 對乘客預測問題的回歸制定進行了訓練為了完整起見，下面是整個代碼示例。 ```py # LSTM for international airline passengers problem with regression framing import numpy import matplotlib.pyplot as plt from pandas import read_csv import math from keras.models import Sequential from keras.layers import Dense from keras.layers import LSTM from sklearn.preprocessing import MinMaxScaler from sklearn.metrics import mean_squared_error # 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() ``` 運行該示例將生成以下輸出。 ```py ... Epoch 95/100 0s - loss: 0.0020 Epoch 96/100 0s - loss: 0.0020 Epoch 97/100 0s - loss: 0.0020 Epoch 98/100 0s - loss: 0.0020 Epoch 99/100 0s - loss: 0.0020 Epoch 100/100 0s - loss: 0.0020 Train Score: 22.93 RMSE Test Score: 47.53 RMSE ``` 我們可以看到該模型在訓練數據集上的平均誤差約為 23 名乘客（以千計），在測試數據集上的平均誤差約為 52 名乘客（以千計）。沒那么糟。 ## 使用窗口方法進行回歸的 LSTM 我們還可以對問題進行短語，以便可以使用多個最近時間步驟來對下一個時間步進行預測。這稱為窗口，窗口的大小是可以針對每個問題進行調整的參數。例如，給定當前時間（t）我們想要預測序列中下一次的值（t + 1），我們可以使用當前時間（t），以及前兩次（t-1）和 t-2）作為輸入變量。當表達為回歸問題時，輸入變量為 t-2，t-1，t，輸出變量為 t + 1。我們在上一節中創建的 **create_dataset（）**函數允許我們通過將 **look_back** 參數從 1 增加到 3 來創建時間序列問題的這個公式。具有此秘籍的數據集樣本如下所示： ```py X1 X2 X3 Y 112 118 132 129 118 132 129 121 132 129 121 135 129 121 135 148 121 135 148 148 ``` 我們可以使用更大的窗口大小重新運行上一節中的示例。為了完整性，下面列出了僅包含窗口大小更改的整個代碼清單。 ```py # LSTM for international airline passengers problem with window regression framing import numpy import matplotlib.pyplot as plt from pandas import read_csv import math from keras.models import Sequential from keras.layers import Dense from keras.layers import LSTM from sklearn.preprocessing import MinMaxScaler from sklearn.metrics import mean_squared_error # 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() ``` 運行該示例提供以下輸出： ```py ... 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 ``` 我們可以看到，與上一節相比，誤差略有增加。窗口大小和網絡架構沒有調整：這只是如何構建預測問題的演示。 ![LSTM Trained on Window Method Formulation of Passenger Prediction Problem](https://img.kancloud.cn/c6/8c/c68cd30a7eb5a80a7203902a8afa9eaa_800x600.jpg) LSTM 訓練乘客預測問題的窗口方法 ## 帶時間步長的回歸 LSTM 您可能已經注意到 LSTM 網絡的數據準備包括時間步驟。一些序列問題可能每個樣本具有不同數量的時間步長。例如，您可能會測量導致故障點或喘振點的物理機器。每個事件都是一個樣本，導致事件的觀察將是時間步驟，觀察到的變量將是特征。時間步驟提供了另一種表達時間序列問題的方法。與上面的窗口示例一樣，我們可以將時間序列中的先前時間步長作為輸入來預測下一時間步的輸出。我們可以將它們用作一個輸入要素的時間步長，而不是將過去的觀察結果作為單獨的輸入要素，這確實是對問題的更準確的框架。我們可以使用與上一個基于窗口的示例相同的數據表示來執行此操作，除非我們對數據進行整形，我們將列設置為時間步長維并將要素維更改為 1.例如： ```py # 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)) ``` 下面提供了整個代碼清單，以確保完整性。 ```py # LSTM for international airline passengers problem with time step regression framing import numpy import matplotlib.pyplot as plt from pandas import read_csv import math from keras.models import Sequential from keras.layers import Dense from keras.layers import LSTM from sklearn.preprocessing import MinMaxScaler from sklearn.metrics import mean_squared_error # 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() ``` 運行該示例提供以下輸出： ```py ... 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 ``` 我們可以看到結果略好于前面的例子，盡管輸入數據的結構更有意義。 ![LSTM Trained on Time Step Formulation of Passenger Prediction Problem](https://img.kancloud.cn/68/dd/68dda581784ef35ff2c50949d67ca051_800x600.jpg) LSTM 訓練乘客預測問題的時間步長形式 ## LSTM 與批次之間的內存 LSTM 網絡具有內存，能夠記住長序列。通常，在擬合模型時，在每次訓練批次之后重置網絡內的狀態，以及每次調用 **model.predict（）**或 **model.evaluate（）**。通過使 LSTM 層“有狀態”，我們可以更好地控制何時在 Keras 中清除 LSTM 網絡的內部狀態。這意味著它可以在整個訓練序列中構建狀態，甚至在需要進行預測時保持該狀態。它要求在安裝網絡時不要改組訓練數據。它還要求通過調用 **model.reset_states（）**，在每次暴露于訓練數據（時期）后明確重置網絡狀態。這意味著我們必須在每個時代調用 **model.fit（）**和 **model.reset_states（）**內創建我們自己的時代外環。例如： ```py for i in range(100): model.fit(trainX, trainY, epochs=1, batch_size=batch_size, verbose=2, shuffle=False) model.reset_states() ``` 最后，當構造 LSTM 層時，**有狀態**參數必須設置為 **True** 而不是指定輸入維度，我們必須硬編碼批次中的樣本數量，通過設置 **batch_input_shape** 參數，樣本中的時間步長和時間步長中的要素數量。例如： ```py model.add(LSTM(4, batch_input_shape=(batch_size, time_steps, features), stateful=True)) ``` 然后，在評估模型和進行預測時，必須使用相同的批量大小。例如： ```py model.predict(trainX, batch_size=batch_size) ``` 我們可以調整前一個時間步驟示例以使用有狀態 LSTM。完整的代碼清單如下。 ```py # LSTM for international airline passengers problem with memory import numpy import matplotlib.pyplot as plt from pandas import read_csv import math from keras.models import Sequential from keras.layers import Dense from keras.layers import LSTM from sklearn.preprocessing import MinMaxScaler from sklearn.metrics import mean_squared_error # 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() ``` 運行該示例提供以下輸出： ```py ... 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 ``` 我們確實看到結果更糟。該模型可能需要更多模塊，并且可能需要針對更多時期進行訓練以內化問題的結構。 ![Stateful LSTM Trained on Regression Formulation of Passenger Prediction Problem](https://img.kancloud.cn/f5/27/f5273399634eeda9b973ceea09879217_800x600.jpg) 有狀態 LSTM 訓練乘客預測問題的回歸形式 ## 堆疊 LSTM 與批次之間的內存最后，我們將了解 LSTM 的一大優勢：它們可以在堆疊到深層網絡架構中時成功進行訓練。 LSTM 網絡可以像其他層類型堆疊一樣堆疊在 Keras 中。對配置的一個補充是每個后續 LSTM 層之前的 LSTM 層必須返回序列。這可以通過將層上的 **return_sequences** 參數設置為 **True** 來完成。我們可以在上一節中擴展有狀態 LSTM，使其具有兩層，如下所示： ```py 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)) ``` 下面提供了整個代碼清單，以確保完整性。 ```py # Stacked LSTM for international airline passengers problem with memory import numpy import matplotlib.pyplot as plt from pandas import read_csv import math from keras.models import Sequential from keras.layers import Dense from keras.layers import LSTM from sklearn.preprocessing import MinMaxScaler from sklearn.metrics import mean_squared_error # 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() ``` 運行該示例將生成以下輸出。 ```py ... 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 ``` 對測試數據集的預測再次惡化。這是更多證據表明需要額外的訓練時期。 ![Stacked Stateful LSTMs Trained on Regression Formulation of Passenger Prediction Problem](https://img.kancloud.cn/9b/09/9b09edf3b886a7877465aee3baab48de_800x600.jpg) 堆積狀態 LSTM 訓練對乘客預測問題的回歸表達式 ## 摘要在這篇文章中，您了解了如何使用 Keras 深度學習網絡在 Python 中開發用于時間序列預測的 LSTM 循環神經網絡。具體來說，你學到了： * 關于國際航空公司客運時間序列預測問題。 * 如何為回歸創建 LSTM 以及時間序列問題的窗口公式。 * 如何使用時間序列問題的時間步長公式創建 LSTM。 * 如何使用狀態和堆疊的 LSTM 創建具有狀態的 LSTM 以學習長序列。您對 LSTMs 有關時間序列預測或關于這篇文章的任何疑問嗎？在下面的評論中提出您的問題，我會盡力回答。 ### 更新了 LSTM 時間序列預測帖子：這篇文章中的例子非常陳舊，我有更好的例子可用于在時間序列中使用 LSTM，請參閱： 1. [用于單變量時間序列預測的 LSTM](https://machinelearningmastery.com/time-series-forecasting-long-short-term-memory-network-python/) 2. [多變量時間序列預測的 LSTM](https://machinelearningmastery.com/multivariate-time-series-forecasting-lstms-keras/) 3. [用于多步時間序列預測的 LSTM](https://machinelearningmastery.com/multi-step-time-series-forecasting-long-short-term-memory-networks-python/)