睿智的seq2seq模型2——利用seq2seq模型實現英文到法文的翻譯

學習前言

快樂學習新知識，seq2seq還是很重要的！

seq2seq簡要介紹

seq2seq屬於encoder-decoder結構的一種。
seq2seq的encoder是一個常見的循環神經網絡，可以使用LSTM或者RNN，當輸入一個字符串的時候，可以對其進行特徵提取，獲得語義編碼C。

而decoder則將encoder得到的編碼C作爲初始狀態輸入到decoder的RNN中，得到輸出序列。

語義編碼C是輸入內容的特徵集合體，decoder可以講這個特徵集合體解碼成輸出序列。

英文翻譯到法文的思路

1、對英文進行特徵提取

將英文按順序輸入到LSTM中，LSTM會對英文進行特徵提取。

我們知道LSTM存在兩個重要的內容

一個是單元狀態c、一個是輸出值h。

LSTM對英文進行特徵提取後，便會得到單元狀態c和輸出值h，這兩者代表了輸入英文的特徵。

實現代碼爲：

encoder_inputs = Input(shape=(None, num_encoder_tokens))

encoder_outputs, state_h, state_c = LSTM(latent_dim, return_state=True)(encoder_inputs)

2、將提取到的特徵傳入到decoder

通過第一步，我們可以獲取到單元狀態c和輸出值h，這兩者代表了輸入英文的特徵。

這兩者會作爲decoder的初始狀態傳入到decoder的LSTM中。

3、將"\t"作爲起始符預測第一個字母

當我們將單元狀態c和輸出值h作爲初始值傳入到decoder的LSTM中時。

seq2seq實現翻譯的話需要一個字母接着一個字母往下預測，一般來說起始的符號是"\t"，通過"\t"預測出第一個字母。

4、逐個字母向後傳遞進行預測

接下來就是將O作爲下一個輸入，將STEP1獲得的單元狀態h和輸出值h作爲初始狀態傳入到下一次的預測中，完成預測。

以此類推。
以此類推，當出現"\n"的時候，表示結尾了！

全部代碼實現

訓練集在這裏下載：
http://www.manythings.org/anki/fra-eng.zip
英文到法文的翻譯可通過如下的代碼實現。

from __future__ import print_function

from keras.models import Model
from keras.layers import Input, LSTM, Dense,TimeDistributed
import numpy as np
import keras.backend as K
def get_dataset(data_path, num_samples):
    input_texts = []
    target_texts = []

    input_characters = set()
    target_characters = set()
    with open(data_path, 'r', encoding='utf-8') as f:
        lines = f.read().split('\n')
    for line in lines[: min(num_samples, len(lines) - 1)]:
        input_text, target_text, _ = line.split('\t')
        # 用tab作用序列的開始，用\n作爲序列的結束
        target_text = '\t' + target_text + '\n'

        input_texts.append(input_text)
        target_texts.append(target_text)
        
        for char in input_text:
            if char not in input_characters:
                input_characters.add(char)
        for char in target_text:
            if char not in target_characters:
                target_characters.add(char)
    return input_texts,target_texts,input_characters,target_characters


#------------------------------------------#
#   init初始化部分
#------------------------------------------#
# 每一次輸入64個batch
batch_size = 64
# 訓練一百個世代
epochs = 100
# 256維特徵向量
latent_dim = 256
# 一共10000個樣本
num_samples = 10000

# 讀取數據集
data_path = 'fra.txt'

# 獲取數據集
# 其中input_texts爲輸入的英文字符串
# target_texts爲對應的法文字符串

# input_characters用到的所有輸入字符,如a,b,c,d,e,……,.,!等
# target_characters用到的所有輸出字符
input_texts,target_texts,input_characters,target_characters = get_dataset(data_path, num_samples)

# 對字符進行排序
input_characters = sorted(list(input_characters))
target_characters = sorted(list(target_characters))
# 計算共用到了什麼字符
num_encoder_tokens = len(input_characters)
num_decoder_tokens = len(target_characters)
# 計算出最長的序列是多長
max_encoder_seq_length = max([len(txt) for txt in input_texts])
max_decoder_seq_length = max([len(txt) for txt in target_texts])

print('一共有多少訓練樣本：', len(input_texts))
print('多少個英文字母：', num_encoder_tokens)
print('多少個法文字母：', num_decoder_tokens)
print('最大英文序列:', max_encoder_seq_length)
print('最大法文序列:', max_decoder_seq_length)

# 建立字母到數字的映射
input_token_index = dict(
    [(char, i) for i, char in enumerate(input_characters)])
target_token_index = dict(
    [(char, i) for i, char in enumerate(target_characters)])

#---------------------------------------------------------------------------#

#--------------------------------------#
#   改變數據集的格式
#--------------------------------------#
encoder_input_data = np.zeros(
    (len(input_texts), max_encoder_seq_length, num_encoder_tokens),
    dtype='float32')
