時間序列的預言者：如何通過 RNN、LSTM 和 GRU 預測未來

RNN的運作概念非常簡單，就是在每個時間點 t，RNN 會讀入一個新的序列資料 input_t，並利用這個資料以及自己的記憶狀態 state_t 來產生一個輸出 output_t。這個過程可以用下面的程式碼來表示：

1: def f(input_t, state_t): # f 函式是神經元的運算
2:     return input_t + state_t
3: state_t = 0 # 初始化細胞的狀態
4: for input_t in input_sequence:
5:     output_t = f(input_t, state_t) # f 函式是神經元的運算
6:     state_t = output_t # 更新細胞的狀態

在 RNN 每次讀入任何新的序列資料前，細胞 A 中的記憶狀態 state_t 都會被初始化為 0。

接著在每個時間點 t，RNN 會重複以下步驟：

• 讀入 input_sequence 序列中的一個新元素 input_t
  
• 利用 f 函式將當前細胞的狀態 state_t 以及輸入 input_t 做些處理產生 output_t
  
• 輸出 output_t 並同時更新自己的狀態 state_t
  

面對一個如下的簡易RNN，要如何將神經元當下的記憶 state_t 與輸入 input_t 結合，才能產生最有意義的輸出 output_t 呢？

1: state_t = 0
2: # 細胞 A 會重複執行以下處理
3: for input_t in input_sequence:
4:     output_t = f(input_t, state_t)
5:     state_t = output_t

RNN神經元在時間點t的輸出 \(h_t\) 由以下公式計算:
\[ h_t = f(W_x \cdot X_t + W_h \cdot h_{t-1} + b) \]

在 SimpleRNN 的神經元中，這個函數 \(f\) 的實作很簡單，這也導致了其記憶狀態 state_t 沒辦法很好地「記住」前面處理過的序列元素，因而造成 RNN 在處理後來的元素時，就已經把前面重要的資訊給忘記了，也就是只有短期記憶，沒有長期記憶。長短期記憶（Long Short-Term Memory, 後簡稱 LSTM）就是被設計來解決 RNN 的這個問題。

RNN的模型架構非常簡單，只需要一個 RNN 層即可。以 Keras 為例，建立一個 RNN 層只需要建立一個 SimpleRNN 層即可。以下是一個簡單的 RNN 模型架構：

 1: import tensorflow as tf
 2: from tensorflow.keras import layers, models
 3: 
 4: # 模型輸入層 (4個節點)
 5: inputs = layers.Input(shape=(1, 4))
 6: 
 7: # 隱藏層 (RNN層, 2個節點，對應h1, h2)
 8: hidden = layers.SimpleRNN(units=2, activation='tanh', return_sequences=False)(inputs)
 9: 
10: # 模型輸出層 (2個節點)
11: outputs = layers.Dense(units=2, activation='linear')(hidden)
12: 
13: # 建立並編譯模型
14: model = models.Model(inputs=inputs, outputs=outputs)
15: model.compile(optimizer='adam', loss='mse')
16: 
17: # 顯示模型結構
18: model.summary()

Model: "functional"
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ input_layer (InputLayer)        │ (None, 1, 4)           │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ simple_rnn (SimpleRNN)          │ (None, 2)              │            14 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense (Dense)                   │ (None, 2)              │             6 │
└─────────────────────────────────┴────────────────────────┴───────────────┘
 Total params: 20 (80.00 B)
 Trainable params: 20 (80.00 B)
 Non-trainable params: 0 (0.00 B)

上述模型架構的資料流向如下：

針對上述模型，我們可以設想一個智慧工廠中的機器維護預測系統，這個工廠中的一台重要機器每分鐘會傳回 4 個感測器數據：溫度、壓力、振動幅度和電流。這些數據會被送進 RNN 模型中，並根據目前時間點的數值預測機器的異常風險和維修建議指數。

機器感測器每分鐘會收到下列資料：

• 溫度（Temperature）
  
• 壓力（Pressure）
  
• 振動幅度（Vibration）
  
• 電流（Current）
  

這些資料會被送進 RNN 模型中，並根據目前時間點的數值預測：

• 預測下個時間點的異常風險（是否有可能故障）
  
• 預測是否需維修（建議立即維護/可繼續運行）
  

模型解讀：

• 輸入層（4 個感測器值）
  
