像長短期記憶（Long Short-Term Memory ) LSTM 遞迴神經網路這樣的神經網路幾乎可以完美地模擬多個輸入變數的問題。

這在時間序列預測中是一個很大的好處，經典的線性方法很難適應多元或多輸入預測問題。

在本教程中，您將瞭解如何在Keras深度學習庫中開發用於多變數時間序列預測的LSTM模型。

完成本教程後，您將知道：

• 如何將原始資料集轉換為我們可用於時間序列預測的東西。
• 如何準備資料和並將一個LSTM模型擬合到一個多變數的時間序列預測問題上。
• 如何進行預測並將結果重新調整到原始單位。

讓我們開始吧。

• 2017年8月更新：修正了在計算最終均方根（RMSE）時，y^與前一時間步的觀測值相比較的缺陷。謝謝，Songbin Xu 和David Righart。
• 2017年10月更新：增加了一個新的例子，展示瞭如何根據大眾需求來訓練多個優先的時間步。

教程概述

本教程分為3個部分; 他們是：

1. 空氣汙染預測
2. 基本資料準備
3. 多變數LSTM預測模型

Python環境

本教程假設您已經安裝了Python SciPy環境。本教程可以使用Python 2或3。

您必須在TensorFlow或Theano後端安裝了Keras（2.0或者更高版本）。

本教程還假設您已經安裝了scikit-learn，Pandas，與NumPy和Matplotlib庫。

如果你的環境需要幫助，請看這個帖子：

• 如何使用Anaconda設定Python環境進行機器學習和深度學習

1.空氣汙染預測

在本教程中，我們將使用空氣質量（Air Quality數）據集。

這是一個報告了中國北京美國大使館五年每個小時的天氣和汙染程度的資料集。

這些資料包括日期時間，稱為PM2.5濃度的汙染以及包括露點，溫度，壓力，風向，風速和累計雨雪小時數在內的天氣資訊。原始資料中的完整功能列表如下：

1. No：行號
2. year：這一行中的資料年份
3. month：此行中的資料月份
4. day：這一行中的資料日
5. hour：此行中的小時資料
6. pm2.5：PM2.5濃度
7. DEWP：露點
8. TEMP：溫度
9. PRES：壓力
10. cbwd：綜合風向
11. Iws：累計風速
12. Is：累積下了幾個小時的雪
13. Ir：累積下了幾個小時的雨

我們可以使用這些資料，並構建一個預測問題，在前一天的天氣條件和汙染情況下，我們預測下一個小時的汙染情況。

這個資料集可以用來構造其他的預測問題。

您可以從UCI Machine Learning Repository下載資料集。

• 北京PM2.5資料集

下載資料集並將其放在當前工作目錄中，檔案名為 “ raw.csv ”。

2.基本資料準備

資料尚未準備好使用。我們必須先準備。

以下是原始資料集的前幾行。

No,year,month,day,hour,pm2.5,DEWP,TEMP,PRES,cbwd,Iws,Is,I
1,2010,1,1,0,NA,-21,-11,1021,NW,1.79,0,0
2,2010,1,1,1,NA,-21,-12,1020,NW,4.92,0,0
3,2010,1,1,2,NA,-21,-11,1019,NW,6.71,0,0
4,2010,1,1,3,NA,-21,-14,1019,NW,9.84,0,0
5,2010,1,1,4,NA,-20,-12,1018,NW,12.97,0,0

第一步是將日期 - 時間資訊合併成一個日期 - 時間，以便我們可以將它用作Pandas的一個索引。

快速檢查顯示前24小時pm2.5的NA值。因此，我們將需要刪除第一行資料。資料集中後面還有一些零散的“NA”值。我們現在可以用0值來標記它們。

下面的指令碼載入原始資料集，並將日期 - 時間資訊解析為Pandas DataFrame索引。“否”列被刪除，然後為每列指定更清晰的名稱。最後，將NA值替換為“0”值，並且將前24小時移除。

