• 使用seq2seq架构实现英译法

    e5fcd827ceb04f33b1ba3f49f54fefba.jpeg

    seq2seq介绍 

    模型架构：9e4e8495162c4cb1919afa68ea45933a.png

    Seq2Seq（Sequence-to-Sequence）模型是一种在自然语言处理（NLP）中广泛应用的架构，其核心思想是将一个序列作为输入，并输出另一个序列。这种模型特别适用于机器翻译、聊天机器人、自动文摘等场景，其中输入和输出的长度都是可变的。

    • embedding层在seq2seq模型中起着将离散单词转换为连续向量表示的关键作用，为后续的自然语言处理任务提供了有效的特征输入。 

    数据集 

    下载: https://download.pytorch.org/tutorial/data.zip

    🍸️步骤：

    基于GRU的seq2seq模型架构实现翻译的过程:

    • 导入必备的工具包.
    • 对文件中数据进行处理，满足模型训练要求.
    • 构建基于GRU的编码器和解码
    • 构建模型训练函数，并进行训练
    • 构建模型评估函数，并进行测试以及Attention效果分析

    2e56c3e1f6204fcfbaf53decb45c1c3b.png

    1. # 从io工具包导入open方法
    2. from io import open
    3. # 用于字符规范化
    4. import unicodedata
    5. # 用于正则表达式
    6. import re
    7. # 用于随机生成数据
    8. import random
    9. # 用于构建网络结构和函数的torch工具包
    10. import torch
    11. import torch.nn as nn
    12. import torch.nn.functional as F
    13. # torch中预定义的优化方法工具包
    14. from torch import optim
    15. # 设备选择, 我们可以选择在cuda或者cpu上运行你的代码
    16. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

    数据预处理

    b7e432a96dff4958b39b36b22bc45285.png

    将指定语言中的词汇映射成数值💫

    1. # 起始标志
    2. SOS_token = 0
    3. # 结束标志
    4. EOS_token = 1
    5.  
    6. class Lang:
    7.     def __init__(self, name):
    8.         self.name = name
    9.         self.word2index = {}
    10.         self.index2word = {0: "SOS", 1: "EOS"}
    11.         self.n_words = 2  
    12.  
    13.     def addSentence(self, sentence):
    14.         for word in sentence.split(' '):
    15.             self.addWord(word)
    16.  
    17.  
    18.     def addWord(self, word):
    19.       
    20.         if word not in self.word2index:
    21.             self.word2index[word] = self.n_words
    22.             self.index2word[self.n_words] = words
    23.             self.n_words += 1
    • 测试：实例化参数: 
    1. name = "eng"
    2. sentence = "hello I am Jay"
    3.  
    4. engl = Lang(name)
    5. engl.addSentence(sentence)
    6. print("word2index:", engl.word2index)
    7. print("index2word:", engl.index2word)
    8. print("n_words:", engl.n_words)
    9.  
    10. # 输出
    11. word2index: {'hello': 2, 'I': 3, 'am': 4, 'Jay': 5}
    12. index2word: {0: 'SOS', 1: 'EOS', 2: 'hello', 3: 'I', 4: 'am', 5: 'Jay'}
    13. n_words: 6

     字符规范化💫

    1.  
    2. def unicodeToAscii(s):
    3.     return ''.join(
    4.         c for c in unicodedata.normalize('NFD', s)
    5.         if unicodedata.category(c) != 'Mn'
    6.     )
    7.  
    8.  
    9. def normalizeString(s):
    10.     s = unicodeToAscii(s.lower().strip())
    11.     s = re.sub(r"([.!?])", r" \1", s)
    12.     s = re.sub(r"[^a-zA-Z.!?]+", r" ", s)
    13.     return s

    将文件中的数据加载到内存，实例化类Lang💫

    1. data_path = 'eng-fra.txt'
    2.  
    3. def readLangs(lang1, lang2):
    4.     """读取语言函数, 参数lang1是源语言的名字, 参数lang2是目标语言的名字
    5.        返回对应的class Lang对象, 以及语言对列表"""
    6.     # 从文件中读取语言对并以/n划分存到列表lines中
    7.     lines = open(data_path, encoding='utf-8').read().strip().split('\n')
    8.     # 对lines列表中的句子进行标准化处理，并以\t进行再次划分, 形成子列表, 也就是语言对
    9.     pairs = [[normalizeString(s) for s in l.split('\t')] for l in lines] 
    10.     # 然后分别将语言名字传入Lang类中, 获得对应的语言对象, 返回结果
    11.     input_lang = Lang(lang1)
    12.     output_lang = Lang(lang2)
    13.     return input_lang, output_lang, pairs
    • 测试：输入参数:
    1. lang1 = "eng"
    2. lang2 = "fra"
    3.  
    4. input_lang, output_lang, pairs = readLangs(lang1, lang2)
    5. print("pairs中的前五个:", pairs[:5])
    6.  
    7. # 输出
    8. pairs中的前五个: [['go .', 'va !'], ['run !', 'cours !'], ['run !', 'courez !'], ['wow !', 'ca alors !'], ['fire !', 'au feu !']]

    过滤出符合我们要求的语言对💫

    1. # 设置组成句子中单词或标点的最多个数
    2. MAX_LENGTH = 10
    3.  
    4. eng_prefixes = (
    5.     "i am ", "i m ",
    6.     "he is", "he s ",
    7.     "she is", "she s ",
    8.     "you are", "you re ",
    9.     "we are", "we re ",
    10.     "they are", "they re "
    11. )
    12.  
    13.  
    14. def filterPair(p):
    15.     return len(p[0].split(' ')) < MAX_LENGTH and \
    16.         p[0].startswith(eng_prefixes) and \
    17.         len(p[1].split(' ')) < MAX_LENGTH 
    18.  
    19.  
    20. def filterPairs(pairs):
    21.     return [pair for pair in pairs if filterPair(pair)]

    对以上数据准备函数进行整合💫

    1. def prepareData(lang1, lang2):
    2.  
    3.     input_lang, output_lang, pairs = readLangs(lang1, lang2)
    4.  
    5.     pairs = filterPairs(pairs)
    6.     for pair in pairs:
    7.         input_lang.addSentence(pair[0])
    8.         output_lang.addSentence(pair[1])
    9.     return input_lang, output_lang, pairs

    将语言对转化为模型输入需要的张量💫

    1. def tensorFromSentence(lang, sentence):
    2.     indexes = [lang.word2index[word] for word in sentence.split(' ')]
    3.  
    4.     indexes.append(EOS_token)
    5.     return torch.tensor(indexes, dtype=torch.long, device=device).view(-1, 1)
    6.  
    7.  
    8. def tensorsFromPair(pair):
    9.  
    10.     input_tensor = tensorFromSentence(input_lang, pair[0])
    11.     target_tensor = tensorFromSentence(output_lang, pair[1])
    12.     return (input_tensor, target_tensor)
    • 测试输入：
    1. # 取pairs的第一条
    2. pair = pairs[0]
    3. pair_tensor = tensorsFromPair(pair)
    4. print(pair_tensor)
    5.  
    6. # 输出
    7. (tensor([[2],
    8.         [3],
    9.         [4],
    10.         [1]]), 
    11.  tensor([[2],
    12.         [3],
    13.         [4],
    14.         [5],
    15.         [1]]))

    构建编码器和解码器

    22c77655e7a243bcb6ad3078af321335.png

    构建基于GRU的编码器 

    • “embedding”指的是一个将离散变量（如单词、符号等）转换为连续向量表示的过程或技术
    • “embedded”是embedding过程的输出，即已经通过嵌入矩阵转换后的连续向量。在神经网络中，这些向量将作为后续层的输入。
    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.  
    6.         self.embedding = nn.Embedding(input_size, hidden_size)
    7.         self.gru = nn.GRU(hidden_size, hidden_size)
    8.  
    9.     def forward(self, input, hidden):
    10.         output = self.embedding(input).view(1, 1, -1)
    11.         output, hidden = self.gru(output, hidden)
    12.         return output, hidden
    13.  
    14.     def initHidden(self):
    15.         return torch.zeros(1, 1, self.hidden_size, device=device)
    •  测试：参数：
    1. hidden_size = 25
    2. input_size = 20
    3.  
    4. # pair_tensor[0]代表源语言即英文的句子，pair_tensor[0][0]代表句子中
    5. 的第一个词
    6. input = pair_tensor[0][0]
    7. # 初始化第一个隐层张量，1x1xhidden_size的0张量
    8. hidden = torch.zeros(1, 1, hidden_size)
    9.  
    10. encoder = EncoderRNN(input_size, hidden_size)
    11. encoder_output, hidden = encoder(input, hidden)
    12. print(encoder_output)
    13.  
    14. # 输出
    15. tensor([[[ 1.9149e-01, -2.0070e-01, -8.3882e-02, -3.3037e-02, -1.3491e-01,
    16.           -8.8831e-02, -1.6626e-01, -1.9346e-01, -4.3996e-01,  1.8020e-02,
    17.            2.8854e-02,  2.2310e-01,  3.5153e-01,  2.9635e-01,  1.5030e-01,
    18.           -8.5266e-02, -1.4909e-01,  2.4336e-04, -2.3522e-01,  1.1359e-01,
    19.            1.6439e-01,  1.4872e-01, -6.1619e-02, -1.0807e-02,  1.1216e-02]]],
    20.        grad_fn=)

    构建基于GRU的解码器

    1. class DecoderRNN(nn.Module):
    2.     def __init__(self, hidden_size, output_size):
    3.       
    4.         super(DecoderRNN, self).__init__()
    5.  
    6.         self.hidden_size = hidden_size
    7.         self.embedding = nn.Embedding(output_size, hidden_size)
    8.  
    9.         self.gru = nn.GRU(hidden_size, hidden_size)
    10.         self.out = nn.Linear(hidden_size, output_size)
    11.         self.softmax = nn.LogSoftmax(dim=1)
    12.  
    13.  
    14.     def forward(self, input, hidden):
    15.  
    16.         output = self.embedding(input).view(1, 1, -1)
    17.         output = F.relu(output)
    18.         output, hidden = self.gru(output, hidden)
    19.  
    20.         output = self.softmax(self.out(output[0]))
    21.         return output, hidden
    22.  
    23.     def initHidden(self):
    24.         return torch.zeros(1, 1, self.hidden_size, device=device)

    构建基于GRU和Attention的解码器💥

    💥三个输入：

    • prev_hidden：指上一个时间步解码器的隐藏状态
    • input：input 是当前时间步解码器的输入。在解码的开始阶段，它可能是一个特殊的起始符号。在随后的解码步骤中，input 通常是上一个时间步解码器输出的词（或对应的词向量）。
    • encoder_outputs ：是编码器处理输入序列后生成的一系列输出向量，在基于Attention的解码器中，这些输出向量将作为注意力机制的候选记忆单元，用于计算当前解码步与输入序列中不同位置的相关性。
    1. class AttnDecoderRNN(nn.Module):
    2.     def __init__(self, hidden_size, output_size, dropout_p=0.1, max_length=MAX_LENGTH):
    3.  
    4.         super(AttnDecoderRNN, self).__init__()
    5.         self.hidden_size = hidden_size
    6.         self.output_size = output_size
    7.         self.dropout_p = dropout_p
    8.         self.max_length = max_length
    9.  
    10.         self.embedding = nn.Embedding(self.output_size, self.hidden_size)
    11.         
    12.         self.attn = nn.Linear(self.hidden_size * 2, self.max_length)
    13.         self.attn_combine = nn.Linear(self.hidden_size * 2, self.hidden_size)
    14.         self.dropout = nn.Dropout(self.dropout_p)
    15.  
    16.         self.gru = nn.GRU(self.hidden_size, self.hidden_size)
    17.         self.out = nn.Linear(self.hidden_size, self.output_size)
    18.  
    19.  
    20.     def forward(self, input, hidden, encoder_outputs):
    21.  
    22.         embedded = self.embedding(input).view(1, 1, -1)
    23.  
    24.         embedded = self.dropout(embedded)
    25.  
    26.         attn_weights = F.softmax(
    27.             self.attn(torch.cat((embedded[0], hidden[0]), 1)), dim=1)
    28.  
    29.         attn_applied = torch.bmm(attn_weights.unsqueeze(0),
    30.                                  encoder_outputs.unsqueeze(0))
    31.  
    32.  
    33.         output = torch.cat((embedded[0], attn_applied[0]), 1)
    34.  
    35.         output = self.attn_combine(output).unsqueeze(0)
    36.  
    37.         output = F.relu(output)
    38.  
    39.         output, hidden = self.gru(output, hidden)
    40.  
    41.  
    42.         output = F.log_softmax(self.out(output[0]), dim=1)
    43.  
    44.         return output, hidden, attn_weights
    45.  
    46.     def initHidden(self):
    47.  
    48.         return torch.zeros(1, 1, self.hidden_size, device=device)

    构建模型训练函数

    2a8c5559c3064e22877f2d88e17ad51a.png

    teacher_forcing介绍

    Teacher Forcing是一种在训练序列生成模型，特别是循环神经网络（RNN）和序列到序列（seq2seq）模型时常用的技术。在seq2seq架构中，根据循环神经网络理论，解码器每次应该使用上一步的结果作为输入的一部分, 但是训练过程中，一旦上一步的结果是错误的，就会导致这种错误被累积，无法达到训练效果，我们需要一种机制改变上一步出错的情况，因为训练时我们是已知正确的输出应该是什么，因此可以强制将上一步结果设置成正确的输出, 这种方式就叫做teacher_forcing。

    teacher_forcing的作用

    • 加速模型收敛与稳定训练：通过使用真实的历史数据作为解码器的输入，Teacher Forcing技术可以加速模型的收敛速度，并使得训练过程更加稳定，因为它避免了因模型早期预测错误而导致的累积误差。
    • 矫正预测并避免误差放大：Teacher Forcing在训练时能够矫正模型的预测，防止在序列生成过程中误差的进一步放大，从而提高了模型的预测准确性。
    1. # 设置teacher_forcing比率为0.5
    2. teacher_forcing_ratio = 0.5
    3.  
    4.  
    5. def train(input_tensor, target_tensor, encoder, decoder, encoder_optimizer, decoder_optimizer, criterion, max_length=MAX_LENGTH):
    6.  
    7.     encoder_hidden = encoder.initHidden()
    8.  
    9.     encoder_optimizer.zero_grad()
    10.     decoder_optimizer.zero_grad()
    11.  
    12.     input_length = input_tensor.size(0)
    13.     target_length = target_tensor.size(0)
    14.  
    15.     encoder_outputs = torch.zeros(max_length, encoder.hidden_size, device=device)
    16.  
    17.     loss = 0
    18.  
    19.     for ei in range(input_length):
    20.         
    21.         encoder_output, encoder_hidden = encoder(
    22.             input_tensor[ei], encoder_hidden)
    23.    
    24.         encoder_outputs[ei] = encoder_output[0, 0]
    25.  
    26.  
    27.     decoder_input = torch.tensor([[SOS_token]], device=device)
    28.  
    29.     decoder_hidden = encoder_hidden
    30.  
    31.     use_teacher_forcing = True if random.random() < teacher_forcing_ratio else False
    32.  
    33.  
    34.     if use_teacher_forcing:
    35.  
    36.         for di in range(target_length):
    37.  
    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.  
    43.             decoder_input = target_tensor[di]  
    44.  
    45.     else:
    46.  
    47.         for di in range(target_length):
    48.             decoder_output, decoder_hidden, decoder_attention = decoder(
    49.                 decoder_input, decoder_hidden, encoder_outputs)
    50.  
    51.             topv, topi = decoder_output.topk(1)
    52.  
    53.             loss += criterion(decoder_output, target_tensor[di])
    54.  
    55.             if topi.squeeze().item() == EOS_token:
    56.                 break
    57.            
    58.             decoder_input = topi.squeeze().detach()
    59.  
    60.  
    61.     # 误差进行反向传播
    62.     loss.backward()
    63.     # 编码器和解码器进行优化即参数更新
    64.     encoder_optimizer.step()
    65.     decoder_optimizer.step()
    66.  
    67.     # 返回平均损失
    68.     return loss.item() / target_length

    构建时间计算函数

    1. import time
    2. import math
    3.  
    4. def timeSince(since):
    5.     now = time.time()
    6.     # 获得时间差
    7.     s = now - since
    8.     # 将秒转化为分钟
    9.     m = math.floor(s / 60)
    10.     s -= m * 60
    11.     return '%dm %ds' % (m, s)

    调用训练函数并打印日志和制图

    1. import matplotlib.pyplot as plt
    2.  
    3. def trainIters(encoder, decoder, n_iters, print_every=1000, plot_every=100, learning_rate=0.01):
    4.  
    5.     start = time.time()
    6.  
    7.     plot_losses = []
    8.  
    9.     print_loss_total = 0  
    10.  
    11.     plot_loss_total = 0  
    12.  
    13.     encoder_optimizer = optim.SGD(encoder.parameters(), lr=learning_rate)
    14.     decoder_optimizer = optim.SGD(decoder.parameters(), lr=learning_rate)
    15.  
    16.  
    17.     criterion = nn.NLLLoss()
    18.  
    19.     for iter in range(1, n_iters + 1):
    20.  
    21.         training_pair = tensorsFromPair(random.choice(pairs))
    22.  
    23.         input_tensor = training_pair[0]
    24.         target_tensor = training_pair[1]
    25.  
    26.  
    27.         loss = train(input_tensor, target_tensor, encoder,
    28.                      decoder, encoder_optimizer, decoder_optimizer, criterion)
    29.  
    30.         print_loss_total += loss
    31.         plot_loss_total += loss
    32.  
    33.  
    34.         if iter % print_every == 0:
    35.  
    36.             print_loss_avg = print_loss_total / print_every
    37.             print_loss_total = 0
    38.             print('%s (%d %d%%) %.4f' % (timeSince(start),
    39.                                          iter, iter / n_iters * 100, print_loss_avg))
    40.  
    41.         if iter % plot_every == 0:
    42.             plot_loss_avg = plot_loss_total / plot_every
    43.             plot_losses.append(plot_loss_avg)
    44.             plot_loss_total = 0
    45.  
    46.  
    47.     plt.figure()  
    48.     plt.plot(plot_losses)
    49.     plt.savefig("loss.png")

    💥训练模型：

    1. # 设置隐层大小为256 ，也是词嵌入维度      
    2. hidden_size = 256
    3. # 通过input_lang.n_words获取输入词汇总数，与hidden_size一同传入EncoderRNN类中
    4. # 得到编码器对象encoder1
    5. encoder1 = EncoderRNN(input_lang.n_words, hidden_size).to(device)
    6.  
    7. # 通过output_lang.n_words获取目标词汇总数，与hidden_size和dropout_p一同传入AttnDecoderRNN类中
    8. # 得到解码器对象attn_decoder1
    9. attn_decoder1 = AttnDecoderRNN(hidden_size, output_lang.n_words, dropout_p=0.1).to(device)
    10.  
    11. # 设置迭代步数 
    12. n_iters = 80000
    13. # 设置日志打印间隔
    14. print_every = 5000 
    15.  
    16. trainIters(encoder1, attn_decoder1, n_iters, print_every=print_every)

    模型会不断打印loss损失值并且绘制图像

    d037317aa28d40b49bf1dac1cf22f680.png

    • 一直下降的损失曲线, 说明模型正在收敛 

    构建模型评估函数

    50f947b7416249b695abe3738cc64164.png

    1. def evaluate(encoder, decoder, sentence, max_length=MAX_LENGTH):
    2.     with torch.no_grad():
    3.         # 对输入的句子进行张量表示
    4.         input_tensor = tensorFromSentence(input_lang, sentence)
    5.         # 获得输入的句子长度
    6.         input_length = input_tensor.size()[0]
    7.         encoder_hidden = encoder.initHidden()
    8.  
    9.         encoder_outputs = torch.zeros(max_length, encoder.hidden_size, device=device)
    10.  
    11.         for ei in range(input_length):
    12.  
    13.             encoder_output, encoder_hidden = encoder(input_tensor[ei],
    14.                                                      encoder_hidden)
    15.  
    16.             encoder_outputs[ei] += encoder_output[0, 0]
    17.  
    18.         decoder_input = torch.tensor([[SOS_token]], device=device) 
    19.  
    20.         decoder_hidden = encoder_hidden
    21.  
    22.         decoded_words = []
    23.         # 初始化attention张量
    24.         decoder_attentions = torch.zeros(max_length, max_length)
    25.         # 开始循环解码
    26.         for di in range(max_length):
    27.  
    28.             decoder_output, decoder_hidden, decoder_attention = decoder(
    29.                 decoder_input, decoder_hidden, encoder_outputs)
    30.  
    31.  
    32.             decoder_attentions[di] = decoder_attention.data
    33.             topv, topi = decoder_output.data.topk(1)
    34.             if topi.item() == EOS_token:
    35.                 decoded_words.append('') 
    36.                 break
    37.  
    38.             else:
    39.                 
    40.                 decoded_words.append(output_lang.index2word[topi.item()])
    41.  
    42.  
    43.             decoder_input = topi.squeeze().detach()
    44.         return decoded_words, decoder_attentions[:di + 1]

     随机选择指定数量的数据进行评估

    1. def evaluateRandomly(encoder, decoder, n=6):
    2.     for i in range(n):
    3.         pair = random.choice(pairs)
    4.         # > 代表输入
    5.         print('>', pair[0])
    6.         # = 代表正确的输出
    7.         print('=', pair[1])
    8.         # 调用evaluate进行预测
    9.         output_words, attentions = evaluate(encoder, decoder, pair[0])
    10.         # 将结果连成句子
    11.         output_sentence = ' '.join(output_words)
    12.         # < 代表模型的输出
    13.         print('<', output_sentence)
    14.         print('')
    15.  
    16. evaluateRandomly(encoder1, attn_decoder1)

    效果：

    1. > i m impressed with your french .
    2. = je suis impressionne par votre francais .
    3. < je suis impressionnee par votre francais . 
    4.  
    5. > i m more than a friend .
    6. = je suis plus qu une amie .
    7. < je suis plus qu une amie . 
    8.  
    9. > she is beautiful like her mother .
    10. = elle est belle comme sa mere .
    11. < elle est sa sa mere . 
    12.  
    13. > you re winning aren t you ?
    14. = vous gagnez n est ce pas ?
    15. < tu restez n est ce pas ? 
    16.  
    17. > he is angry with you .
    18. = il est en colere apres toi .
    19. < il est en colere apres toi . 
    20.  
    21. > you re very timid .
    22. = vous etes tres craintifs .
    23. < tu es tres craintive .

    Attention张量制图

    1. sentence = "we re both teachers ."
    2. # 调用评估函数
    3. output_words, attentions = evaluate(
    4. encoder1, attn_decoder1, sentence)
    5. print(output_words)
    6. # 将attention张量转化成numpy, 使用matshow绘制
    7. plt.matshow(attentions.numpy())
    8. plt.savefig("attn.png")

    如果迭代次数过少，训练不充分，那么注意力就不会很好：

    703e1e4cd170498c8fb211aa10694c02.png

    💯迭代次数变大：

    5a4477724f3147ecaf4e846972d24293.png

  • 相关阅读:
    1546_AURIX_TC275_CPU子系统_指令耗时以及程序存储接口
    尚医通_第9章_部署医院模拟系统和搭建环境
    【软件与系统安全笔记】三、基础技术
    JDBC、ORM、mybatis之间的关系
    LeetCode刷题系列 -- 652. 寻找重复的子树
    Paste v4.1.2(Mac剪切板)
    【Android安全】Frida 指定classloader | hook动态加载的类 | 安卓多apk hook
    项目采购管理
    数据结构绪论思维导图
    day065：IO流、字节流、字节流写数据
  • 原文地址：https://blog.csdn.net/qq_64685283/article/details/139569864