• RNN 隱藏層會考慮時間序列的歷史變化（例如溫度持續升高等趨勢）
  
• 輸出層（2 個節點）代表兩個預測目標：
  
  • y₁: 機器異常風險機率
    
  • y₂: 維修建議指數（例如 0~1）
    

實際應用流程：

1. 感測器每分鐘傳來資料，累積成序列輸入模型。
   
2. RNN 模型處理並輸出風險值與建議。
   
3. 若風險高，系統自動發出警報並派出工程師檢條，防範因機器突然故障導致生產線停機進而導致生產進度落後與金錢損失。
   

1: model = keras.models.Sequential([
2:     keras.layers.SimpleRNN(1, input_shape=[None, 1])  # 預設 activation='tanh'
3: ])
4: model.compile(loss='mse', optimizer='adam')
5: model.summary()

在 Keras 中，input_shape=[None, 1] 的意思是：

在 Keras RNN 中，每筆資料會被視為一個 3 維陣列：

1: [樣本數, 時間步長 (None), 特徵數]

舉個例子：

1: X.shape = (1000, 20, 1)

我們現在只知道每個時間點有 1 個特徵（像是溫度），但不知道資料序列會多長，因此時間的維度就交給模型在運作時決定，所以寫 None。」

幾種RNN模型的評估指標如下：

1. MSE（均方誤差，Mean Squared Error）, 是預測值與實際值之間的平均平方差，越小越好, 單位是平方的數值。計算公式如下：
   \[ MSE = \frac{1}{n} \sum_{i=1}^{n} (y_i - \hat{y}_i)^2 \]
   其中，$y_i$是實際值，$\hat{y}_i$是預測值，$n$是樣本數。
   
2. MAE（平均絕對誤差，Mean Absolute Error）, 是預測值與實際值之間的平均絕對差，越小越好, 單位與資料本身一致, 優點是不容易被極端值影響。計算公式如下：
   \[ MAE = \frac{1}{n} \sum_{i=1}^{n} |y_i - \hat{y}_i| \]
   其中，$y_i$是實際值，$\hat{y}_i$是預測值，$n$是樣本數。
   
3. RMSE（均方根誤差，Root Mean Squared Error）, 是預測值與實際值之間的均方根誤差，越小越好, 單位是平方根的數值，常用在實際工程應用。 計算公式如下：
   \[ RMSE = \sqrt{\frac{1}{n} \sum_{i=1}^{n} (y_i - \hat{y}_i)^2} \]
   其中，$y_i$是實際值，$\hat{y}_i$是預測值，$n$是樣本數。
   
4. \(R^2\)（決定係數，Coefficient of Determination），是用來評估模型預測能力的指標，值介於0~1之間，越接近1表示模型越好。$R^2$的計算公式如下：
   \[ R^2 = 1 - \frac{\sum_{i=1}^{n} (y_i - \hat{y}_i)^2}{\sum_{i=1}^{n} (y_i - \bar{y})^2} \]
   

 1: predicted = model.predict(X_test)
 2: # 還原回原始數值
 3: predicted_inv = scaler.inverse_transform(predicted)
 4: actual_inv = scaler.inverse_transform(y_test)
 5: 
 6: plt.figure(figsize=(12, 4))
 7: plt.plot(actual_inv, label='Clean Target', alpha=0.6)
 8: plt.plot(predicted_inv, label='Predicted', alpha=0.8)
 9: plt.title("Keras SimpleRNN Prediction")
10: plt.xlabel("Time step")
11: plt.ylabel("Value")
12: plt.legend()
13: plt.grid(True)
14: plt.show()
15: 

想象你有一個書包（LSTM的內部結構），你可以決定在上課前放入什麼書籍、何時取出某本書，或者甚至決定更新裡面的某些書，你每天上學就利用書包裡的書來學習新的知識。LSTM也有類似的機制來處理信息，這些機制就是一個個的閘門(Gate)。

LSTM利用一個新的機制：記憶狀態（Cell State ）來達到保留長期記憶，如圖9所示，我們可以想像LSTM將RNN的隱藏狀態拆成兩部份：記憶狀態的變化較慢，能儘量保留先前的記憶、而隱藏狀態則隨輸入不同而有較多變化。