decoder_input_data = np.zeros(
    (len(input_texts), max_decoder_seq_length, num_decoder_tokens),
    dtype='float32')
decoder_target_data = np.zeros(
    (len(input_texts), max_decoder_seq_length, num_decoder_tokens),
    dtype='float32')


for i, (input_text, target_text) in enumerate(zip(input_texts, target_texts)):
    # 爲末尾加上" "空格
    for t, char in enumerate(input_text):
        encoder_input_data[i, t, input_token_index[char]] = 1.
    encoder_input_data[i, t + 1:, input_token_index[' ']] = 1.
    # 相當於前一個內容的識別結果，作爲輸入，傳入到解碼網絡中
    for t, char in enumerate(target_text):
        decoder_input_data[i, t, target_token_index[char]] = 1.
        if t > 0:
            # decoder_target_data不包括第一個tab
            decoder_target_data[i, t - 1, target_token_index[char]] = 1.
    decoder_input_data[i, t + 1:, target_token_index[' ']] = 1.
    decoder_target_data[i, t:, target_token_index[' ']] = 1.
#---------------------------------------------------------------------------#


encoder_inputs = Input(shape=(None, num_encoder_tokens))

encoder_outputs, state_h, state_c = LSTM(latent_dim, return_state=True)(encoder_inputs)

encoder_states = [state_h, state_c]

decoder_inputs = Input(shape=(None, num_decoder_tokens))

decoder_outputs, _, _ = LSTM(latent_dim, return_sequences=True, return_state=True)(decoder_inputs,initial_state=encoder_states)

decoder_outputs = TimeDistributed(Dense(num_decoder_tokens, activation='softmax'))(decoder_outputs)

model = Model([encoder_inputs, decoder_inputs], decoder_outputs)

# 開始訓練
model.compile(optimizer='rmsprop', loss='categorical_crossentropy',
              metrics=['accuracy'])
model.fit([encoder_input_data, decoder_input_data], decoder_target_data,
          batch_size=batch_size,
          epochs=epochs,
          validation_split=0.2)
# 保存模型
model.save('out.h5')
K.clear_session()

encoder_inputs = Input(shape=(None, num_encoder_tokens))

encoder_outputs, state_h, state_c = LSTM(latent_dim, return_state=True)(encoder_inputs)
encoder_states = [state_h, state_c]
encoder_model = Model(encoder_inputs, encoder_states)
encoder_model.load_weights("out.h5",by_name=True)
encoder_model.summary()

decoder_inputs = Input(shape=(None, num_decoder_tokens))
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 = LSTM(latent_dim, return_sequences=True,
                                        return_state=True)(decoder_inputs, initial_state=decoder_states_inputs)

decoder_states = [state_h, state_c]

decoder_outputs = TimeDistributed(Dense(num_decoder_tokens, activation='softmax'))(decoder_outputs)
decoder_model = Model(
    [decoder_inputs] + decoder_states_inputs,
    [decoder_outputs] + decoder_states)
decoder_model.load_weights("out.h5",by_name=True)
# 建立序號到字母的映射
reverse_input_char_index = dict(
    (i, char) for char, i in input_token_index.items())
reverse_target_char_index = dict(
    (i, char) for char, i in target_token_index.items())


def decode_sequence(input_seq):
    states_value = encoder_model.predict(input_seq)
    target_seq = np.zeros((1, 1, num_decoder_tokens))
    target_seq[0, 0, target_token_index['\t']] = 1.

    stop_condition = False
    decoded_sentence = ''
    while not stop_condition:
        # 以\t爲開頭，一個一個向後預測
        output_tokens, h, c = decoder_model.predict(
            [target_seq] + states_value)

        sampled_token_index = np.argmax(output_tokens[0, -1, :])
        sampled_char = reverse_target_char_index[sampled_token_index]
        decoded_sentence += sampled_char
        # 如果達到結尾
        if (sampled_char == '\n' or len(decoded_sentence) > max_decoder_seq_length):
            stop_condition = True

        states_value = [h, c]
        target_seq = np.zeros((1, 1, num_decoder_tokens))
        target_seq[0, 0, sampled_token_index] = 1.


    return decoded_sentence


for seq_index in range(100):
    input_seq = np.expand_dims(encoder_input_data[seq_index],axis=0)
    decoded_sentence = decode_sequence(input_seq)
    print('-')
    print('Input sentence:', input_texts[seq_index])
    print('Decoded sentence:', decoded_sentence)

實現效果：

Input sentence: Call us.
Decoded sentence: Appellez-le.

-
Input sentence: Call us.
Decoded sentence: Appellez-le.

-
Input sentence: Come in.
Decoded sentence: Viens siti !

-
Input sentence: Come in.
Decoded sentence: Viens siti !