“No”列被刪除，然後為每列指定更清晰的名稱。最後，將NA值替換為“0”值，並且將最初的24小時移除。

from pandas import read_csv
from datetime import datetime
# 載入資料
def parse(x):
    return datetime.strptime(x, '%Y %m %d %H')
dataset = read_csv('raw.csv',  parse_dates = [['year', 'month', 'day', 'hour']], index_col=0, date_parser=parse)
dataset.drop('No', axis=1, inplace=True)
# 手動更改列名
dataset.columns = ['pollution', 'dew', 'temp', 'press', 'wnd_dir', 'wnd_spd', 'snow', 'rain']
dataset.index.name = 'date'
# 把所有NA值用0替換
dataset['pollution'].fillna(0, inplace=True)
# 丟棄前24小時
dataset = dataset[24:] 
# 輸出前五行
print(dataset.head(5))
# 儲存到檔案中
dataset.to_csv('pollution.csv')
 

執行該示例將輸出轉換資料集的前5行，並將資料集儲存為“ pollution.csv ”。

                     pollution  dew  temp   press wnd_dir  wnd_spd  snow  rain
date
2010-01-02 00:00:00      129.0  -16  -4.0  1020.0      SE     1.79     0     0
2010-01-02 01:00:00      148.0  -15  -4.0  1020.0      SE     2.68     0     0
2010-01-02 02:00:00      159.0  -11  -5.0  1021.0      SE     3.57     0     0
2010-01-02 03:00:00      181.0   -7  -5.0  1022.0      SE     5.36     1     0
2010-01-02 04:00:00      138.0   -7  -5.0  1022.0      SE     6.25     2     0

現在我們有了一個易於使用的資料形式，我們可以快速繪製每個系列的圖，看看我們有什麼。

下面的程式碼載入新的“ pollution.csv ”檔案，並將每個序列作為一個單獨的子圖繪製，除了風速dir（這是絕對的）之外。

from pandas import read_csv
from matplotlib import pyplot
# 載入資料集
dataset = read_csv('pollution.csv', header=0, index_col=0)
values = dataset.values
# 指定要繪製的列
groups = [0, 1, 2, 3, 5, 6, 7]
i = 1
# 繪製每一列
pyplot.figure()
for group in groups:
    pyplot.subplot(len(groups), 1, i)
    pyplot.plot(values[:, group])
    pyplot.title(dataset.columns[group], y=0.5, loc='right')
    i += 1
pyplot.show()

執行該示例繪製了一個包含7個子圖的圖，顯示了每個變數的5年資料。

3.多元LSTM預測模型

在本節中，我們將適合LSTM的問題。

LSTM資料準備

第一步是準備LSTM的汙染資料集。

這涉及將資料集構造為監督學習問題並對輸入變數進行歸一化。

我們將監督學習問題的框架，作為汙染測量和天氣條件在前一個時間步驟（t）預測汙染。

這個表述很簡單，只是為了演示。您可以探索的一些替代配方包括：

• 根據過去24小時內的天氣情況和汙染情況，預測下一小時的汙染情況。
• 預測如上所述的下一小時的汙染，並給出下一小時的“預期”天氣條件。

我們可以使用部落格文章中開發的series_to_supervised（）函式來轉換資料集：

• 如何將時間序列轉換為Python中的監督學習問題

首先，載入“ pollution.csv ”資料集。風速特徵是標籤編碼（整數編碼）。如果你有興趣探索它，這可能會進一步在未來編碼。

接下來，將所有特徵歸一化，然後將該資料集變換成監督學習問題。然後去除要預測小時的天氣變數（t）。

下面提供了完整的程式碼清單。

