十分鐘搞定Keras序列到序列學習(附代碼實現)">十分鐘搞定Keras序列到序列學習(附代碼實現)

如何在 Keras 中實現 RNN 序列到序列學習?本文中,作者將嘗試對這一問題做出簡短解答;本文預設你已有一些循環網絡和 Keras 的使用經驗。

GitHub:https://github.com/fchollet/keras/blob/master/examples/lstm_seq2seq.py

什么是序列到序列學習?

序列到序列學習(Seq2Seq)是指訓練模型從而把一個域的序列(比如英語語句)轉化為另一個域的序列(比如法語中的對應語句)。

"the cat sat on the mat" -> [Seq2Seq model] -> "le chat etait assis sur le tapis"

Seq2Seq 可用于機器翻譯或者省去問題回答——通常來講,它可以隨時生成文本。完成這一任務有很多方式,比如 RNN 或一維卷積。本文只介紹 RNN。

次要案例:當輸入序列和輸出序列長度相同

當輸入序列和輸出序列長度相同時,你可以通過 Keras LSTM 或者 GRU 層(或者其中的堆棧)簡單地實現模型。這一實例腳本中的案例展示了如何教會 RNN 學習添加被編碼為字符串的數字:

一般案例:標準的 Seq2Seq

一般情況下,輸入序列和輸出序列有不同的長度(比如機器翻譯)。這就需要一個更高級的設置,尤其在沒有進一步語境的「序列到序列模型」時。下面是其工作原理

  • 一個 RNN 層(或其中的堆棧)作為「編碼器」:它處理輸入序列并反饋其內部狀態。注意我們拋棄了編碼器 RNN 的輸出,只恢復其狀態。該狀態在下一步中充當解碼器的「語境」。
  • 另一個 RNN 層作為「解碼器」:在給定目標序列先前字母的情況下,它被訓練以預測目標序列的下一個字符。具體講,它被訓練把目標序列轉化為相同序列,但接下來被一個時間步抵消,這一訓練過程在語境中被稱為「teacher forcing」。更重要的是,編碼器把其狀態向量用作初始狀態,如此編碼器獲得了其將要生成的信息。實際上,在給定 targets[...t] 的情況下,解碼器學習生成 targets[t+1...],前提是在輸入序列上。

在推理模式中,即當要解碼未知的輸入序列,我們完成了一個稍微不同的處理:

  1. 把輸入序列編碼進狀態向量
  2. 從大小為 1 的目標序列開始
  3. 饋送狀態向量和 1 個字符的目標序列到解碼器從而為下一字符生成預測
  4. 通過這些預測采樣下一個字符(我們使用 argmax)
  5. 把采樣的字符附加到目標序列
  6. 不斷重復直至我們生成序列最后的字符或者達到字符的極限

相同的處理也可被用于訓練沒有「teacher forcing」的 Seq2Seq 網絡,即把解碼器的預測再注入到解碼器之中。

一個 Keras 實例

讓我們用實際的代碼演示一下這些想法。

對于實例實現,我們將使用一對英語語句及其法語翻譯的數據集,你可以從 http://www.manythings.org/anki/下載它,文件的名稱是 fra-eng.zip。我們將會實現一個字符級別的序列到序列模型,逐個字符地處理這些輸入并生成輸出。另一個選擇是單詞級別的模型,它對機器學習更常用。在本文最后,你會發現通過嵌入層把我們的模型轉化為單詞級別模型的一些注釋。

這是實例的全部腳本:https://github.com/fchollet/keras/blob/master/examples/lstm_seq2seq.py。

下面是這一過程的總結:

1. 把語句轉化為 3 個 Numpy 數組 encoder_input_data、decoder_input_data、decoder_target_data:

  • encoder_input_data 是一個形態的 3D 數組(num_pairs, max_english_sentence_length, num_english_characters),包含一個英語語句的獨熱向量化。
  • decoder_input_data 是一個形態的 3D 數組(num_pairs, max_french_sentence_length, num_french_characters),包含一個法語語句的獨熱向量化。
  • decoder_target_data 與 decoder_input_data 相同,但是被一個時間步抵消。decoder_target_data[:, t, :] 與 decoder_input_data[:, t + 1, :] 相同。

2. 在給定 encoder_input_data 和 decoder_input_data 的情況下,訓練一個基本的基于 LSTM 的 Seq2Seq 模型以預測 decoder_target_data。我們的模型使用 teacher forcing。

3. 解碼一些語句以檢查模型正在工作。

