Encoder-Decoder 架構實現

基於循環網絡實現編解碼結構，代碼參考了Jason Brownlee博士博客，看上去博士也是參考官方文檔的內容。

1. 本人進行了一些注釋。

2. 該架構並不是循環網絡特有。

3. 序列的多部預測遵循循環導出的原則。

4.其中的隱狀態和細胞狀態確實依賴於LSTM這個特定模型

 

 

 5. 對於上圖的結構，基於循環網絡的編解碼結構，不忍許多人扯的血淋淋，故鄙人希望從簡抓要點。

　 遵循一般做事原則：找出口或入口或轉折點等重要接口；分割出循環單體。

    a. 重要接口在於中間的狀態

    b. 循環單體在於循環網絡時間步驟

    c. 做過時間序列預測不難看出，解碼器完成從不等長序列空間到狀態空間的映射，狀態沒有時間步驟概念(指的就是在某個時間戳下；解碼器就是一個一階時間序列預測(錯開一步預測)；

       既然是循環就需要起始條件，這也就是跟差分方程(或者微分方程）的起始條件差不多，由編碼器提供；時間序列的玩法，與經典統計中類似，一步模型的多步預測就按如下方式搞。

 

 

from random import randint
from numpy import array, argmax, array_equal
from keras.utils import to_categorical
from keras.models import Model
from keras.layers import Input, LSTM, Dense

# generate a sequence of random integers
def generate_sequence(length, n_unique):
    return [randint(1, n_unique-1) for _ in range(length)]


# prepare data for the LSTM
def get_dataset(n_in, n_out, cardinality, n_samples):
    X1, X2, y = list(), list(), list()
    for _ in range(n_samples):
        # generate source sequence
        source = generate_sequence(n_in, cardinality)
        # define padded target sequence
        target = source[:n_out]
        target.reverse()
        # create padded input target sequence
        target_in = [0] + target[:-1]
        # encode
        src_encoded = to_categorical(source, num_classes=cardinality)
        tar_encoded = to_categorical(target, num_classes=cardinality)
        tar2_encoded = to_categorical(target_in, num_classes=cardinality)
        # store
        X1.append(src_encoded)
        X2.append(tar2_encoded)
        y.append(tar_encoded)
    return array(X1), array(X2), array(y)


# returns train, inference_encoder and inference_decoder models
def define_models(n_input, n_output, n_units):
    # 定義訓練編碼器
    encoder_inputs = Input(shape=(None, n_input))  # n_input表示特征這一維(維的大小即特征的數目，如圖像的feature map)
    encoder = LSTM(n_units, return_state=True)  # 編碼器的特征維的大小dimension(n),即單元數。
    encoder_outputs, state_h, state_c = encoder(encoder_inputs) # 取出輸入生成的隱藏狀態和細胞狀態，作為解碼器的隱藏狀態和細胞狀態的初始化值。
    # 定義訓練解碼器
    decoder_inputs = Input(shape=(None, n_output))   # n_output：輸出響應序列的特征維的大小。
    decoder_lstm = LSTM(n_units, return_sequences=True, return_state=True)  # 因解碼器用編碼器的隱藏狀態和細胞狀態，所以n_units必等
    decoder_outputs, _, _ = decoder_lstm(decoder_inputs, initial_state=[state_h, state_c])  # 這個解碼層在后面推斷中會被共享！！

    decoder_dense = Dense(n_output, activation='softmax')    # 這個full層在后面推斷中會被共享！！
    decoder_outputs = decoder_dense(decoder_outputs)
    model = Model([encoder_inputs, decoder_inputs], decoder_outputs)  # 得到以輸入序列和目標序列作為輸入，以目標序列的移位為輸出的訓練模型

    # 定義推斷編碼器  根據輸入序列得到隱藏狀態和細胞狀態的路徑圖，得到模型，使用的輸入到輸出之間所有層的權重，與tf的預測簽名一樣
    encoder_model = Model(encoder_inputs, [state_h, state_c])   # 層編程模型很簡單，只要用Model包住其輸入和輸出即可。
    #encoder_outputs, state_h, state_c = encoder(encoder_inputs)  # ？ 似乎就是上面的
    # 定義推斷解碼器，由於循環網絡的性質，由輸入狀態(前)推理出輸出狀態(后)。
    decoder_state_input_h = Input(shape=(n_units,))
    decoder_state_input_c = Input(shape=(n_units,))

    decoder_outputs, state_h, state_c = decoder_lstm(decoder_inputs, initial_state=[decoder_state_input_h, decoder_state_input_c])
    decoder_outputs = decoder_dense(decoder_outputs)
    # 由老狀態更新出新的狀態
    decoder_model = Model([decoder_inputs, decoder_state_input_h, decoder_state_input_c], [decoder_outputs, state_h, state_c])
    # return all models
    return model, encoder_model, decoder_model


# generate target given source sequence
def predict_sequence(infenc, infdec, source, n_steps, cardinality):
    # encode
    h_state, c_state = infenc.predict(source)  # 根據輸入計算該原輸入在狀態空間的取值
    # start of sequence input
    target_seq = array([0.0 for _ in range(cardinality)]).reshape(1, 1, cardinality)   # shape (1, 1, 51) [[[0,0,..]]] 一步
    # collect predictions
    output = list()
    for t in range(n_steps):
        # predict next char  這是遞歸網絡的序列預測過程
        yhat,h_state, c_state = infdec.predict([target_seq, h_state, c_state])   # 獲得循環地推的target_seq初始值，不停迭代產生新值
        # store prediction
        output.append(yhat[0, 0, :])
        # update state
        # update target sequence
        target_seq = yhat
    return array(output)

# decode a one hot encoded string
def one_hot_decode(encoded_seq):
    return [argmax(vector) for vector in encoded_seq]

# configure problem
n_features = 50 + 1
n_steps_in = 6
n_steps_out = 3
# define model
train, infenc, infdec = define_models(n_features, n_features, 128)
train.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['acc'])  # 這一層需要被編譯
# generate training dataset
X1, X2, y = get_dataset(n_steps_in, n_steps_out, n_features, 100000)
print(X1.shape,X2.shape,y.shape)
# train model
train.fit([X1, X2], y, epochs=1)
# evaluate LSTM
total, correct = 100, 0
# for _ in range(total):
#     X1, X2, y = get_dataset(n_steps_in, n_steps_out, n_features, 1)
#     target = predict_sequence(infenc, infdec, X1, n_steps_out, n_features)
#     if array_equal(one_hot_decode(y[0]), one_hot_decode(target)):
#         correct += 1
# print('Accuracy: %.2f%%' % (float(correct)/float(total)*100.0))
# spot check some examples
for _ in range(10):
    X1, X2, y = get_dataset(n_steps_in, n_steps_out, n_features, 1)
    target = predict_sequence(infenc, infdec, X1, n_steps_out, n_features)
    print('X=%s y=%s, yhat=%s' % (one_hot_decode(X1[0]), one_hot_decode(y[0]), one_hot_decode(target)))