# 將序列轉換成監督學習問題
def series_to_supervised(data, n_in=1, n_out=1, dropnan=True):
    n_vars = 1 if type(data) is list else data.shape[1]
    df = DataFrame(data)
    cols, names = list(), list()
    # input sequence (t-n, ... t-1)
    for i in range(n_in, 0, -1):
        cols.append(df.shift(i))
        names += [('var%d(t-%d)' % (j+1, i)) for j in range(n_vars)]
    # forecast sequence (t, t+1, ... t+n)
    for i in range(0, n_out):
        cols.append(df.shift(-i))
        if i == 0:
            names += [('var%d(t)' % (j+1)) for j in range(n_vars)]
        else:
            names += [('var%d(t+%d)' % (j+1, i)) for j in range(n_vars)]
    # put it all together
    agg = concat(cols, axis=1)
    agg.columns = names
    # drop rows with NaN values
    if dropnan:
        agg.dropna(inplace=True)
    return agg
 
# 載入資料集
dataset = read_csv('pollution.csv', header=0, index_col=0)
values = dataset.values
# 整數編碼方向
encoder = LabelEncoder()
values[:,4] = encoder.fit_transform(values[:,4])
# 確保所有資料是浮動的
values = values.astype('float32')
# 歸一化特徵
scaler = MinMaxScaler(feature_range=(0, 1))
scaled = scaler.fit_transform(values)
# 構建成監督學習問題
reframed = series_to_supervised(scaled, 1, 1)
# 丟棄我們不想預測的列
reframed.drop(reframed.columns[[9,10,11,12,13,14,15]], axis=1, inplace=True)
print(reframed.head())

執行該示例將列印轉換資料集的前5行。我們可以看到8個輸入變數（輸入序列）和1個輸出變數（當前小時的汙染程度）。

   var1(t-1)  var2(t-1)  var3(t-1)  var4(t-1)  var5(t-1)  var6(t-1)  
1   0.129779   0.352941   0.245902   0.527273   0.666667   0.002290
2   0.148893   0.367647   0.245902   0.527273   0.666667   0.003811
3   0.159960   0.426471   0.229508   0.545454   0.666667   0.005332
4   0.182093   0.485294   0.229508   0.563637   0.666667   0.008391
5   0.138833   0.485294   0.229508   0.563637   0.666667   0.009912
 
   var7(t-1)  var8(t-1)   var1(t)
1   0.000000        0.0  0.148893
2   0.000000        0.0  0.159960
3   0.000000        0.0  0.182093
4   0.037037        0.0  0.138833
5   0.074074        0.0  0.109658

這個資料準備很簡單，我們可以探索更多。你可以看一些想法包括：

• 一位有效編碼風速。
• 通過差分和季節調整使所有的系列保持平穩。
• 提供超過1小時的輸入時間步。

在學習序列預測問題時，考慮到LSTM使用反向傳播的時間，最後一點可能是最重要的。

定義和擬合模型

在本節中，我們將在多元輸入資料上擬合一個LSTM模型。

首先，我們必須將準備好的資料集分解為訓練集和測試集。為了加速演示中對模型的訓練，我們將只適合第一年的資料模型，然後在剩下的4年資料上進行評估。如果有時間的話，可以考慮探索這個測試工具的倒置版本。

下面的例子將資料集分解為訓練集和測試集，然後將訓練集和測試集分解為輸入和輸出變數。最後，輸入（X）重塑成LSTM預期的3D格式，即[樣例，時間步，特徵]。

# 把資料分為訓練集和測試集
values = reframed.values
n_train_hours = 365 * 24
train = values[:n_train_hours, :]
test = values[n_train_hours:, :]
# 把資料分為輸入和輸出
train_X, train_y = train[:, :-1], train[:, -1]
test_X, test_y = test[:, :-1], test[:, -1]
# 把輸入重塑成3D格式 [樣例， 時間步, 特徵]
train_X = train_X.reshape((train_X.shape[0], 1, train_X.shape[1]))
test_X = test_X.reshape((test_X.shape[0], 1, test_X.shape[1]))
print(train_X.shape, train_y.shape, test_X.shape, test_y.shape)

執行此示例將輸出訓練集和測試集的輸入輸出形狀，其中包含大約9K小時的訓練資料和大約35K小時的測試資料。

