KerasGRU詳解

一、GRU簡介

循環神經網路（Recurrent Neural Network, RNN）一般用於處理序列數據。長短期記憶（Long Short-Term Memory, LSTM）是用於解決傳統RNN無法處理長序列數據的問題。然而，LSTM參數過多，訓練起來非常耗時。出於對參數數量和訓練時間的考慮，Gated Recurrent Unit（GRU）誕生了。相對於LSTM，GRU擁有更少的參數以及更快的訓練速度，而且在許多任務上的表現也相當不錯。

GRU通過引入重置門（reset gate）和更新門（update gate）來控制序列和隱藏狀態的信息流，以實現記憶單元和長短期記憶單元的功能。如果前一個時間步的輸出不重要，則更新門將其設置為值為零。重置門有利於減少圖像化貢獻和自我注重性，以增強RNN對局部特徵的表達能力。

二、KerasGRU模型結構

Keras是一種高級神經網路API，支持幾乎所有類型的神經網路模型。在Keras中，使用GRU是非常簡單的，理解模型的結構將使您更容易使用GRU及其他類型的神經網路。

GRU層可以通過keras.layers.GRU類來創建。以下是一個具有一個GRU層的簡單Keras模型：

from keras.models import Sequential
from keras.layers import GRU, Dense

model = Sequential()
model.add(GRU(64, input_shape=(10, 32)))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

上面的代碼片段是一個簡單的Keras分類模型，其中包含一個具有64個節點的GRU層和一個sigmoid激活函數的密集層。維度（10,32）指的是輸入序列的長度為10，每個時間步的維數為32。優化器使用Adam，損失函數為二元交叉熵。

三、KerasGRU參數詳解

1. activation

GRU輸出和隱藏狀態的激活函數。默認為超bolic正切（tanh），但是也可以使用其他激活函數，例如ReLU或Sigmoid。

2. recurrent_activation

GRU重置門和更新門的激活函數。默認為超bolic正切（tanh），但是也可以使用其他激活函數，例如ReLU或Sigmoid。

3. use_bias

表示GRU是否使用偏置。默認為True。當設置為False時，初始狀態必須提供。

4. kernel_initializer、recurrent_initializer、bias_initializer

初始化GRU層內權重和偏置的方法。默認為’glorot_uniform’，即Xavier（高斯）初始化用於權重和偏置，但其他初始化方法也可以使用，例如’zeros’或’ones’等。

5. kernel_regularizer、recurrent_regularizer、bias_regularizer

正則化GRU權重和偏差的方法。例如，可以使用L1或L2正則化（通過設置’keras.regularizers.l1’或’keras.regularizers.l2’）。使用正則化可以減少過擬合。

6. dropout、recurrent_dropout

Dropout是一種廣泛用於神經網路的正則化方法，用於減少過擬合。dropout是一個小小的概率，在每個時間步應用於GRU輸出，以丟棄一些節點，以提高網路的泛化能力和魯棒性。recurrent_dropout是類似的機制，但是在重置門和更新門上應用。

7. implementation

GRU的內部計算可以使用高效的基於GPU的方法或者更慢但更精確的基於CPU的方法。默認情況下，’CuDNN’高效GPU實現被選擇，但在某些情況下（例如，使用GPU下降器）它可能無法使用。因此，’cpu’可能更好。

四、KerasGRU應用

1.文本分類

GRU常用於處理文本數據的序列生成和分類問題。可以使用預訓練的詞嵌入器初始化GRU層，並使用softmax激活函數對輸出進行分類。以下是一個示例，使用IMDB數據集對情感分析進行文本分類。

from keras.datasets import imdb
from keras.preprocessing import sequence
from keras.models import Sequential
from keras.layers import Embedding, GRU, Dense

max_features = 10000
max_len = 500
batch_size = 32

print('Loading data...')
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)

print(len(x_train), 'train sequences')
print(len(x_test), 'test sequences')

print('Pad sequences (samples x time)...')
x_train = sequence.pad_sequences(x_train, maxlen=max_len)
x_test = sequence.pad_sequences(x_test, maxlen=max_len)
print('x_train shape:', x_train.shape)
print('x_test shape:', x_test.shape)