除了記憶狀態，LSTM還多了三個閘門來管控資訊的保留與遺忘：遺忘閘（forget gate）、輸入閘（input gate）、輸出閘（output gate）。其相應功能大致如下(參考圖10)：

1. 遺忘閘（forget gate）：控制模型中有哪些資訊可以被遺忘。
   
2. 輸入閘（input gate）：控制當前的輸入資訊能對記憶狀態產生多大的影響。
   
3. 輸出閘（output gate）：控制記憶狀態中的哪些資訊可以被傳遞到隱藏狀態並往後傳遞。
   

典型的LSTM架構如圖10所示，可以看出除了原本的資料輸入(input)，LSTM還多了三個輸入，分別是input(模型輸入），forget gate(遺忘閘)，input gate(輸入閘)，以及output gate(輸出閘)。因此相比普通的神經網路，LSTM的參數量是它們的4倍。這3個閘訊號都是處於0～1之間的實數，1代表完全打開，0代表關閉。

1. 遺忘閘（Forget Gate）：這就像是你決定從書包中拿掉不再需要的書。在LSTM中，遺忘閘會查看新的輸入信息和當前的記憶，然後決定保留哪些記憶（有用的）或者遺忘哪些（不再重要的）。
   
2. 輸入閘（Input Gate）：這是決定將哪些新書放入書包。LSTM會評估當前的輸入（例如新的單詞或資料點），並決定應該添加哪些信息到記憶中，這有助於更新記憶內容。
   
3. 輸出閘（Output Gate）：決定從書包中拿出哪本書來使用。根據需要的話題或任務，LSTM會決定哪些記憶是目前有用的，然後基於這些記憶提供輸出信息。
   
4. 記憶單元（Memory Cell）：這是LSTM的核心，它負責記錄和更新所有的記憶。記憶單元是一個長期的記憶存儲，可以通過遺忘閘和輸入閘來更新。LSTM 中的 Memory Cell（也就是記憶狀態，通常記為 Cₜ）的核心功能，就是要 跨時間步保持資訊的狀態，這也是它的關鍵設計。
   

圖10為時間點t時資料在神經元中流動示意，進一步的處理流程如下所述：

• LSTM神經元於時間點t收到三項輸入資料：
  
  1. x_t：代表當前時間點的輸入資料。
     
  2. h_(t-1)：上一時間點的隱藏狀態。
     
  3. c_(t-1)：上一時間點的記憶狀態。
     
• LSTM神經元於時間點t輸出兩項資料：
  
  1. c_t：代表當前的記憶狀態，c_t的值來自以下兩部份：
     
  2. 輸出閘：決定有多少來自c_t的資訊可以傳遞到h_t。
     

進一步從時間序列的角度來看，LSTM運作過程中的資料流向如下：

• 遺忘閘(Forget Gate)：該閘決定在特定時間點(timestamp, 例如圖12中的\(t\) )，前一個時間點(\(t-1\)) 的模型記憶(也就是狀態, state)是否會被記住保留參與這個時間點的運算，或是直接被遺忘。當遺忘閘打開時，前一刻的記憶會被保留，當遺忘閘關閉時，前一刻的記憶就會被清空。換句話說，就讓模型具備選擇性遺忘部份訊息的能力，這個機制可以由激活函數sigmoid來實作，其中0代表完全忘記，1代表完全記住。
  
• 輸入閘(Input Gate): 決定目前這個時間點有哪些神經元的輸入(\(x\))中有哪些是足夠重要到可以保留下來加入「目前狀態」中，因為在序列輸入中，並不是每個時刻的輸入的資訊都是同等重要的，當輸入完全沒有用時，輸入閘關閉，也就是此時刻的輸入資訊被丟棄了。這個機制同樣也可以由sigmoid 激活函數來實作，sigmoid產生的值介於0到1之間，可以被看作是一個閘控信號，這個閘控信號​和tanh函數生成的候選隱藏狀態相乘，確定了從候選狀態中將多少資訊添加到當前的單元狀態​中。
  
• 輸出閘(Output Gate): 決定目前神經元的狀態中有哪一部分可以輸出(流向下一個狀態)，同樣由激活函數來sigmoid來決定，這個輸出會通過tanh函數來調整，因為Tanh能夠將單元狀態的值正規化到-1到1之間，這有助於控制神經網路的激活範圍。再由Tanh來提供輸出權重。
  
• 記憶單元(Memory Cell): 這是LSTM的核心，它負責記錄和更新所有的記憶。記憶單元是一個長期的記憶存儲，可以通過遺忘閘和輸入閘來更新。LSTM 中的 Memory Cell（也就是記憶狀態，通常記為 Cₜ）的核心功能，就是要 跨時間步保持資訊的狀態，這也是它的關鍵設計。在數學公式中，LSTM 的記憶更新如下：\(C_t=f_t \times C_{t−1}+i_t \times \tilde{C}_t\)，其中：
  
  1. \(f_t\) ：忘記閘輸出（控制保留多少舊記憶）
     
  2. \(C_{t-1}\) ：上一個時間步的記憶狀態
     
  3. \(i_t\) ：輸入閘輸出（控制加入多少新資訊）
     
  4. \(\tilde{C}_t\) ：由當前輸入與前一隱藏狀態計算出的新候選記憶
     

因為這樣的機制，讓 LSTM 即使面對很長的序列資料也能有效處理，不遺忘以前的記憶。因為效果卓越，LSTM 非常廣泛地被使用。事實上，當有人跟你說他用 RNN 做了什麼 NLP 專案時，有 9 成機率他是使用 LSTM 或是 GRU（LSTM 的改良版，只使用 2 個閘閘） 來實作，而不是使用最簡單的 SimpleRNN。

LSTM 的設計引入了三個「閘」（gate）：

• **遺忘閘 forget gate**：決定應該忘記多少過去的記憶
  
• **輸入閘 input gate**：決定應該加入多少新的資訊進入記憶
  
• **輸出閘 output gate**：決定應該輸出多少目前的記憶內容
  

此外，LSTM 維持了兩種狀態：

• **cell state（長期記憶）C_t**：透過閘控機制被有選擇地保留或更新
  
• **hidden state（短期輸出）h_t**：實際傳給下一層網路的輸出
  

其計算過程可以用以下簡化版 Python 表示：

 1: def lstm_step(x_t, h_t_prev, c_t_prev):
 2:     forget_gate = sigmoid(W_f @ x_t + U_f @ h_t_prev + b_f)
 3:     input_gate = sigmoid(W_i @ x_t + U_i @ h_t_prev + b_i)
 4:     output_gate = sigmoid(W_o @ x_t + U_o @ h_t_prev + b_o)
 5:     candidate = tanh(W_c @ x_t + U_c @ h_t_prev + b_c)
 6: 
 7:     c_t = forget_gate * c_t_prev + input_gate * candidate
 8:     h_t = output_gate * tanh(c_t)
 9:     return h_t, c_t
10: 
11: h_t, c_t = 0, 0  # 初始化
12: for x_t in input_sequence:
13:     h_t, c_t = lstm_step(x_t, h_t, c_t)

LSTM 解決了 RNN 無法長期保留資訊的問題，特別適用於像語言模型、機器翻譯、長時間序列預測等任務。

LSTM 是一種改良版的 RNN，可記住更長期的資訊。只需將 SimpleRNN 改為 LSTM 層即可。以下是一個 LSTM 模型的寫法：

 1: import tensorflow as tf
 2: from tensorflow.keras import layers, models
 3: 
 4: # 模型輸入層 (4個節點)
 5: inputs = layers.Input(shape=(1, 4))
 6: 
 7: # 隱藏層 (LSTM層, 2個單元)
 8: hidden = layers.LSTM(units=2, activation='tanh', return_sequences=False)(inputs)
 9: 
10: # 模型輸出層 (2個節點)
11: outputs = layers.Dense(units=2, activation='linear')(hidden)
12: 
13: # 建立並編譯模型
14: model = models.Model(inputs=inputs, outputs=outputs)
15: model.compile(optimizer='adam', loss='mse')
16: 
17: # 顯示模型結構
18: model.summary()

Model: "functional"
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ input_layer (InputLayer)        │ (None, 1, 4)           │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ lstm (LSTM)                     │ (None, 2)              │            56 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense (Dense)                   │ (None, 2)              │             6 │
└─────────────────────────────────┴────────────────────────┴───────────────┘
 Total params: 62 (248.00 B)
 Trainable params: 62 (248.00 B)
 Non-trainable params: 0 (0.00 B)

當AI遇上股票-LSTM.ipynb