(8760, 1, 8) (8760,) (35039, 1, 8) (35039,)

現在我們可以定義和擬合我們的LSTM模型。

我們將在第一隱層中定義50個神經元，在輸出層中定義1個神經元用於預測汙染。輸入形狀將是帶有8個特徵的一個時間步。

我們將使用平均絕對誤差（MAE）損失函式和隨機梯度下降的高效Adam版本。

該模型將適用於批量大小為72的50個訓練時期。請記住，Keras中的LSTM的內部狀態在每個批次結束時被重置，所以是多天函式的內部狀態可能是有用的（嘗試測試）。

最後，我們通過在fit（）函式中設定validation_data引數來跟蹤訓練期間的訓練和測試損失。在執行結束時，訓練和測試損失都被繪製出來。

# 設計網路
model = Sequential()
model.add(LSTM(50, input_shape=(train_X.shape[1], train_X.shape[2])))
model.add(Dense(1))
model.compile(loss='mae', optimizer='adam')
# 擬合網路
history = model.fit(train_X, train_y, epochs=50, batch_size=72, validation_data=(test_X, test_y), verbose=2, shuffle=False)
# 繪製歷史資料
pyplot.plot(history.history['loss'], label='train')
pyplot.plot(history.history['val_loss'], label='test')
pyplot.legend()
pyplot.show()

評估模型

模型擬合後，我們可以預測整個測試資料集。

我們將預測與測試資料集結合起來，並將縮放比例倒置。我們還將測試資料集與預期的汙染資料進行了轉換。

通過預測值和實際值，我們可以計算模型的誤差分數。在這種情況下，我們計算出與變數本身相同的單位給出誤差的均方根誤差（RMSE）。

# 作出預測
yhat = model.predict(test_X)
test_X = test_X.reshape((test_X.shape[0], test_X.shape[2]))
# 反向縮放預測值
inv_yhat = concatenate((yhat, test_X[:, 1:]), axis=1)
inv_yhat = scaler.inverse_transform(inv_yhat)
inv_yhat = inv_yhat[:,0]
# 反向縮放實際值
test_y = test_y.reshape((len(test_y), 1))
inv_y = concatenate((test_y, test_X[:, 1:]), axis=1)
inv_y = scaler.inverse_transform(inv_y)
inv_y = inv_y[:,0]
# 計算RMSE
rmse = sqrt(mean_squared_error(inv_y, inv_yhat))
print('Test RMSE: %.3f' % rmse)1

完整例子

完整的例子如下所示。

注意：這個例子假定你已經準備好了正確的資料，例如把下載的“ raw.csv ”轉換成準備好的“ pollution.csv ”。請參閱本教程的第一部分。

from math import sqrt
from numpy import concatenate
from matplotlib import pyplot
from pandas import read_csv
from pandas import DataFrame
from pandas import concat
from sklearn.preprocessing import MinMaxScale
from sklearn.preprocessing import LabelEncode
from sklearn.metrics import mean_squared_erro
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
 
# 轉換序列成監督學習問題
def series_to_supervised(data, n_in=1, n_out=1, dropnan=True):
    n_vars = 1 if type(data) is list else data.shape[1]
    df = DataFrame(data)
    cols, names = list(), list()
    # input sequence (t-n, ... t-1)
    for i in range(n_in, 0, -1):
        cols.append(df.shift(i))
        names += [('var%d(t-%d)' % (j+1, i)) for j in range(n_vars)]
    # forecast sequence (t, t+1, ... t+n)
    for i in range(0, n_out):
        cols.append(df.shift(-i))
        if i == 0:
            names += [('var%d(t)' % (j+1)) for j in range(n_vars)]
        else:
            names += [('var%d(t+%d)' % (j+1, i)) for j in range(n_vars)]
    # put it all together
    agg = concat(cols, axis=1)
    agg.columns = names
    # drop rows with NaN values
    if dropnan:
        agg.dropna(inplace=True)
    return agg
 