由于訓練過程和推理過程(解碼語句)相當不同,我們使用了不同的模型,雖然兩者具有相同的內在層。這是我們的模型,它利用了 Keras RNN 的 3 個關鍵功能:

  • return_state 構造函數參數配置一個 RNN 層以反饋列表,其中第一個是其輸出,下一個是內部的 RNN 狀態。這被用于恢復編碼器的狀態。
  • inital_state 調用參數指定一個 RNN 的初始狀態,這被用于把編碼器狀態作為初始狀態傳遞至解碼器。
  • return_sequences 構造函數參數配置一個 RNN 反饋輸出的全部序列。這被用在解碼器中。
from keras.models import Model
from keras.layers import Input, LSTM, Dense
# Define an input sequence and process it.
encoder_inputs = Input(shape=(None, num_encoder_tokens))
encoder = LSTM(latent_dim, return_state=True)
encoder_outputs, state_h, state_c = encoder(encoder_inputs)
# We discard `encoder_outputs` and only keep the states.
encoder_states = [state_h, state_c]
# Set up the decoder, using `encoder_states` as initial state.
decoder_inputs = Input(shape=(None, num_decoder_tokens))
# We set up our decoder to return full output sequences,
# and to return internal states as well. We don't use the
# return states in the training model, but we will use them in inference.
decoder_lstm = LSTM(latent_dim, return_sequences=True, return_state=True)
decoder_outputs, _, _ = decoder_lstm(decoder_inputs,
                                    initial_state=encoder_states)
decoder_dense = Dense(num_decoder_tokens, activation='softmax')
decoder_outputs = decoder_dense(decoder_outputs)
# Define the model that will turn
# `encoder_input_data` & `decoder_input_data` into `decoder_target_data`
model = Model([encoder_inputs, decoder_inputs], decoder_outputs)

我們用這兩行代碼訓練模型,同時在 20% 樣本的留存集中監測損失。

# Run training
model.compile(optimizer='rmsprop', loss='categorical_crossentropy')
model.fit([encoder_input_data, decoder_input_data], decoder_target_data,
         batch_size=batch_size,
         epochs=epochs,
         validation_split=0.2)

大約 1 小時后在 MacBook CPU 上,我們已準備好做推斷。為了解碼測試語句,我們將重復:

  • 編碼輸入語句,檢索初始解碼器狀態。
  • 用初始狀態運行一步解碼器,以「序列開始」為目標。輸出即是下一個目標字符。
  • 附加預測到的目標字符并重復。

這是我們的推斷設置:

encoder_model = Model(encoder_inputs, encoder_states)
decoder_state_input_h = Input(shape=(latent_dim,))
decoder_state_input_c = Input(shape=(latent_dim,))
decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c]
decoder_outputs, state_h, state_c = decoder_lstm(
   decoder_inputs, initial_state=decoder_states_inputs)
decoder_states = [state_h, state_c]
decoder_outputs = decoder_dense(decoder_outputs)
decoder_model = Model(
   [decoder_inputs] + decoder_states_inputs,
   [decoder_outputs] + decoder_states)

我們使用它實現上述推斷循環(inference loop):

def decode_sequence(input_seq):
   # Encode the input as state vectors.
   states_value = http://www.tuicool.com/articles/encoder_model.predict(input_seq)
   # Generate empty target sequence of length 1.
   target_seq = np.zeros((1, 1, num_decoder_tokens))
   # Populate the first character of target sequence with the start character.
   target_seq[0, 0, target_token_index['\t']] = 1.
   # Sampling loop for a batch of sequences
   # (to simplify, here we assume a batch of size 1).
   stop_condition = False
   decoded_sentence = ''
   while not stop_condition:
       output_tokens, h, c = decoder_model.predict(
           [target_seq] + states_value)
       # Sample a token
       sampled_token_index = np.argmax(output_tokens[0, -1, :])
       sampled_char = reverse_target_char_index[sampled_token_index]
       decoded_sentence += sampled_char
       # Exit condition: either hit max length
       # or find stop character.
       if (sampled_char == '\n' or
          len(decoded_sentence) > max_decoder_seq_length):
           stop_condition = True
       # update the target sequence (of length 1).
       target_seq = np.zeros((1, 1, num_decoder_tokens))
       target_seq[0, 0, sampled_token_index] = 1.
       # Update states
       states_value = http://www.tuicool.com/articles/[h, c]
   return decoded_sentence

我們得到了一些不錯的結果——這在意料之中,因為我們解碼的樣本來自訓練測試。

Input sentence: Be nice.
Decoded sentence: Soyez gentil !
-
Input sentence: Drop it!
Decoded sentence: Laissez tomber !
-
Input sentence: Get out!
Decoded sentence: Sortez?!

這就是我們的十分鐘入門 Keras 序列到序列模型教程。完整代碼詳見 GitHub:https://github.com/fchollet/keras/blob/master/examples/lstm_seq2seq.py。

