【如何训练一个中英翻译模型】LSTM机器翻译seq2seq字符编码（一）_机器翻译模型的训练方式

系列文章

【如何训练一个中英翻译模型】LSTM机器翻译seq2seq字符编码（一）
【如何训练一个中英翻译模型】LSTM机器翻译模型训练与保存（二）
【如何训练一个中英翻译模型】LSTM机器翻译模型部署（三）
【如何训练一个中英翻译模型】LSTM机器翻译模型部署之onnx（python）（四）

训练一个翻译模型，我们需要一份数据集，以cmn.txt数据集为例：
取前两行数据来看看，如下：

Wait!	等等！
Hello!	你好。
1
2

对于中译英，我们希望让网络输入：“Wait!”，输出：“等等！”，输入：“Hello!”，输出：“你好。”
那么问题来了，这样的数据要如何输入网络进行训练呢？
显然需要进行编码，大白话说就是用“0101…”这样的数据来表示这些文字（为了方便表达，后面称为字符）。
先假设，我们的训练数据只取第一行，那就是只有“Wait! 等等！”，那么，我们开始对它进行编码，读取cmn.txt文件，并取第一行数据中英文分别保存在target_texts ，input_texts，,然后将所有的字符取出来，中英文字符并分别保存在target_characters ，input_characters

input_texts = [] # 保存英文数据集
target_texts = [] # 保存中文数据集
input_characters = set() # 保存英文字符，比如a,b，c
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)]: # 遍历每一行数据集（用min来防止越出）
    input_text, target_text = line.split('\t') # 分割中英文
    # We use "tab" as the "start sequence" character
    # for the targets, and "\n" as "end sequence" character.
    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)
            
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('Number of samples:', len(input_texts))
print('Number of unique input tokens:', num_encoder_tokens)
print('Number of unique output tokens:', num_decoder_tokens)
print('Max sequence length for inputs:', max_encoder_seq_length)
print('Max sequence length for outputs:', max_decoder_seq_length)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

可以得到这样的数据：

#原始数据：Wait!	等等！

input_texts =  ['Wait!'] 
target_texts =  ['\t等等！\n']

input_characters = ['!', 'W', 'a', 'i', 't']
target_characters = ['\t', '\n', '等', '！']
1
2
3
4
5
6
7

然后我们就可以开始编码啦。
先对input_characters 于target_characters 进行编号，也就是

['!', 'W', 'a', 'i', 't']
 0    1    2   3  4
['\t', '\n', '等', '！']
  0    1    2    3  
1
2
3
4

代码如下：

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)])
1
2

编号完之后就是：

input_token_index =
 {
   '!':   0,
   'W': 1,
   'a':   2,
   'i':    3,
   't':    4
 }
target_token_index =
 {
   '\t':  0,
   '\n': 1,
   '等': 2,
   '！': 3
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

有了input_token_index 与target_token_index ，我们就可以开始对输入输出进行编码，先来看输入。
假设我们的输入只有一个字符W，那么根据input_token_index 对W进行编码就如下：

可看到W用向量01000表示了，只有W的那个位置被标为1，其余标为0
依次类推对Wait!进行编码，结果如下：

对中文进行编码也是一样的操作：

因此输入输出分别可以用encoder_input_data与decoder_input_data这两个矩阵来表示了，这两个矩阵里面的值是一堆01

['!', 'W', 'a', 'i', 't']
encoder_input_data
[[[0. 1. 0. 0. 0.]    W
  [0. 0. 1. 0. 0.]    a
  [0. 0. 0. 1. 0.]    i
  [0. 0. 0. 0. 1.]    t
  [1. 0. 0. 0. 0.]]]  !
  
target_texts通过编码得到
['\t', '\n', '等', '！']
decoder_input_data
[[[1. 0. 0. 0.]      \t
  [0. 0. 1. 0.]      等
  [0. 0. 1. 0.]      等
  [0. 0. 0. 1.]      !
  [0. 1. 0. 0.]]]    \n
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

为了进一步说明，我们这时候将训练集改为2，也就是num_samples = 2，那么

input_texts =  ['Wait!', 'Hello!']
target_texts = ['\t等等！\n', '\t你好。\n']
input_characters = ['!', 'H', 'W', 'a', 'e', 'i', 'l', 'o', 't']
target_characters = ['\t', '\n', '。', '你', '好', '等', '！']
1
2
3
4

分别对输入输出的内容进行编码，可得到：

encoder_input_data = 
[[[0. 0. 1. 0. 0. 0. 0. 0. 0.]  # 第一句 Wait!
  [0. 0. 0. 1. 0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 1. 0. 0. 0.]
  [0. 0. 0. 0. 0. 0. 0. 0. 1.]
  [1. 0. 0. 0. 0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 0. 0. 0. 0.]]

 [[0. 1. 0. 0. 0. 0. 0. 0. 0.]  # 第二句 Hello
  [0. 0. 0. 0. 1. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 0. 1. 0. 0.]
  [0. 0. 0. 0. 0. 0. 1. 0. 0.]
  [0. 0. 0. 0. 0. 0. 0. 1. 0.]
  [1. 0. 0. 0. 0. 0. 0. 0. 0.]]]

decoder_input_data = 
[[[1. 0. 0. 0. 0. 0. 0.]    # 第一句 \t等等！\n
  [0. 0. 0. 0. 0. 1. 0.]
  [0. 0. 0. 0. 0. 1. 0.]
  [0. 0. 0. 0. 0. 0. 1.]
  [0. 1. 0. 0. 0. 0. 0.]]

 [[1. 0. 0. 0. 0. 0. 0.]    # 第二句 \t你好。\n
  [0. 0. 0. 1. 0. 0. 0.]
  [0. 0. 0. 0. 1. 0. 0.]
  [0. 0. 1. 0. 0. 0. 0.]
  [0. 1. 0. 0. 0. 0. 0.]]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

到这里，我们就清楚了这些文字用向量是怎么表示的，有了向量我们可以进行计算，也就是可以搭建一个网络来训练这些数据了，这个网络的输入是一堆0 1矩阵，输出也是一堆0 1矩阵，输入矩阵在输入字符那里索引得出这个矩阵是什么句子，而输出矩阵在输出字符那里索引得出这个句子代表什么句子，因此我们就可以来训练一个翻译模型了。
总结下来：翻译模型实际上就是输入一个0 1矩阵，输出另外一个0 1矩阵。
句子->输入矩阵->运算->输出矩阵->句子

下面是相应的代码：

# mapping token to index， easily to vectors
# 处理方便进行编码为向量
# {
#   'a': 0,
#   'b': 1,
#   'c': 2,
#   ...
#   'z': 25
# }
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)])