# 載入資料集
dataset = read_csv('pollution.csv', header=0, index_col=0)
values = dataset.values
# 整數編碼
encoder = LabelEncoder()
values[:,4] = encoder.fit_transform(values[:,4])
# ensure all data is float
values = values.astype('float32')
# 歸一化特徵
scaler = MinMaxScaler(feature_range=(0, 1))
scaled = scaler.fit_transform(values)
# 構建監督學習問題
reframed = series_to_supervised(scaled, 1, 1)
# 丟棄我們並不想預測的列
reframed.drop(reframed.columns[[9,10,11,12,13,14,15]], axis=1, inplace=True)
print(reframed.head())
 
# 分割為訓練集和測試集
values = reframed.values
n_train_hours = 365 * 24
train = values[:n_train_hours, :]
test = values[n_train_hours:, :]
# 分為輸入輸出
train_X, train_y = train[:, :-1], train[:, -1]
test_X, test_y = test[:, :-1], test[:, -1]
# 重塑成3D形狀 [樣例, 時間步, 特徵]
train_X = train_X.reshape((train_X.shape[0], 1, train_X.shape[1]))
test_X = test_X.reshape((test_X.shape[0], 1, test_X.shape[1]))
print(train_X.shape, train_y.shape, test_X.shape, test_y.shape)
 
# 設計網路
model = Sequential()
model.add(LSTM(50, input_shape=(train_X.shape[1], train_X.shape[2])))
model.add(Dense(1))
model.compile(loss='mae', optimizer='adam')
# 擬合神經網路模型
history = model.fit(train_X, train_y, epochs=50, batch_size=72, validation_data=(test_X, test_y), verbose=2, shuffle=False)
# 繪製歷史資料
pyplot.plot(history.history['loss'], label='train')
pyplot.plot(history.history['val_loss'], label='test')
pyplot.legend()
pyplot.show()
 
# 做出預測
yhat = model.predict(test_X)
test_X = test_X.reshape((test_X.shape[0], test_X.shape[2]))
# 反向轉換預測值比例
inv_yhat = concatenate((yhat, test_X[:, 1:]), axis=1)
inv_yhat = scaler.inverse_transform(inv_yhat)
inv_yhat = inv_yhat[:,0]
# 反向轉換實際值比例
test_y = test_y.reshape((len(test_y), 1))
inv_y = concatenate((test_y, test_X[:, 1:]), axis=1)
inv_y = scaler.inverse_transform(inv_y)
inv_y = inv_y[:,0]
# 計算RMSE
rmse = sqrt(mean_squared_error(inv_y, inv_yhat))
print('Test RMSE: %.3f' % rmse)

首先執行示例建立一個顯示訓練期間訓練集和測試集損失的圖表。

有趣的是，我們可以看到測試損失低於訓練損失。該模型可能過度擬合。在訓練過程中測量和繪製均方根誤差可能會使我們看到更多的資訊。

訓練和測試損失被輸出在每個訓練時期結束時。在執行結束時，列印測試資料集上模型的最終RMSE。

我們可以看到，該模型達到了26.496的可比RMSE，低於用永續性模型發現的RMSE30。

 
...
Epoch 46/50
0s - loss: 0.0143 - val_loss: 0.0133
Epoch 47/50
0s - loss: 0.0143 - val_loss: 0.0133
Epoch 48/50
0s - loss: 0.0144 - val_loss: 0.0133
Epoch 49/50
0s - loss: 0.0143 - val_loss: 0.0133
Epoch 50/50
0s - loss: 0.0144 - val_loss: 0.0133
Test RMSE: 26.496

這個模型沒有調整。你能做得更好嗎？ 讓我知道你的問題框架，模型配置和RMSE在下面的評論。

更新：訓練多個滯後時間步的示例

關於如何調整上面的示例以在多個以前的時間步驟中訓練模型，已經有許多請求。

