原文連結：http://tecdat.cn/?p=8461
原文出處：拓端資料部落公衆号
時間序列預測是指我們必須根據時間相關的輸入來預測結果的問題類型。時間序列資料的典型示例是股市資料，其中股價随時間變化。
遞歸神經網絡（RNN）已被證明可以有效解決序列問題。特别地，作為RNN的變體的長期短期記憶網絡（LSTM）目前正在各種領域中用于解決序列問題。
序列問題的類型
序列問題可以大緻分為以下幾類：
- 一對一：其中有一個輸入和一個輸出。一對一序列問題的典型示例是您擁有一幅圖像并且想要為該圖像預測單個标簽的情況。
- 多對一：在多對一序列問題中，我們将資料序列作為輸入，并且必須預測單個輸出。文本分類是多對一序列問題的主要示例，其中我們有一個單詞輸入序列，并且我們希望預測一個輸出标簽。
- 一對多：在一對多序列問題中，我們隻有一個輸入和一個輸出序列。典型示例是圖像及其相應的說明。
- 多對多：多對多序列問題涉及序列輸入和序列輸出。例如，将7天的股票價格作為輸入，并将接下來7天的股票價格作為輸出。聊天機器人還是多對多序列問題的一個示例，其中文本序列是輸入，而另一個文本序列是輸出。
在本文中，我們将了解如何使用LSTM及其不同的變體來解決一對一和多對一的序列問題。
閱讀本文後，您将能夠基于曆史資料解決諸如股價預測，天氣預報等問題。由于文本也是單詞序列，是以本文中獲得的知識也可以用于解決自然語言處理任務，例如文本分類，語言生成等。
一對一序列問題
正如我之前所說，在一對一序列問題中，隻有一個輸入和一個輸出。在本節中，我們将看到兩種類型的序列問題。首先，我們将了解如何使用單個特征解決一對一的序列問題，然後我們将了解如何使用多個特征解決一對一的序列問題。
單一特征的一對一序列問題
在本節中，我們将看到如何解決每個時間步都有一個特征的一對一序列問題。
首先，我們導入将在本文中使用的必需庫：
from numpy import array
from keras.preprocessing.text import one_hot
from keras.preprocessing.sequence import pad_sequences
from keras.models import Sequential
from keras.layers.core import Activation, Dropout, Dense
from keras.layers import Flatten, LSTM
from keras.layers import GlobalMaxPooling1D
from keras.models import Model
from keras.layers.embeddings import Embedding
from sklearn.model_selection import train_test_split
from keras.preprocessing.text import Tokenizer
from keras.layers import Input
from keras.layers.merge import Concatenate
from keras.layers import Bidirectional
import pandas as pd
import numpy as np
import re
import matplotlib.pyplot as plt
建立資料集
在下一步中，我們将準備本節要使用的資料集。
X = list()
Y = list()
X = [x+1 for x in range(20)]
Y = [y * 15 for y in X]
print(X)
print(Y)
在上面的腳本中，我們建立20個輸入和20個輸出。每個輸入都包含一個時間步，而該時間步又包含一個特征。每個輸出值是相應輸入值的15倍。如果運作上面的腳本，應該看到如下所示的輸入和輸出值：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
[15, 30, 45, 60, 75, 90, 105, 120, 135, 150, 165, 180, 195, 210, 225, 240, 255, 270, 285, 300]
LSTM層的輸入應為3D形狀，即（樣本，時間步長，特征）。樣本是輸入資料中樣本的數量。輸入中有20個樣本。時間步長是每個樣本的時間步長數。我們有1個時間步。最後，特征對應于每個時間步的特征數量。每個時間步都有一個特征。
X = array(X).reshape(20, 1, 1)
通過簡單LSTM解決方案
現在，我們可以建立具有一個LSTM層的簡單LSTM模型。
model = Sequential()
model.add(LSTM(50, activation='relu', input_shape=(1, 1)))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mse')
print(model.summary())
在上面的腳本中，我們建立了一個LSTM模型，該模型具有一層包含50個神經元和
relu
激活函數的LSTM層。您可以看到輸入形狀為（1,1），因為我們的資料具有一個特征的時間步長。
Layer (type) Output Shape Param #
=================================================================
lstm_16 (LSTM) (None, 50) 10400
_________________________________________________________________
dense_15 (Dense) (None, 1) 51
=================================================================
Total params: 10,451
Trainable params: 10,451
Non-trainable params: 0
現在讓我們訓練模型：
model.fit(X, Y, epochs=2000, validation_split=0.2, batch_size=5)
我們為2000個時期訓練模型，批大小為5。您可以選擇任何數字。訓練模型後，我們可以對新執行個體進行預測。
假設我們要預測輸入為30的輸出。實際輸出應為30 x 15 =450。 首先，我們需要按照LSTM的要求将測試資料轉換為正确的形狀，即3D形狀。以下 預測數字30的輸出：
print(test_output)
我得到的輸出值
437.86
略小于450。
通過堆疊LSTM解決方案
現在讓我們建立一個堆疊的LSTM，看看是否可以獲得更好的結果。資料集将保持不變，模型将被更改。看下面的腳本：
print(model.summary())
在上面的模型中，我們有兩個LSTM層。注意，第一個LSTM層的參數
return_sequences
設定為
True
。當傳回序列設定
True
為時，每個神經元隐藏狀态的輸出将用作下一個LSTM層的輸入。以上模型的摘要如下：
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
lstm_33 (LSTM) (None, 1, 50) 10400
_________________________________________________________________
lstm_34 (LSTM) (None, 50) 20200
_________________________________________________________________
dense_24 (Dense) (None, 1) 51
=================================================================
Total params: 30,651
Trainable params: 30,651
Non-trainable params: 0
________________________
接下來，我們需要訓練我們的模型，如以下腳本所示：
print(test_output)
我得到的輸出為459.85，好于我們通過單個LSTM層獲得的數字437。
具有多個特征的一對一序列問題
在最後一節中，每個輸入樣本都有一個時間步，其中每個時間步都有一個特征。在本節中，我們将看到如何解決輸入時間步長具有多個特征的一對一序列問題。
建立資料集
首先建立資料集。看下面的腳本：
nums = 25
X1 = list()
X2 = list()
X = list()
Y = list()
print(X1)
print(X2)
print(Y)
在上面的腳本中，我們建立三個清單：
X1
，
X2
，和
Y
。每個清單包含25個元素，這意味着總樣本大小為25。最後，
Y
包含輸出。
X1
，
X2
以及
Y
清單已輸出在下面：
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50]
[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75]
[6, 24, 54, 96, 150, 216, 294, 384, 486, 600, 726, 864, 1014, 1176, 1350, 1536, 1734, 1944, 2166, 2400, 2646, 2904, 3174, 3456, 3750]
輸出清單中的每個元素基本上都是
X1
和
X2
清單中相應元素的乘積。例如，輸出清單中的第二個元素是24，這是清單中的第二個元素（
X1
即4）和清單中的第二個元素（
X2
即6 ）的乘積。
輸入将由
X1
和
X2
清單的組合組成，其中每個清單将表示為一列。以下腳本建立最終輸入：
X = np.column_stack((X1, X2))
print(X)
這是輸出：
[[ 2 3]
[ 4 6]
[ 6 9]
[ 8 12]
[10 15]
[12 18]
[14 21]
[16 24]
[18 27]
[20 30]
[22 33]
[24 36]
[26 39]
[28 42]
[30 45]
[32 48]
[34 51]
[36 54]
[38 57]
[40 60]
[42 63]
[44 66]
[46 69]
[48 72]
[50 75]]
可以看到它包含兩列，即每個輸入兩個特征。如前所述，我們需要将輸入轉換為3維形狀。我們的輸入有25個樣本，其中每個樣本包含1個時間步，每個時間步包含2個特征。以下腳本可重塑輸入。
X = array(X).reshape(25, 1, 2)
通過簡單LSTM解決方案
我們現在準備訓練我們的LSTM模型。讓我們首先像上一節中那樣開發一個LSTM模型：
model = Sequential()
model.add(LSTM(80, activation='relu', input_shape=(1, 2)))
print(model.summary())
在這裡，我們的LSTM層包含80個神經元。我們有兩個神經層，其中第一層包含10個神經元，第二個密集層（也作為輸出層）包含1個神經元。該模型的摘要如下：
Layer (type) Output Shape Param #
=================================================================
lstm_38 (LSTM) (None, 80) 26560
_________________________________________________________________
dense_29 (Dense) (None, 10) 810
_________________________________________________________________
dense_30 (Dense) (None, 1) 11
=================================================================
Total params: 27,381
Trainable params: 27,381
Non-trainable params: 0
_________________________________________________________________
None
以下腳本訓練模型：
model.fit(X, Y, epochs=2000, validation_split=0.2, batch_size=5)
讓我們在一個新的資料點上測試我們訓練有素的模型。我們的資料點将具有兩個特征，即（55,80）實際輸出應為55 x 80 =4400。讓我們看看我們的算法預測了什麼。執行以下腳本：
print(test_output)
我的輸出為3263.44，與實際輸出相差甚遠。
通過堆疊LSTM解決方案
現在，讓我們建立一個具有多個LSTM和密集層的更複雜的LSTM，看看是否可以改善我們的結果：
model = Sequential()
print(model.summary())
模型摘要如下：
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
lstm_53 (LSTM) (None, 1, 200) 162400
_________________________________________________________________
lstm_54 (LSTM) (None, 1, 100) 120400
_________________________________________________________________
lstm_55 (LSTM) (None, 1, 50) 30200
_________________________________________________________________
lstm_56 (LSTM) (None, 25) 7600
_________________________________________________________________
dense_43 (Dense) (None, 20) 520
_________________________________________________________________
dense_44 (Dense) (None, 10) 210
_________________________________________________________________
dense_45 (Dense) (None, 1) 11
=================================================================
Total params: 321,341
Trainable params: 321,341
Non-trainable params: 0
下一步是訓練我們的模型，并在測試資料點（即（55,80））上對其進行測試。
為了提高準确性，我們将減小批量大小，并且由于我們的模型更加複雜，現在我們還可以減少時期數。以下腳本訓練LSTM模型并在測試資料點上進行預測。
print(test_output)
在輸出中，我得到的值3705.33仍小于4400，但比以前使用單個LSTM層獲得的3263.44的值好得多。您可以将LSTM層，密集層，批處理大小和時期數進行不同的組合，以檢視是否獲得更好的結果。
多對一序列問題
在前面的部分中，我們看到了如何使用LSTM解決一對一的序列問題。在一對一序列問題中，每個樣本都包含一個或多個特征的單個時間步長。具有單個時間步長的資料實際上不能視為序列資料。事實證明，密集連接配接的神經網絡在單個時間步長資料下表現更好。
實際序列資料包含多個時間步長，例如過去7天的股票市場價格，包含多個單詞的句子等等。
在本節中，我們将看到如何解決多對一序列問題。在多對一序列問題中，每個輸入樣本具有多個時間步長，但是輸出由單個元素組成。輸入中的每個時間步都可以具有一個或多個特征。我們将從具有一個特征的多對一序列問題開始，然後我們将了解如何解決輸入時間步長具有多個特征的多對一問題。
具有單個特征的多對一序列問題
首先建立資料集。我們的資料集将包含15個樣本。每個樣本将具有3個時間步長，其中每個時間步長将包含一個單一特征，即一個數字。每個樣本的輸出将是三個時間步長中每個步長的數字之和。例如，如果我們的樣本包含序列4,5,6，則輸出将為4 + 5 + 6 = 10。
建立資料集
首先建立一個從1到45的整數清單。由于我們要在資料集中獲得15個樣本，是以我們将對包含前45個整數的整數清單進行整理。
X = np.array([x+1 for x in range(45)])
print(X)
在輸出中，您應該看到前45個整數：
[ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45]
我們可以使用以下函數将其整理為樣本數，時間步長和特征：
X = X.reshape(15,3,1)
print(X)
上面的腳本将清單
X
轉換為帶有15個樣本，3個時間步長和1個特征的3維形狀。上面的腳本還輸出了調整後的資料。
[[[ 1]
[ 2]
[ 3]]
[[ 4]
[ 5]
[ 6]]
[[ 7]
[ 8]
[ 9]]
[[10]
[11]
[12]]
[[13]
[14]
[15]]
[[16]
[17]
[18]]
[[19]
[20]
[21]]
[[22]
[23]
[24]]
[[25]
[26]
[27]]
[[28]
[29]
[30]]
[[31]
[32]
[33]]
[[34]
[35]
[36]]
[[37]
[38]
[39]]
[[40]
[41]
[42]]
[[43]
[44]
[45]]]
我們已經将輸入資料轉換為正确的格式，現在讓我們建立輸出向量。正如我之前所說，輸出中的每個元素将等于相應輸入樣本中時間步長中的值之和。以下腳本建立輸出向量：
Y = list()
for x in X:
print(Y)
輸出數組
Y
如下所示：
[ 6 15 24 33 42 51 60 69 78 87 96 105 114 123 132]
通過簡單LSTM解決方案
現在讓我們用一個LSTM層建立模型。
model = Sequential()
model.compile(optimizer='adam', loss='mse')
以下腳本訓練了我們的模型：
history = model.fit(...)
訓練完模型後，我們就可以使用它對測試資料點進行預測。讓我們預測數字序列50、51、52的輸出。實際輸出應為50 + 51 + 52 =153。以下腳本将我們的測試點轉換為3維形狀，然後預測輸出：
print(test_output)
我的輸出為145.96，比實際輸出值153少7點。
通過堆疊LSTM解決方案
現在，讓我們建立一個具有多層的複雜LSTM模型，看看是否可以獲得更好的結果。執行以下腳本來建立和訓練具有多個LSTM和密集層的複雜模型：
model = Sequential()
model.compile(optimizer='adam', loss='mse')
history = model.fit(X, Y, epochs=1000, validation_split=0.2, verbose=1)
現在讓我們在測試序列（即50、51、52）上測試模型：
print(test_output)
我在這裡得到的答案是155.37，比我們之前得到的145.96更好。在這種情況下，我們與153的實際內插補點隻有2分。
通過雙向LSTM解決方案
雙向LSTM是一種LSTM，可以從正向和反向兩個方向的輸入序列中學習。最終的序列解釋是向前和向後學習周遊。讓我們看看使用雙向LSTM是否可以獲得更好的結果。
以下腳本建立了一個雙向LSTM模型，該模型具有一個雙向層和一個作為模型輸出的密集層。
from keras.layers import Bidirectional
model.compile(optimizer='adam', loss='mse')
以下腳本訓練模型并根據測試序列50、51和52進行預測。
print(test_output)
我得到的結果是152.26，僅比實際結果少一小部分。是以，我們可以得出結論，對于我們的資料集，具有單層的雙向LSTM的性能優于單層和堆疊的單向LSTM。
具有多個特征的多對一序列問題
在多對一序列問題中，我們有一個輸入，其中每個時間步均包含多個特征。輸出可以是一個值或多個值，在輸入時間步長中每個特征一個。我們将在本節中介紹這兩種情況。
建立資料集
我們的資料集将包含15個樣本。每個樣本将包含3個時間步。
讓我們建立兩個清單。一個将包含3的倍數，直到135，即總共45個元素。第二個清單将包含5的倍數，從1到225。第二個清單也将總共包含45個元素。以下腳本建立這兩個清單：
X1 = np.array([x+3 for x in range(0, 135, 3)])
print(X2)
您可以在以下輸出中看到清單的内容：
[ 3 6 9 12 15 18 21 24 27 30 33 36 39 42 45 48 51 54
57 60 63 66 69 72 75 78 81 84 87 90 93 96 99 102 105 108
111 114 117 120 123 126 129 132 135]
[ 5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90
95 100 105 110 115 120 125 130 135 140 145 150 155 160 165 170 175 180
185 190 195 200 205 210 215 220 225]
上面的每個清單代表時間樣本中的一個特征。可以通過合并兩個清單來建立聚合資料集，如下所示：
X = np.column_stack((X1, X2))
print(X)
輸出顯示彙總的資料集：
[ 6 10]
[ 9 15]
[ 12 20]
[ 15 25]
[ 18 30]
[ 21 35]
[ 24 40]
[ 27 45]
[ 30 50]
[ 33 55]
[ 36 60]
[ 39 65]
[ 42 70]
[ 45 75]
[ 48 80]
[ 51 85]
[ 54 90]
[ 57 95]
[ 60 100]
[ 63 105]
[ 66 110]
[ 69 115]
[ 72 120]
[ 75 125]
[ 78 130]
[ 81 135]
[ 84 140]
[ 87 145]
[ 90 150]
[ 93 155]
[ 96 160]
[ 99 165]
[102 170]
[105 175]
[108 180]
[111 185]
[114 190]
[117 195]
[120 200]
[123 205]
[126 210]
[129 215]
[132 220]
[135 225]]
我們需要将資料重塑為三個次元，以便LSTM可以使用它。我們的資料集有45行，兩列。我們将資料集整理為15個樣本，3個時間步長和兩個特征。
X = array(X).reshape(15, 3, 2)
print(X)
您可以在以下輸出中看到15個樣本：
[[[ 3 5]
[ 6 10]
[ 9 15]]
[[ 12 20]
[ 15 25]
[ 18 30]]
[[ 21 35]
[ 24 40]
[ 27 45]]
[[ 30 50]
[ 33 55]
[ 36 60]]
[[ 39 65]
[ 42 70]
[ 45 75]]
[[ 48 80]
[ 51 85]
[ 54 90]]
[[ 57 95]
[ 60 100]
[ 63 105]]
[[ 66 110]
[ 69 115]
[ 72 120]]
[[ 75 125]
[ 78 130]
[ 81 135]]
[[ 84 140]
[ 87 145]
[ 90 150]]
[[ 93 155]
[ 96 160]
[ 99 165]]
[[102 170]
[105 175]
[108 180]]
[[111 185]
[114 190]
[117 195]]
[[120 200]
[123 205]
[126 210]]
[[129 215]
[132 220]
[135 225]]]
輸出還将具有對應于15個輸入樣本的15個值。輸出中的每個值将是每個輸入樣本的第三時間步中兩個特征值的總和。例如，第一個樣本的第三時間步長具有特征9和15，是以輸出将為24。類似地，第二個樣本的第三時間步長中的兩個特征值分别為18和30；第二個時間步長中的兩個特征值分别為18和30。相應的輸出将是48，依此類推。
以下腳本建立并顯示輸出向量：
[ 24 48 72 96 120 144 168 192 216 240 264 288 312 336 360]
現在讓我們通過簡單的，堆疊的和雙向的LSTM解決多對一序列問題。
通過簡單LSTM解決方案
model = Sequential()
history = model.fit(X, Y, epochs=1000, validation_split=0.2, verbose=1)
模型經過訓練。我們将建立一個測試資料點，然後将使用我們的模型對測試點進行預測。
print(test_output)
輸入的第三時間步長的兩個特征的總和為14 + 61 =75。我們的帶有一個LSTM層的模型預測為73.41，這非常接近。
通過堆疊LSTM解決方案
以下腳本訓練堆疊的LSTM并在測試點上進行預測：
model = Sequential()
model.add(LSTM(200, activation='relu', return_sequences=True, input_shape=(3, 2)))
print(test_output)
我收到的輸出為71.56，比簡單的LSTM差。似乎我們堆疊的LSTM過度拟合。
通過雙向LSTM解決方案
這是簡單雙向LSTM的訓練腳本，以及用于對測試資料點進行預測的代碼：
from keras.layers import Bidirectional
model = Sequential()
print(test_output)
輸出為76.82，非常接近75。同樣，雙向LSTM似乎勝過其餘算法。
到目前為止，我們已經基于來自不同時間步長的多個要素值預測了單個值。在多對一序列的另一種情況下，您希望在時間步長中為每個特征預測一個值。例如，我們在本節中使用的資料集具有三個時間步，每個時間步具有兩個特征。我們可能希望預測每個特征系列的單獨價值。下面的示例很清楚，假設我們有以下輸入：
[[[ 3 5]
[ 6 10]
[ 9 15]]
在輸出中，我們需要一個具有兩個特征的時間步長，如下所示：
[12, 20]
您可以看到輸出中的第一個值是第一個序列的延續，第二個值是第二個序列的延續。我們可以通過簡單地将輸出密集層中神經元的數量更改為我們想要的輸出中的特征值的數量來解決此類問題。但是，首先我們需要更新輸出向量
Y
。輸入向量将保持不變：
Y = list()
for x in X:
print(Y)
上面的腳本建立一個更新的輸出向量并将其輸出，輸出如下所示：
[[ 12 20]
[ 21 35]
[ 30 50]
[ 39 65]
[ 48 80]
[ 57 95]
[ 66 110]
[ 75 125]
[ 84 140]
[ 93 155]
[102 170]
[111 185]
[120 200]
[129 215]
[138 230]]
現在，讓我們在資料集上訓練我們的簡單，堆疊和雙向LSTM網絡。以下腳本訓練了一個簡單的LSTM：
model = Sequential()
...
history = model.fit(X, Y, epochs=1000, validation_split=0.2, verbose=1)
下一步是在測試資料點上測試我們的模型。以下腳本建立一個測試資料點：
test_input = array([[20,34],
[23,39],
[26,44]])
...
print(test_output)
實際輸出為[29，45]。我們的模型預測[29.089157，48.469097]，這非常接近。
現在讓我們訓練一個堆疊的LSTM并預測測試資料點的輸出：
model = Sequential()
model.add(LSTM(100, activation='relu', return_sequences=True, input_shape=(3, 2)))
...
print(test_output)
輸出為[29.170143，48.688267]，再次非常接近實際輸出。
最後，我們可以訓練雙向LSTM并在測試點上進行預測：
from keras.layers import Bidirectional
model = Sequential()
...
print(test_output)
輸出為[29.2071，48.737988]。
您可以再次看到雙向LSTM做出最準确的預測。
結論
簡單的神經網絡不适用于解決序列問題，因為在序列問題中，除了目前輸入之外，我們還需要跟蹤先前的輸入。具有某種記憶的神經網絡更适合解決序列問題。LSTM就是這樣一種網絡。
最受歡迎的見解
1.用于NLP的Python：使用Keras的多标簽文本LSTM神經網絡分類
2.Python中利用長短期記憶模型LSTM進行時間序列預測分析 – 預測電力消耗資料
3.python在Keras中使用LSTM解決序列問題
4.Python中用PyTorch機器學習分類預測銀行客戶流失模型
5.R語言多元Copula GARCH 模型時間序列預測
6.在r語言中使用GAM（廣義相加模型）進行電力負荷時間序列分析
7.R語言中ARMA，ARIMA（Box-Jenkins），SARIMA和ARIMAX模型用于預測時間序列數
8.R語言估計時變VAR模型時間序列的實證研究分析案例
9.用廣義加性模型GAM進行時間序列分析
![TestLink導出用例轉換工具(XML2Excel)[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)