# np.zeros(shape, dtype, order)
# shape is an tuple, in here 3D
encoder_input_data = np.zeros( # (12000, 32, 73) （数据集长度、句子长度、字符数量）
    (len(input_texts), max_encoder_seq_length, num_encoder_tokens),
    dtype='float32')
decoder_input_data = np.zeros( # (12000, 22, 2751)
    (len(input_texts), max_decoder_seq_length, num_decoder_tokens),
    dtype='float32')
decoder_target_data = np.zeros( # (12000, 22, 2751)
    (len(input_texts), max_decoder_seq_length, num_decoder_tokens),
    dtype='float32')

# 遍历输入文本（input_texts）和目标文本（target_texts）中的每个字符，
# 并将它们转换为数值张量以供深度学习模型使用。
#编码如下
#我，你，他，这，国，是，家，人，中
#1  0  0   0  1   1  0   1  1，我是中国人
#1  0   1  0  0   1  1   1  0，他是我家人
# input_texts contain all english sentences
# output_texts contain all chinese sentences
# zip('ABC','xyz') ==> Ax By Cz, looks like that
# the aim is: vectorilize text, 3D
# zip(input_texts, target_texts)成对取出输入输出，比如input_text = 你好，target_text = you good

for i, (input_text, target_text) in enumerate(zip(input_texts, target_texts)):
    for t, char in enumerate(input_text):
        # 3D vector only z-index has char its value equals 1.0
        encoder_input_data[i, t, input_token_index[char]] = 1.
    for t, char in enumerate(target_text):
        # decoder_target_data is ahead of decoder_input_data by one timestep
        decoder_input_data[i, t, target_token_index[char]] = 1.
        if t > 0:
            # decoder_target_data will be ahead by one timestep
            # and will not include the start character.
            # igone t=0 and start t=1, means
            decoder_target_data[i, t - 1, target_token_index[char]] = 1.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

在进行模型推理的时候，你同样需要相同的一份input_token_index 与target_token_index ，那么就需要将input_characters与target_characters保存下来，在推理之前，将你输入的内容进行编码，因为只有同一份位置编码，你的网络才能认识，要不然全乱套了，下面是将input_characters与target_characters保存为txt与读取的方法：

# 将 input_characters保存为 input_words.txt 文件
with open('input_words.txt', 'w', newline='') as f:
    for char in input_characters:
        if char == '\t':
            f.write('\\t\n')
        elif char == '\n':
            f.write('\\n\n')
        else:
            f.write(char + '\n')


# 将 target_characters保存为 target_words.txt 文件
with open('target_words.txt', 'w', newline='') as f:
    for char in target_characters:
        if char == '\t':
            f.write('\\t\n')
        elif char == '\n':
            f.write('\\n\n')
        else:
            f.write(char + '\n')


# 从 input_words.txt 文件中读取字符串
with open('input_words.txt', 'r') as f:
    input_words = f.readlines()
    input_characters = [line.rstrip('\n') for line in input_words]

# 从 target_words.txt 文件中读取字符串
with open('target_words.txt', 'r', newline='') as f:
    target_words = [line.strip() for line in f.readlines()]
    target_characters = [char.replace('\\t', '\t').replace('\\n', '\n') for char in target_words]


#字符处理，以方便进行编码
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)])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36