在寫這篇文章的時候，我嘗試了這個和其他許多配置，並決定不包含它們，因為它們沒有提升模型。

不過，我已經把下面這個例子作為參考模板，可以適應自己的問題。

在以前的多個時間步中訓練模型所需的更改非常少，如下所示：

首先，呼叫series_to_supervised（）時，必須適當地構造問題。我們將使用3小時的資料作為輸入。另請注意，我們不再明確地刪除ob（t）中所有其他欄位的列。

# 為滯後小時指定大小
n_hours = 3
n_features = 8
# frame as supervised learning
reframed = series_to_supervised(scaled, n_hours, 1)

接下來，我們需要更加小心地指定輸入和輸出的列。

我們在框架資料集中有3 * 8 + 8列。我們會將3 * 8或24列作為前3小時所有功能的輸入。我們將在下一小時將汙染變數作為輸出，如下所示：

# 分為輸入和輸出
n_obs = n_hours * n_features
train_X, train_y = train[:, :n_obs], train[:, -n_features]
test_X, test_y = test[:, :n_obs], test[:, -n_features]
print(train_X.shape, len(train_X), train_y.shape)1
 接下來，我們可以正確地重塑我們的輸入資料，以反映時間步驟和功能。

# 重塑成3D格式 [samples, timesteps, features]
train_X = train_X.reshape((train_X.shape[0], n_hours, n_features))
test_X = test_X.reshape((test_X.shape[0], n_hours, n_features))

擬合模型是一樣的。

唯一的另一個小變化就是如何評估模型。具體而言，在我們如何重構具有8列的行適合於反轉縮放操作以將y和y返回到原始尺度以便我們可以計算RMSE。

改變的要點是我們將y或yhat列與測試資料集的最後7個特徵連線起來，以反比例縮放，如下所示：

# 反向縮放預測值
inv_yhat = concatenate((yhat, test_X[:, -7:]), axis=1)
inv_yhat = scaler.inverse_transform(inv_yhat)
inv_yhat = inv_yhat[:,0]
# 反向縮放實際值
test_y = test_y.reshape((len(test_y), 1))
inv_y = concatenate((test_y, test_X[:, -7:]), axis=1)
inv_y = scaler.inverse_transform(inv_y)
inv_y = inv_y[:,0]
 

我們可以將所有這些修改與上面的例子結合在一起。具有多滯後輸入的多變數時間序列預測的完整示例如下所示：

from math import sqrt
from numpy import concatenate
from matplotlib import pyplot
from pandas import read_csv
from pandas import DataFrame
from pandas import concat
from sklearn.preprocessing import MinMaxScale
from sklearn.preprocessing import LabelEncode
from sklearn.metrics import mean_squared_erro
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
 
# 將序列轉換為監督學習問題
def series_to_supervised(data, n_in=1, n_out=1, dropnan=True):
    n_vars = 1 if type(data) is list else data.shape[1]
    df = DataFrame(data)
    cols, names = list(), list()
    # input sequence (t-n, ... t-1)
    for i in range(n_in, 0, -1):
        cols.append(df.shift(i))
        names += [('var%d(t-%d)' % (j+1, i)) for j in range(n_vars)]
    # forecast sequence (t, t+1, ... t+n)
    for i in range(0, n_out):
        cols.append(df.shift(-i))
        if i == 0:
            names += [('var%d(t)' % (j+1)) for j in range(n_vars)]
        else:
            names += [('var%d(t+%d)' % (j+1, i)) for j in range(n_vars)]
    # put it all togethe
    agg = concat(cols, axis=1)
    agg.columns = names
    # drop rows with NaN values
    if dropnan:
        agg.dropna(inplace=True)
    return agg
 
# 載入資料集
dataset = read_csv('pollution.csv', header=0, index_col=0)
values = dataset.values
# 整數編碼
encoder = LabelEncoder()
values[:,4] = encoder.fit_transform(values[:,4])
# 確保所有資料是浮動的
values = values.astype('float32')
# 歸一化特徵
scaler = MinMaxScaler(feature_range=(0, 1))
scaled = scaler.fit_transform(values)
# 指定滯後時間大小
n_hours = 3
n_features = 8
# 構建監督學習問題
reframed = series_to_supervised(scaled, n_hours, 1)
print(reframed.shape)
 
