第N11周：seq2seq翻译实战-Pytorch复现

使命：
●为解码器添加上注意力机制
一、前期预备工作

1. from __future__ import unicode_literals, print_function, division
2. from io import open
3. import unicodedata
4. import string
5. import re
6. import random
8. import torch
9. import torch.nn as nn
10. from torch import optim
11. import torch.nn.functional as F
13. device = torch.device("cuda" if torch.cuda.is_available() else "cpu
14. ")
15. print(device)

复制代码

代码输出

1. cpu

复制代码

• 搭建语言类
  

1. SOS_token = 0
2. EOS_token = 1
4. # 语言类，方便对语料库进行操作
5. class Lang:
6.     def __init__(self, name):
7.         self.name = name
8.         self.word2index = {}
9.         self.word2count = {}
10.         self.index2word = {0: "SOS", 1: "EOS"}
11.         self.n_words    = 2  # Count SOS and EOS
13.     def addSentence(self, sentence):
14.         for word in sentence.split(' '):
15.             self.addWord(word)
17.     def addWord(self, word):
18.         if word not in self.word2index:
19.             self.word2index[word] = self.n_words
20.             self.word2count[word] = 1
21.             self.index2word[self.n_words] = word
22.             self.n_words += 1
23.         else:
24.             self.word2count[word] += 1

复制代码

• 文本处理处罚函数
  

1. def unicodeToAscii(s):
2.     return ''.join(
3.         c for c in unicodedata.normalize('NFD', s)
4.         if unicodedata.category(c) != 'Mn'
5.     )
7. # 小写化，剔除标点与非字母符号
8. def normalizeString(s):
9.     s = unicodeToAscii(s.lower().strip())
10.     s = re.sub(r"([.!?])", r" \1", s)
11.     s = re.sub(r"[^a-zA-Z.!?]+", r" ", s)
12.     return s

复制代码

• 文件读取函数
  

1. def readLangs(lang1, lang2, reverse=False):
2.     print("Reading lines...")
4.     # 以行为单位读取文件
5.     lines = open('N11/%s-%s.txt'%(lang1,lang2), encoding='utf-8').\
6.             read().strip().split('\n')
8.     # 将每一行放入一个列表中
9.     # 一个列表中有两个元素，A语言文本与B语言文本
10.     pairs = [[normalizeString(s) for s in l.split('\t')] for l in lines]
12.     # 创建Lang实例，并确认是否反转语言顺序
13.     if reverse:
14.         pairs       = [list(reversed(p)) for p in pairs]
15.         input_lang  = Lang(lang2)
16.         output_lang = Lang(lang1)
17.     else:
18.         input_lang  = Lang(lang1)
19.         output_lang = Lang(lang2)
21.     return input_lang, output_lang, pairs

复制代码

.startswith(eng_prefixes) 是字符串方法 startswith() 的调用。它用于查抄一个字符串是否以指定的前缀开始。

1. MAX_LENGTH = 10      # 定义语料最长长度
3. eng_prefixes = (
4.     "i am ", "i m ",
5.     "he is", "he s ",
6.     "she is", "she s ",
7.     "you are", "you re ",
8.     "we are", "we re ",
9.     "they are", "they re "
10. )
12. def filterPair(p):
13.     return len(p[0].split(' ')) < MAX_LENGTH and \
14.            len(p[1].split(' ')) < MAX_LENGTH and p[1].startswith(eng_prefixes)
16. def filterPairs(pairs):
17.     # 选取仅仅包含 eng_prefixes 开头的语料
18.     return [pair for pair in pairs if filterPair(pair)]

复制代码

1. def prepareData(lang1, lang2, reverse=False):
2.     # 读取文件中的数据
3.     input_lang, output_lang, pairs = readLangs(lang1, lang2, reverse)
4.     print("Read %s sentence pairs" % len(pairs))
5.    
6.     # 按条件选取语料
7.     pairs = filterPairs(pairs[:])
8.     print("Trimmed to %s sentence pairs" % len(pairs))
9.     print("Counting words...")
10.    
11.     # 将语料保存至相应的语言类
12.     for pair in pairs:
13.         input_lang.addSentence(pair[0])
14.         output_lang.addSentence(pair[1])
15.         
16.     # 打印语言类的信息   
17.     print("Counted words:")
18.     print(input_lang.name, input_lang.n_words)
19.     print(output_lang.name, output_lang.n_words)
20.     return input_lang, output_lang, pairs
22. input_lang, output_lang, pairs = prepareData('eng', 'fra', True)
23. print(random.choice(pairs))

复制代码

代码输出

1. Reading lines...
2. Read 135842 sentence pairs
3. Trimmed to 10599 sentence pairs
4. Counting words...
5. Counted words:
6. fra 4345
7. eng 2803
8. ['je volerai vers la lune .', 'i m going to fly to the moon .']

复制代码

二、Seq2Seq 模型

• 编码器（Encoder）
  

1. class EncoderRNN(nn.Module):
2.     def __init__(self, input_size, hidden_size):
3.         super(EncoderRNN, self).__init__()
4.         self.hidden_size = hidden_size
5.         self.embedding   = nn.Embedding(input_size, hidden_size)
6.         self.gru         = nn.GRU(hidden_size, hidden_size)
8.     def forward(self, input, hidden):
9.         embedded       = self.embedding(input).view(1, 1, -1)
10.         output         = embedded
11.         output, hidden = self.gru(output, hidden)
12.         return output, hidden
14.     def initHidden(self):
15.         return torch.zeros(1, 1, self.hidden_size, device=device)

复制代码

• 解码器（Decoder）
  

1. class AttnDecoderRNN(nn.Module):
2.     def __init__(self, hidden_size, output_size, dropout_p=0.1, max_length=MAX_LENGTH):
3.         super(AttnDecoderRNN, self).__init__()
4.         self.hidden_size = hidden_size
5.         self.output_size = output_size
6.         self.dropout_p = dropout_p
7.         self.max_length = max_length
9.         self.embedding = nn.Embedding(self.output_size, self.hidden_size)
10.         self.attn = nn.Linear(self.hidden_size * 2, self.max_length)
11.         self.attn_combine = nn.Linear(self.hidden_size * 2, self.hidden_size)
12.         self.dropout = nn.Dropout(self.dropout_p)
13.         self.gru = nn.GRU(self.hidden_size, self.hidden_size)
14.         self.out = nn.Linear(self.hidden_size, self.output_size)
16.     def forward(self, input, hidden, encoder_outputs):
17.         embedded = self.embedding(input).view(1, 1, -1)
18.         embedded = self.dropout(embedded)
20.         attn_weights = F.softmax(
21.             self.attn(torch.cat((embedded[0], hidden[0]), 1)), dim=1)
22.         attn_applied = torch.bmm(attn_weights.unsqueeze(0),
23.                                  encoder_outputs.unsqueeze(0))
25.         output = torch.cat((embedded[0], attn_applied[0]), 1)
26.         output = self.attn_combine(output).unsqueeze(0)
28.         output = F.relu(output)
29.         output, hidden = self.gru(output, hidden)
31.         output = F.log_softmax(self.out(output[0]), dim=1)
32.         return output, hidden, attn_weights
34.     def initHidden(self):
35.         return torch.zeros(1, 1, self.hidden_size, device=device)

复制代码

三、训练

• 数据预处理处罚
  

1. # 将文本数字化，获取词汇index
2. def indexesFromSentence(lang, sentence):
3.     return [lang.word2index[word] for word in sentence.split(' ')]
5. # 将数字化的文本，转化为tensor数据
6. def tensorFromSentence(lang, sentence):
7.     indexes = indexesFromSentence(lang, sentence)
8.     indexes.append(EOS_token)
9.     return torch.tensor(indexes, dtype=torch.long, device=device).view(-1, 1)
11. # 输入pair文本，输出预处理好的数据
12. def tensorsFromPair(pair):
13.     input_tensor  = tensorFromSentence(input_lang, pair[0])
14.     target_tensor = tensorFromSentence(output_lang, pair[1])
15.     return (input_tensor, target_tensor)

复制代码

• 训练函数
  

1. teacher_forcing_ratio = 0.5
3. def train(input_tensor, target_tensor,
4.           encoder, decoder,
5.           encoder_optimizer, decoder_optimizer,
6.           criterion, max_length=MAX_LENGTH):
7.    
8.     # 编码器初始化
9.     encoder_hidden = encoder.initHidden()
10.    
11.     # grad属性归零
12.     encoder_optimizer.zero_grad()
13.     decoder_optimizer.zero_grad()
15.     input_length  = input_tensor.size(0)
16.     target_length = target_tensor.size(0)
17.    
18.     # 用于创建一个指定大小的全零张量（tensor），用作默认编码器输出
19.     encoder_outputs = torch.zeros(max_length, encoder.hidden_size, device=device)
21.     loss = 0
22.    
23.     # 将处理好的语料送入编码器
24.     for ei in range(input_length):
25.         encoder_output, encoder_hidden = encoder(input_tensor[ei], encoder_hidden)
26.         encoder_outputs[ei]            = encoder_output[0, 0]
27.    
28.     # 解码器默认输出
29.     decoder_input  = torch.tensor([[SOS_token]], device=device)
30.     decoder_hidden = encoder_hidden
32.     use_teacher_forcing = True if random.random() < teacher_forcing_ratio else False
33.    
34.     # 将编码器处理好的输出送入解码器
35.     if use_teacher_forcing:
36.         # Teacher forcing: Feed the target as the next input
37.         for di in range(target_length):
38.             decoder_output, decoder_hidden, decoder_attention = decoder(
39.                 decoder_input, decoder_hidden, encoder_outputs)
40.             
41.             loss         += criterion(decoder_output, target_tensor[di])
42.             decoder_input = target_tensor[di]  # Teacher forcing
43.     else:
44.         # Without teacher forcing: use its own predictions as the next input
45.         for di in range(target_length):
46.             decoder_output, decoder_hidden, decoder_attention = decoder(
47.                 decoder_input, decoder_hidden, encoder_outputs)
48.             
49.             topv, topi    = decoder_output.topk(1)
50.             decoder_input = topi.squeeze().detach()  # detach from history as input
52.             loss         += criterion(decoder_output, target_tensor[di])
53.             if decoder_input.item() == EOS_token:
54.                 break
56.     loss.backward()
58.     encoder_optimizer.step()
59.     decoder_optimizer.step()
61.     return loss.item() / target_length

复制代码

在序列天生的使掷中，如机器翻译或文本天生，解码器（decoder）的输入通常是由解码器自己天生的预测结果，即前一个时间步的输出。然而，这种自回归方式大概存在一个问题，即在训练过程中，解码器大概会产生累积误差，并导致输出与目标序列渐渐偏离。
为了解决这个问题，引入了一种称为"Teacher Forcing"的技术。在训练过程中，Teacher Forcing将目标序列的真实值作为解码器的输入，而不是使用解码器自己的预测结果。这样可以提供更准确的引导信号，帮助解码器更快地学习到精确的输出。
在这段代码中，use_teacher_forcing变量用于确定解码器在训练阶段使用何种策略作为下一个输入。
当use_teacher_forcing为True时，接纳"Teacher Forcing"的策略，即将目标序列中的真实标签作为解码器的下一个输入。而当use_teacher_forcing为False时，接纳"Without Teacher Forcing"的策略，即将解码器自身的预测作为下一个输入。
使用use_teacher_forcing的目的是在训练过程中平衡解码器的预测能力和稳固性。以下是对两种策略的表明：
   

• Teacher Forcing: 在每个时间步（di循环中），解码器的输入都是目标序列中的真实标签。这样做的好处是，解码器可以直接获得精确的输入信息，加速训练速度，并且在训练早期提供更准确的梯度信号，帮助解码器更好地学习。然而，过分依靠目标序列大概会导致模型过于敏感，一旦目标序列中出现错误，大概会在解码器中产生累积的误差。
  
• Without Teacher Forcing: 在每个时间步，解码器的输入是前一个时间步的预测输出。这样做的好处是，解码器必要依靠自身的预测能力来天生下一个输入，从而更好地顺应真实应用场景中大概出现的输入变化。这种策略可以提高模型的稳固性，但大概会导致训练过程更加困难，特殊是在初始阶段。
  

  一样平常来说，Teacher Forcing策略在训练过程中可以帮助模型快速收敛，而Without Teacher Forcing策略则更接近真实应用中的天生场景。通常会使用一定比例的Teacher Forcing，在训练过程中渐渐减小这个比例，以便模型渐渐过渡到更自主的天生模式。
综上所述，通过使用use_teacher_forcing来选择不同的策略，可以在训练解码器时平衡模型的预测能力和稳固性，同时也提供了更灵活的天生模式选择。
   

• topv, topi = decoder_output.topk(1)
  这一行代码使用.topk(1)函数从decoder_output中获取最大的元素及其对应的索引。decoder_output是一个张量（tensor），它包罗了解码器的输出结果，大概是一个概率分布或是其他的数值。.topk(1)函数将返回两个张量：topv和topi。topv是最大的元素值，而topi是对应的索引值。
  
• decoder_input = topi.squeeze().detach() 这一行代码对topi进行处理处罚，以便作为下一个解码器的输入。起首，.squeeze()函数被调用，它的作用是去除张量中维度为1的维度，从而将topi的形状进行压缩。然后，.detach()函数被调用，它的作用是将张量从盘算图中分离出来，使得在后续的盘算中不会对该张量进行梯度盘算。最后，将处理处罚后的张量赋值给decoder_input，作为下一个解码器的输入。
  

1. import time
2. import math
4. def asMinutes(s):
5.     m = math.floor(s / 60)
6.     s -= m * 60
7.     return '%dm %ds' % (m, s)
9. def timeSince(since, percent):
10.     now = time.time()
11.     s = now - since
12.     es = s / (percent)
13.     rs = es - s
14.     return '%s (- %s)' % (asMinutes(s), asMinutes(rs))

复制代码

1. def trainIters(encoder,decoder,n_iters,print_every=1000,
2.                plot_every=100,learning_rate=0.01):
3.    
4.     start = time.time()
5.     plot_losses      = []
6.     print_loss_total = 0  # Reset every print_every
7.     plot_loss_total  = 0  # Reset every plot_every
9.     encoder_optimizer = optim.SGD(encoder.parameters(), lr=learning_rate)
10.     decoder_optimizer = optim.SGD(decoder.parameters(), lr=learning_rate)
11.    
12.     # 在 pairs 中随机选取 n_iters 条数据用作训练集
13.     training_pairs    = [tensorsFromPair(random.choice(pairs)) for i in range(n_iters)]
14.     criterion         = nn.NLLLoss()
16.     for iter in range(1, n_iters + 1):
17.         training_pair = training_pairs[iter - 1]
18.         input_tensor  = training_pair[0]
19.         target_tensor = training_pair[1]
21.         loss = train(input_tensor, target_tensor, encoder,
22.                      decoder, encoder_optimizer, decoder_optimizer, criterion)
23.         print_loss_total += loss
24.         plot_loss_total  += loss
26.         if iter % print_every == 0:
27.             print_loss_avg   = print_loss_total / print_every
28.             print_loss_total = 0
29.             print('%s (%d %d%%) %.4f' % (timeSince(start, iter / n_iters),
30.                                          iter, iter / n_iters * 100, print_loss_avg))
32.         if iter % plot_every == 0:
33.             plot_loss_avg = plot_loss_total / plot_every
34.             plot_losses.append(plot_loss_avg)
35.             plot_loss_total = 0
37.     return plot_losses

复制代码

• 评估
  

1. def evaluate(encoder, decoder, sentence, max_length=MAX_LENGTH):
2.     with torch.no_grad():
3.         input_tensor    = tensorFromSentence(input_lang, sentence)
4.         input_length    = input_tensor.size()[0]
5.         encoder_hidden  = encoder.initHidden()
7.         encoder_outputs = torch.zeros(max_length, encoder.hidden_size, device=device)
9.         for ei in range(input_length):
10.             encoder_output, encoder_hidden = encoder(input_tensor[ei],encoder_hidden)
11.             encoder_outputs[ei]           += encoder_output[0, 0]
13.         decoder_input  = torch.tensor([[SOS_token]], device=device)  # SOS
15.         decoder_hidden = encoder_hidden
17.         decoded_words  = []
18.         decoder_attentions = torch.zeros(max_length, max_length)
20.         for di in range(max_length):
21.             decoder_output, decoder_hidden, decoder_attention = decoder(
22.                 decoder_input, decoder_hidden, encoder_outputs)
23.             
24.             decoder_attentions[di] = decoder_attention.data
25.             topv, topi             = decoder_output.data.topk(1)
26.             
27.             if topi.item() == EOS_token:
28.                 decoded_words.append('<EOS>')
29.                 break
30.             else:
31.                 decoded_words.append(output_lang.index2word[topi.item()])
33.             decoder_input = topi.squeeze().detach()
35.         return decoded_words, decoder_attentions[:di + 1]

复制代码

1. def evaluateRandomly(encoder, decoder, n=5):
2.     for i in range(n):
3.         pair = random.choice(pairs)
4.         print('>', pair[0])
5.         print('=', pair[1])
6.         output_words, attentions = evaluate(encoder, decoder, pair[0])
7.         output_sentence = ' '.join(output_words)
8.         print('<', output_sentence)
9.         print('')

复制代码

四、训练与评估

1. hidden_size   = 256
2. encoder1      = EncoderRNN(input_lang.n_words, hidden_size).to(device)
3. attn_decoder1 = AttnDecoderRNN(hidden_size, output_lang.n_words, dropout_p=0.1).to(device)
5. plot_losses   = trainIters(encoder1, attn_decoder1, 10000, print_every=5000)

复制代码

代码输出

1. 6m 41s (- 6m 41s) (5000 50%) 2.8497
2. 13m 28s (- 0m 0s) (10000 100%) 2.2939

复制代码

1. evaluateRandomly(encoder1, attn_decoder1)

复制代码

代码输出

1. > tu es en grave danger .
2. = you re in serious danger .
3. < you are the of . . <EOS>
5. > il est parfait pour le poste .
6. = he is just right for the job .
7. < he is out to the . . <EOS>
9. > je te quitte demain .
10. = i m leaving you tomorrow .
11. < i am glad to . . <EOS>
13. > c est un auteur .
14. = he s an author .
15. < he s a good . <EOS>
17. > nous sommes des prisonniers .
18. = we re prisoners .
19. < we re in . <EOS>

复制代码

• Loss图
  

1. import matplotlib.pyplot as plt
2. #隐藏警告
3. import warnings
4. warnings.filterwarnings("ignore")               # 忽略警告信息
5. # plt.rcParams['font.sans-serif']    = ['SimHei'] # 用来正常显示中文标签
6. plt.rcParams['axes.unicode_minus'] = False      # 用来正常显示负号
7. plt.rcParams['figure.dpi']         = 100        # 分辨率
9. epochs_range = range(len(plot_losses))
11. plt.figure(figsize=(8, 3))
13. plt.subplot(1, 1, 1)
14. plt.plot(epochs_range, plot_losses, label='Training Loss')
15. plt.legend(loc='upper right')
16. plt.title('Training Loss')
17. plt.show()

复制代码

代码输出

• 可视化注意力
  

1. import matplotlib.pyplot as plt
3. output_words, attentions = evaluate(encoder1, attn_decoder1, "je suis trop froid .")
4. plt.matshow(attentions.numpy())

复制代码

代码输出

1. <matplotlib.image.AxesImage at 0x1f912b9d600>

复制代码

1. import matplotlib.ticker as ticker
2. #隐藏警告
3. import warnings
4. warnings.filterwarnings("ignore")               # 忽略警告信息
6. def showAttention(input_sentence, output_words, attentions):
7.     # Set up figure with colorbar
8.     fig = plt.figure()
9.     ax = fig.add_subplot(111)
10.     cax = ax.matshow(attentions.numpy(), cmap='bone')
11.     fig.colorbar(cax)
13.     # Set up axes
14.     ax.set_xticklabels([''] + input_sentence.split(' ') +
15.                        ['<EOS>'], rotation=90)
16.     ax.set_yticklabels([''] + output_words)
18.     # Show label at every tick
19.     ax.xaxis.set_major_locator(ticker.MultipleLocator(1))
20.     ax.yaxis.set_major_locator(ticker.MultipleLocator(1))
22.     plt.show()
24. def evaluateAndShowAttention(input_sentence):
25.     output_words, attentions = evaluate(
26.         encoder1, attn_decoder1, input_sentence)
27.     print('input =', input_sentence)
28.     print('output =', ' '.join(output_words))
29.     showAttention(input_sentence, output_words, attentions)
32. evaluateAndShowAttention("elle a cinq ans de moins que moi .")
33. evaluateAndShowAttention("elle est trop petit .")
34. evaluateAndShowAttention("je ne crains pas de mourir .")
35. evaluateAndShowAttention("c est un jeune directeur plein de talent .")

复制代码

代码输出（下面的内容全都是代码运行输出的结果）

1. input = elle a cinq ans de moins que moi .
2. output = she s taller than me than me me . .

复制代码

1. input = elle est trop petit .
2. output = she s too old . <EOS>

复制代码

1. input = je ne crains pas de mourir .
2. output = i m not going to . . . <EOS>

复制代码

1. input = c est un jeune directeur plein de talent .
2. output = he s a good at . . <EOS>

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。