model = Sequential()
model.add(Embedding(max_features, 32))
model.add(GRU(64, dropout=0.2, recurrent_dropout=0.2))
model.add(Dense(1, activation='sigmoid'))

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
print(model.summary())

model.fit(x_train, y_train, batch_size=batch_size, epochs=5, validation_data=(x_test, y_test))

score, acc = model.evaluate(x_test, y_test, batch_size=batch_size)
print('Test score:', score)
print('Test accuracy:', acc)

2.序列生成

通過預訓練的GRU層，您可以將序列生成的問題看作是序列到序列（sequence-to-sequence）的問題。這裡是一個實現母音字母的語音序列生成的示例。注意，這是一個基於字元的序列生成，GRU的輸出維度為5（母音字母a,e,i,o,u）。

import numpy as np
from keras.models import Sequential
from keras.layers import GRU, Dense
from keras.optimizers import RMSprop

# Vocabulary
vowels = ['a', 'e', 'i', 'o', 'u']
vowels_idx = dict((c, i) for i, c in enumerate(vowels))
n_vowels = len(vowels)

# Dataset: Generate n dataset samples of length m
n, m = 32000, 10
x = np.random.choice(vowels, (n, m))
y = (x == 'a') | (x == 'e') | (x == 'i') | (x == 'o') | (x == 'u')

# One-hot encoding
x_ohe = np.zeros((n, m, n_vowels), dtype=np.bool)
for i in range(n):
    for j in range(m):
        x_ohe[i, j, vowels_idx[x[i, j]]] = 1
y_ohe = y.astype(np.float32)

# Split into train and test
split = int(0.8 * len(x))
x_train, y_train = x_ohe[:split], y_ohe[:split]
x_test, y_test = x_ohe[split:], y_ohe[split:]

# Build model
model = Sequential()
model.add(GRU(32, input_shape=(None, n_vowels)))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer=RMSprop(lr=0.01))

# Train the model
model.fit(x_train, y_train, batch_size=32, epochs=10, validation_data=(x_test, y_test))

# Predict vowel based on previous 3 characters
x_test = np.array([['u', 'o', 'u'], ['i', 'o', 'i']]) # 'ouu' and 'ioi'
x_test_ohe = np.zeros((2, 3, n_vowels), dtype=np.bool)
for i in range(2):
    for j in range(3):
        x_test_ohe[i, j, vowels_idx[x_test[i, j]]] = 1
y_test_pred = model.predict(x_test_ohe, verbose=0)
print(y_test_pred)

3.時間序列

GRU可用於時間序列問題，例如用於預測未來的股票價格。這裡是一個小樣本模擬，它說明如何使用KerasGRU建立和訓練模型，以預測時間序列中的下一個步驟。

import numpy as np
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import GRU, Dense
from keras.optimizers import RMSprop

# Generate noisy time series data
t = np.arange(0, 30, 0.1)
noise = np.random.randn(len(t))
x = np.sin(0.3 * t) + 0.1 * noise
plt.plot(t, x)

# Dataset
lookback = 10
delay = 3
n_train = 1500
n_test = 1000

def create_dataset(data, lookback, delay, min_index, max_index):
    data = data.astype(np.float32)
    samples = []
    targets = []
    for start in range(min_index, max_index - lookback - delay):
        samples.append(data[start:start+lookback])
        targets.append(data[start+lookback+delay])
    return np.array(samples), np.array(targets)

x_train, y_train = create_dataset(x, lookback, delay, 0, n_train)
x_test, y_test = create_dataset(x, lookback, delay, n_train, n_train + n_test)

print(x_train.shape, y_train.shape)

# Build model
model = Sequential()
model.add(GRU(32, input_shape=(None, 1)))
model.add(Dense(1))
model.compile(loss='mse', optimizer=RMSprop(lr=0.01))

# Train the model
model.fit(np.expand_dims(x_train, axis=-1), y_train, batch_size=128, epochs=10, validation_data=(np.expand_dims(x_test, axis=-1), y_test))

# Predict future values
predictions = model.predict(np.expand_dims(x_test, axis=-1))
plt.plot(t[:len(x_test)], predictions)
plt.show()