# 分為訓練集和測試集
values = reframed.values
n_train_hours = 365 * 24
train = values[:n_train_hours, :]
test = values[n_train_hours:, :]
# 分為輸入和輸出
n_obs = n_hours * n_features
train_X, train_y = train[:, :n_obs], train[:, -n_features]
test_X, test_y = test[:, :n_obs], test[:, -n_features]
print(train_X.shape, len(train_X), train_y.shape)
# 重塑為3D形狀 [samples, timesteps, features]
train_X = train_X.reshape((train_X.shape[0], n_hours, n_features))
test_X = test_X.reshape((test_X.shape[0], n_hours, n_features))
print(train_X.shape, train_y.shape, test_X.shape, test_y.shape)
 
# 設計網路
model = Sequential()
model.add(LSTM(50, input_shape=(train_X.shape[1], train_X.shape[2])))
model.add(Dense(1))
model.compile(loss='mae', optimizer='adam')
# 擬合網路模型
history = model.fit(train_X, train_y, epochs=50, batch_size=72, validation_data=(test_X, test_y), verbose=2, shuffle=False)
# 繪製歷史資料
pyplot.plot(history.history['loss'], label='train')
pyplot.plot(history.history['val_loss'], label='test')
pyplot.legend()
pyplot.show()
 
# 作出預測
yhat = model.predict(test_X)
test_X = test_X.reshape((test_X.shape[0], n_hours*n_features))
# 反向轉換預測值比例
inv_yhat = concatenate((yhat, test_X[:, -7:]), axis=1)
inv_yhat = scaler.inverse_transform(inv_yhat)
inv_yhat = inv_yhat[:,0]
# 反向轉換實際值大小
test_y = test_y.reshape((len(test_y), 1))
inv_y = concatenate((test_y, test_X[:, -7:]), axis=1)
inv_y = scaler.inverse_transform(inv_y)
inv_y = inv_y[:,0]
# 計算RMSE大小
rmse = sqrt(mean_squared_error(inv_y, inv_yhat))
print('Test RMSE: %.3f' % rmse)

這個模型在一兩分鐘內就像以前一樣。

...
Epoch 45/50
1s - loss: 0.0143 - val_loss: 0.0154
Epoch 46/50
1s - loss: 0.0143 - val_loss: 0.0148
Epoch 47/50
1s - loss: 0.0143 - val_loss: 0.0152
Epoch 48/50
1s - loss: 0.0143 - val_loss: 0.0151
Epoch 49/50
1s - loss: 0.0143 - val_loss: 0.0152
Epoch 50/50
1s - loss: 0.0144 - val_loss: 0.0149

訓練集和測試集的損失被繪製出來。

最後，測試RMSE是打印出來的，至少在這個問題上並沒有真正顯示出技術上的優勢。

Test RMSE: 27.177

我會補充說，LSTM 似乎不適合自迴歸型別的問題，並且您可能更適合用大視窗探索MLP。

我希望這個例子可以幫助你進行自己的時間序列預測實驗。

進一步閱讀

如果您正在深入研究，本節將提供更多有關該主題的資源。

• 北京PM2.5資料集在UCI機器學習庫
• Keras中長期短期記憶模型的5步生命週期
• Python中的長時間短時記憶網路的時間序列預測
• Python中的長期短期記憶網路的多步時間序列預測

概要

在本教程中，您瞭解瞭如何將LSTM應用於多變數時間序列預測問題。

具體來說，你瞭解到：

• 如何將原始資料集轉換為我們可用於時間序列預測的東西。
• 如何準備資料和適合多變數時間序列預測問題的LSTM。
• 如何進行預測並將結果重新調整到原始單位。