常見問題

1. 我想使用 GRU 層代替 LSTM,應該怎么做?

這實際上變簡單了,因為 GRU 只有一個狀態,而 LSTM 有兩個狀態。這是使用 GRU 層適應訓練模型的方法:

encoder_inputs = Input(shape=(None, num_encoder_tokens))
encoder = GRU(latent_dim, return_state=True)
encoder_outputs, state_h = encoder(encoder_inputs)
decoder_inputs = Input(shape=(None, num_decoder_tokens))
decoder_gru = GRU(latent_dim, return_sequences=True)
decoder_outputs = decoder_gru(decoder_inputs, initial_state=state_h)
decoder_dense = Dense(num_decoder_tokens, activation='softmax')
decoder_outputs = decoder_dense(decoder_outputs)
model = Model([encoder_inputs, decoder_inputs], decoder_outputs)

2. 我想使用整數序列的單詞級別模型,應該怎么做?

如果你的輸入是整數序列(如按詞典索引編碼的單詞序列),你可以通過 Embedding 層嵌入這些整數標記。方法如下:

# Define an input sequence and process it.
encoder_inputs = Input(shape=(None,))
x = Embedding(num_encoder_tokens, latent_dim)(encoder_inputs)
x, state_h, state_c = LSTM(latent_dim,
                          return_state=True)(x)
encoder_states = [state_h, state_c]
# Set up the decoder, using `encoder_states` as initial state.
decoder_inputs = Input(shape=(None,))
x = Embedding(num_decoder_tokens, latent_dim)(decoder_inputs)
x = LSTM(latent_dim, return_sequences=True)(x, initial_state=encoder_states)
decoder_outputs = Dense(num_decoder_tokens, activation='softmax')(x)
# Define the model that will turn
# `encoder_input_data` & `decoder_input_data` into `decoder_target_data`
model = Model([encoder_inputs, decoder_inputs], decoder_outputs)
# Compile & run training
model.compile(optimizer='rmsprop', loss='categorical_crossentropy')
# Note that `decoder_target_data` needs to be one-hot encoded,
# rather than sequences of integers like `decoder_input_data`!
model.fit([encoder_input_data, decoder_input_data], decoder_target_data,
         batch_size=batch_size,
         epochs=epochs,
         validation_split=0.2)

3. 如果我不想使用「teacher forcing」,應該怎么做?

一些案例中可能不能使用 teacher forcing,因為你無法獲取完整的目標序列,比如,在線訓練非常長的語句,則緩沖完成輸入-目標語言對是不可能的。在這種情況下,你要通過將解碼器的預測重新注入解碼器輸入進行訓練,就像我們進行推斷時所做的那樣。

你可以通過構建硬編碼輸出再注入循環(output reinjection loop)的模型達到該目標:

from keras.layers import Lambda
from keras import backend as K
# The first part is unchanged
encoder_inputs = Input(shape=(None, num_encoder_tokens))
encoder = LSTM(latent_dim, return_state=True)
encoder_outputs, state_h, state_c = encoder(encoder_inputs)
states = [state_h, state_c]
# Set up the decoder, which will only process one timestep at a time.
decoder_inputs = Input(shape=(1, num_decoder_tokens))
decoder_lstm = LSTM(latent_dim, return_sequences=True, return_state=True)
decoder_dense = Dense(num_decoder_tokens, activation='softmax')
all_outputs = []
inputs = decoder_inputs
for _ in range(max_decoder_seq_length):
   # Run the decoder on one timestep
   outputs, state_h, state_c = decoder_lstm(inputs,
                                            initial_state=states)
   outputs = decoder_dense(outputs)
   # Store the current prediction (we will concatenate all predictions later)
   all_outputs.append(outputs)
   # Reinject the outputs as inputs for the next loop iteration
   # as well as update the states
   inputs = outputs
   states = [state_h, state_c]
# Concatenate all predictions
decoder_outputs = Lambda(lambda x: K.concatenate(x, axis=1))(all_outputs)
# Define and compile model as previously
model = Model([encoder_inputs, decoder_inputs], decoder_outputs)
model.compile(optimizer='rmsprop', loss='categorical_crossentropy')
# Prepare decoder input data that just contains the start character
# Note that we could have made it a constant hard-coded in the model
decoder_input_data = http://www.tuicool.com/articles/np.zeros((num_samples, 1, num_decoder_tokens))
decoder_input_data[:, 0, target_token_index['\t']] = 1.
# Train model as previously
model.fit([encoder_input_data, decoder_input_data], decoder_target_data,
         batch_size=batch_size,
         epochs=epochs,
         validation_split=0.2)
贊 (0) 評論 分享 ()

福彩30选5