devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

NLP简单项目实战——ChatBOT（二）

作者：我家自动化 | 2024-04-27 18:33:09

赞

踩

NLP简单项目实战——ChatBOT（二）

二、Seq2Seq

（一）Seq2Seq原理

        Seq2seq模型中的encoder接收一个长度为M的序列，得到1个 context vector，之后decoder把这一个context vector转化为长度为N的序列作为输出，从而构成一个M to N的模型，能够处理很多不定长输入输出的问题

（二）Seq2Seq实现

        1.实现流程：

        文本转换为序列，使用序列，完成encoder、decoder，完成Seq2Seq模型，完成模型训练逻辑与评估逻辑。

        准备一个config.py文件记录可变参数，use_word等。

        2.准备训练数据：

        单轮次聊天数据并不好获取，这里主要用小黄鸡语料以及微博语料。

        下载地址：GitHub - codemayq/chinese-chatbot-corpus: 中文公开聊天语料库

        存放至：

        建立按词与按字分词的input与output文件：

  1. from tqdm import tqdm
  2. from jieba import lcut as jieba_cut
  3. import re
  4.  
  5. def format_xiaohuangji_corpus(word=False):
  6.     """处理小黄鸡的语料，分为两个部分，一个是input部分，就是发起聊天的语料
  7.     output就是回应聊天的语料"""
  8.     if word:
  9.         corpus_path = "corpus_pre/xiaohuangji50w_nofenci.conv"
  10.         input_path = "corpus/input_word.txt"
  11.         output_path = "corpus/corpus/output_word.txt"
  12.     else:
  13.  
  14.         corpus_path = "corpus_pre/xiaohuangji50w_nofenci.conv"
  15.         input_path = "corpus/input.txt"
  16.         output_path = "corpus/output.txt"
  17.  
  18.     f_input = open(input_path,"a")
  19.     f_output = open(output_path,"a")
  20.     pair = []
  21.     for line in tqdm(open(corpus_path, encoding='utf-8'),ascii=True):
  22.         if line.strip() == "E":
  23.             if not pair:
  24.                 continue
  25.             else:
  26.                 assert len(pair) == 2,"长度必须是2"
  27.                 if len(pair[0].strip())>=1 and len(pair[1].strip())>=1:
  28.                     f_input.write(pair[0]+"\n")
  29.                     f_output.write(pair[1]+"\n")
  30.                 pair = []
  31.         elif line.startswith("M"):
  32.             line = line[1:]
  33.             if word:
  34.                 pair.append(" ".join(list(line.strip())))
  35.             else:
  36.                 pair.append(" ".join(jieba_cut(line.strip())))
  37. def format_weibo(word=False):
  38.     """
  39.     微博数据存在一些噪声，未处理
  40.     :return:
  41.     """
  42.     if word:
  43.         origin_input = "corpus_pre/stc_weibo_train_post"
  44.         input_path = "corpus/input_word.txt"
  45.  
  46.         origin_output = "corpus_pre/stc_weibo_train_response"
  47.         output_path = "corpus/output_word.txt"
  48.  
  49.     else:
  50.         origin_input = "corpus_pre/stc_weibo_train_post"
  51.         input_path = "corpus/input.txt"
  52.  
  53.         origin_output = "corpus_pre/stc_weibo_train_response"
  54.         output_path = "corpus/output.txt"
  55.  
  56.     f_input = open(input_path,"a",encoding='utf-8')
  57.     f_output = open(output_path, "a",encoding='utf-8')
  58.     with open(origin_input, encoding='utf-8') as in_o,open(origin_output,encoding='utf-8') as out_o:
  59.         for _in,_out in tqdm(zip(in_o,out_o),ascii=True):
  60.             _in = _in.strip()
  61.             _out = _out.strip()
  62.  
  63.             if _in.endswith("）") or _in.endswith("」") or _in.endswith(")"):
  64.                 _in = re.sub("（.*）|「.*?」|\(.*?\)"," ",_in)
  65.             """由于微博语料较多表情与符号，所以需要用正则表达式进行处理"""
  66.             _in = re.sub("我在.*?alink|alink|（.*?\d+x\d+.*?）|#|】|【|-+|_+|via.*?：*.*"," ",_in)
  67.             _in = re.sub("\s+"," ",_in)
  68.             if len(_in)<1 or len(_out)<1:
  69.                 continue
  70.  
  71.             if word:
  72.                 _in = re.sub("\s+","",_in)  #转化为一整行，不含空格
  73.                 _out = re.sub("\s+","",_out)
  74.                 if len(_in)>=1 and len(_out)>=1:
  75.                     f_input.write(" ".join(list(_in)) + "\n")
  76.                     f_output.write(" ".join(list(_out)) + "\n")
  77.             else:
  78.                 if len(_in) >= 1 and len(_out) >= 1:
  79.                     f_input.write(_in.strip()+"\n")
  80.                     f_output.write(_out.strip()+"\n")
  81.  
  82.     f_input.close()
  83.     f_output.close()
  84.  
  85. if __name__ == '__main__':
  86.     format_xiaohuangji_corpus(False)
  87.     format_xiaohuangji_corpus(True)
  88.     format_weibo(False)
  89.     format_weibo(True)

        报错：

        解决： 添加encoding = ’utf-8‘即可。

        调用函数即可。

       3.文本转换为序列：

        将文本转换为数字再转换为向量：

  1. import config
  2. import pickle
  3.  
  4.  
  5. class Word2Sequence():
  6.     UNK_TAG = "UNK"
  7.     PAD_TAG = "PAD"
  8.     SOS_TAG = "SOS"
  9.     EOS_TAG = "EOS"
  10.  
  11.     UNK = 0
  12.     PAD = 1
  13.     SOS = 2
  14.     EOS = 3
  15.  
  16.     def __init__(self):
  17.         self.dict = {
  18.             self.UNK_TAG: self.UNK,
  19.             self.PAD_TAG: self.PAD,
  20.             self.SOS_TAG: self.SOS,
  21.             self.EOS_TAG: self.EOS
  22.         }
  23.         self.count = {}
  24.         self.fited = False
  25.  
  26.     def to_index(self, word):
  27.         """word -> index"""
  28.         assert self.fited == True, "必须先进行fit操作"
  29.         return self.dict.get(word, self.UNK)
  30.  
  31.     def to_word(self, index):
  32.         """index -> word"""
  33.         assert self.fited, "必须先进行fit操作"
  34.         if index in self.inversed_dict:
  35.             return self.inversed_dict[index]
  36.         return self.UNK_TAG
  37.  
  38.     def __len__(self):
  39.         return len(self.dict)
  40.  
  41.     def fit(self, sentence):
  42.         """
  43.         :param sentence:[word1,word2,word3]
  44.         :param min_count: 最小出现的次数
  45.         :param max_count: 最大出现的次数
  46.         :param max_feature: 总词语的最大数量
  47.         :return:
  48.         """
  49.         for a in sentence:
  50.             if a not in self.count:
  51.                 self.count[a] = 0
  52.             self.count[a] += 1
  53.  
  54.         self.fited = True
  55.  
  56.     def build_vocab(self, min_count=1, max_count=None, max_feature=None):
  57.  
  58.         # 比最小的数量大和比最大的数量小的需要
  59.         if min_count is not None:
  60.             self.count = {k: v for k, v in self.count.items() if v >= min_count}
  61.         if max_count is not None:
  62.             self.count = {k: v for k, v in self.count.items() if v <= max_count}
  63.  
  64.         # 限制最大的数量
  65.         if isinstance(max_feature, int):
  66.             count = sorted(list(self.count.items()), key=lambda x: x[1])
  67.             if max_feature is not None and len(count) > max_feature:
  68.                 count = count[-int(max_feature):]
  69.             for w, _ in count:
  70.                 self.dict[w] = len(self.dict)
  71.         else:
  72.             for w in sorted(self.count.keys()):
  73.                 self.dict[w] = len(self.dict)
  74.  
  75.         # 准备一个index->word的字典
  76.         self.inversed_dict = dict(zip(self.dict.values(), self.dict.keys()))
  77.  
  78.     def transform(self, sentence, max_len=None, add_eos=False):
  79.         """
  80.         实现吧句子转化为数组（向量）
  81.         :param sentence:
  82.         :param max_len:
  83.         :return:
  84.         """
  85.         assert self.fited, "必须先进行fit操作"
  86.  
  87.         r = [self.to_index(i) for i in sentence]
  88.         if max_len is not None:
  89.             if max_len > len(sentence):
  90.                 if add_eos:
  91.                     r += [self.EOS] + [self.PAD for _ in range(max_len - len(sentence) - 1)]
  92.                 else:
  93.                     r += [self.PAD for _ in range(max_len - len(sentence))]
  94.             else:
  95.                 if add_eos:
  96.                     r = r[:max_len - 1]
  97.                     r += [self.EOS]
  98.                 else:
  99.                     r = r[:max_len]
  100.         else:
  101.             if add_eos:
  102.                 r += [self.EOS]
  103.         # print(len(r),r)
  104.         return r
  105.  
  106.     def inverse_transform(self, indices):
  107.         """
  108.         实现从数组 转化为 向量
  109.         :param indices: [1,2,3....]
  110.         :return:[word1,word2.....]
  111.         """
  112.         sentence = []
  113.         for i in indices:
  114.             word = self.to_word(i)
  115.             sentence.append(word)
  116.         return sentence
  117.  
  118.  
  119. # 之后导入该word_sequence使用
  120. # word_sequence = pickle.load(open("./ws", "rb")) if not config.use_word else pickle.load(
  121. #     open("./ws_word", "rb"))
  122.  
  123. if __name__ == '__main__':
  124.     from tqdm import tqdm
  125.     import pickle
  126.  
  127.     word_sequence = Word2Sequence()
  128.     # 词语级别
  129.     input_path = "corpus/input.txt"
  130.     target_path = "corpus/output.txt"
  131.     for line in tqdm(open(input_path, encoding='utf-8').readlines()):
  132.         word_sequence.fit(line.strip().split())
  133.     for line in tqdm(open(target_path, encoding='utf-8').readlines()):
  134.         word_sequence.fit(line.strip().split())
  135.  
  136.     # 使用max_feature=5000个数据
  137.     word_sequence.build_vocab(min_count=5, max_count=None, max_feature=5000)
  138.     print(len(word_sequence))
  139.     pickle.dump(word_sequence, open("./ws", "wb"))

        运行结果：

       4.准备DataLoader：

  1. import torch
  2. import config
  3. from torch.utils.data import Dataset,DataLoader
  4. from wordsequence import word_sequence
  5.  
  6.  
  7. class ChatDataset(Dataset):
  8.     def __init__(self):
  9.         super(ChatDataset,self).__init__()
  10.  
  11.         input_path = "corpus/input.txt"
  12.         target_path = "corpus/output.txt"
  13.         if config.use_word:
  14.             input_path = "corpus/input_word.txt"
  15.             target_path = "corpus/output_word.txt"
  16.  
  17.         self.input_lines = open(input_path).readlines()
  18.         self.target_lines = open(target_path).readlines()
  19.         assert len(self.input_lines) == len(self.target_lines) ,"input和target文本的数量必须相同"
  20.     def __getitem__(self, index):
  21.         input = self.input_lines[index].strip().split()
  22.         target = self.target_lines[index].strip().split()
  23.         if len(input) == 0 or len(target)==0:
  24.             input = self.input_lines[index+1].strip().split()
  25.             target = self.target_lines[index+1].strip().split()
  26.         #此处句子的长度如果大于max_len，那么应该返回max_len
  27.         return input,target,min(len(input),config.max_len),min(len(target),config.max_len)
  28.  
  29.     def __len__(self):
  30.         return len(self.input_lines)
  31.  
  32. def collate_fn(batch):
  33.     #1.排序
  34.     batch = sorted(batch,key=lambda x:x[2],reverse=True)
  35.     input, target, input_length, target_length = zip(*batch)
  36.  
  37.     # 2.进行padding的操作
  38.     input = torch.LongTensor([word_sequence.transform(i, max_len=config.max_len) for i in input])
  39.     target = torch.LongTensor([word_sequence.transform(i, max_len=config.max_len, add_eos=True) for i in target])
  40.     input_length = torch.LongTensor(input_length)
  41.     target_length = torch.LongTensor(target_length)
  42.  
  43.     return input, target, input_length, target_length
  44.  
  45. data_loader = DataLoader(dataset=ChatDataset(),batch_size=config.batch_size,shuffle=True,collate_fn=collate_fn,drop_last=True)

        5.encoder编码层：

        建立一个神经网络，主要有一个embedding层和GRU层（LSTM的变体）

  1. import torch.nn as nn
  2. from wordsequence import word_sequence
  3. import config
  4.  
  5.  
  6. class Encoder(nn.Module):
  7.     def __init__(self):
  8.         super(Encoder,self).__init__()
  9.         self.vocab_size = len(word_sequence)
  10.         self.dropout = config.dropout
  11.         self.embedding_dim = config.embedding_dim
  12.         self.embedding = nn.Embedding(num_embeddings=self.vocab_size,embedding_dim=self.embedding_dim,padding_idx=word_sequence.PAD)
  13.         self.gru = nn.GRU(input_size=self.embedding_dim,
  14.                           hidden_size=config.hidden_size,
  15.                           num_layers=1,
  16.                           batch_first=True,
  17.                           dropout=config.dropout)
  18.  
  19.     def forward(self, input,input_length):
  20.         embeded = self.embedding(input)
  21.         """
  22.         可变长度的tensor
  23.         """
  24.         embeded = nn.utils.rnn.pack_padded_sequence(embeded,lengths=input_length,batch_first=True)
  25.  
  26.         #hidden:[1,batch_size,vocab_size]
  27.         out,hidden = self.gru(embeded)
  28.         out,outputs_length = nn.utils.rnn.pad_packed_sequence(out,batch_first=True,padding_value=word_sequence.PAD)
  29.         #hidden [1,batch_size,hidden_size]
  30.         return out,hidden

        6.decoder层：

        主要有四层，embedding层、Gru层、全链接层和一个输出softmax层。

        forward用于将上一次计算的的的输出与隐层状态传给下一次，forward_step用于向前计算。

  1. import torch
  2. import torch.nn as nn
  3. import config
  4. import random
  5. import torch.nn.functional as F
  6. from wordsequence import word_sequence
  7.  
  8. class Decoder(nn.Module):
  9.     def __init__(self):
  10.         super(Decoder,self).__init__()
  11.         self.max_seq_len = config.max_len
  12.         self.vocab_size = len(word_sequence)
  13.         self.embedding_dim = config.embedding_dim
  14.         self.dropout = config.dropout
  15.  
  16.         self.embedding = nn.Embedding(num_embeddings=self.vocab_size,embedding_dim=self.embedding_dim,padding_idx=word_sequence.PAD)
  17.         self.gru = nn.GRU(input_size=self.embedding_dim,
  18.                           hidden_size=config.hidden_size,
  19.                           num_layers=1,
  20.                           batch_first=True,
  21.                           dropout=self.dropout)
  22.         self.log_softmax = nn.LogSoftmax()
  23.  
  24.         self.fc = nn.Linear(config.hidden_size,self.vocab_size)
  25.  
  26.     def forward(self, encoder_hidden,target,target_length):
  27.         # encoder_hidden [batch_size,hidden_size]
  28.         # target [batch_size,seq-len]
  29.  
  30.         decoder_input = torch.LongTensor([[word_sequence.SOS]]*config.batch_size).to(config.device)
  31.         decoder_outputs = torch.zeros(config.batch_size,config.max_len,self.vocab_size).to(config.device) #[batch_size,seq_len,14]
  32.  
  33.         decoder_hidden = encoder_hidden #[batch_size,hidden_size]
  34.  
  35.         for t in range(config.max_len):
  36.             decoder_output_t , decoder_hidden = self.forward_step(decoder_input,decoder_hidden)
  37.             decoder_outputs[:,t,:] = decoder_output_t
  38.             value, index = torch.topk(decoder_output_t, 1) # index [batch_size,1]
  39.             decoder_input = index
  40.         return decoder_outputs,decoder_hidden
  41.  
  42.     def forward_step(self,decoder_input,decoder_hidden):
  43.         """
  44.         :param decoder_input:[batch_size,1]
  45.         :param decoder_hidden: [1,batch_size,hidden_size]
  46.         :return: out:[batch_size,vocab_size],decoder_hidden:[1,batch_size,didden_size]
  47.         """
  48.         embeded = self.embedding(decoder_input)  #embeded: [batch_size,1 , embedding_dim]
  49.         out,decoder_hidden = self.gru(embeded,decoder_hidden) #out [1, batch_size, hidden_size]
  50.         out = out.squeeze(0)
  51.         out = F.log_softmax(self.fc(out),dim=-1)#[batch_Size, vocab_size]
  52.         out = out.squeeze(1)
  53.         # print("out size:",out.size(),decoder_hidden.size())
  54.         return out,decoder_hidden

        7.完成模型：

        将encoder的隐层状态导入decoder中

  1. import torch
  2. import torch.nn as nn
  3.  
  4. class Seq2Seq(nn.Module):
  5.     def __init__(self,encoder,decoder):
  6.         super(Seq2Seq,self).__init__()
  7.         self.encoder = encoder
  8.         self.decoder = decoder
  9.  
  10.     def forward(self, input,target,input_length,target_length):
  11.         encoder_outputs,encoder_hidden = self.encoder(input,input_length)
  12.         decoder_outputs,decoder_hidden = self.decoder(encoder_hidden,target,target_length)
  13.         return decoder_outputs,decoder_hidden
  14.  
  15.     def evaluation(self,inputs,input_length):
  16.         encoder_outputs,encoder_hidden = self.encoder(inputs,input_length)
  17.         decoded_sentence = self.decoder.evaluation(encoder_hidden)
  18.         return decoded_sentence

         8.评估：

  1. import torch
  2. import config
  3. from torch import optim
  4. import torch.nn as nn
  5. from Encoder import Encoder
  6. from Decoder import Decoder
  7. from seq2seq import Seq2Seq
  8. from Dataset_Dataloader import data_loader as train_dataloader
  9. from wordsequence import word_sequence
  10.  
  11. encoder = Encoder()
  12. decoder = Decoder()
  13. model = Seq2Seq(encoder,decoder)
  14.  
  15. #device在config文件中实现
  16. model.to(config.device)
  17.  
  18.  
  19. model.load_state_dict(torch.load("model/seq2seq_model"))
  20. optimizer =  optim.Adam(model.parameters())
  21. optimizer.load_state_dict(torch.load("model/seq2seq_optimizer"))
  22. criterion= nn.NLLLoss(ignore_index=word_sequence.PAD,reduction="mean")
  23.  
  24. def get_loss(decoder_outputs,target):
  25.     target = target.view(-1) #[batch_size*max_len]
  26.     decoder_outputs = decoder_outputs.view(config.batch_size*config.max_len,-1)
  27.     return criterion(decoder_outputs,target)
  28.  
  29.  
  30. def train(epoch):
  31.     for idx,(input,target,input_length,target_len) in enumerate(train_dataloader):
  32.         input = input.to(config.device)
  33.         target = target.to(config.device)
  34.         input_length = input_length.to(config.device)
  35.         target_len = target_len.to(config.device)
  36.  
  37.         optimizer.zero_grad()
  38.         ##[seq_len,batch_size,vocab_size] [batch_size,seq_len]
  39.         decoder_outputs,decoder_hidden = model(input,target,input_length,target_len)
  40.         loss = get_loss(decoder_outputs,target)
  41.         loss.backward()
  42.         optimizer.step()
  43.  
  44.         print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
  45.             epoch, idx * len(input), len(train_dataloader.dataset),
  46.                    100. * idx / len(train_dataloader), loss.item()))
  47.  
  48.         torch.save(model.state_dict(), "model/seq2seq_model")
  49.         torch.save(optimizer.state_dict(), 'model/seq2seq_optimizer')
  50.  
  51. if __name__ == '__main__':
  52.     for i in range(10):
  53.         train(i)

        电脑冒烟了，跑了12个小时：

         但可见，效果并不是很好，仅有50%的准确率，loss也高。这是因为在当前模型中，Encoder将一个句子转换为一个向量，然后在Decoder中使用，如果说Encoder输入句子过长，包含了太多其他的信息，这就导致在Decoder中进行编码的过程，有太多噪声干扰，导致较低的准确率和较高的loss。

三、attention：

        为了解决上面的问题，我们采用attention机制，即只关注重要的信息。我们不再将encoder的输出状态作为decoder的输入。

（一）attention原理：

        参考：Hung-yi Lee

        初始化decoder的初始状态Z0，然后这个Z0会与encoder的第一个timestep的output进行match操作，match操作可以是一个神经网络，具体表现为一个矩阵乘法。得到结果进行softmax，让其和为1，并将其结果与原来encoder输出就行加权求和得到c0。然后与z0一起进入decoder层，得到h1。然后以此循环直至decoder的output为终止符。

        

 （二）soft-attention与hard-attention

        1.soft-attention：

        指的是encoder中输入的每个词语都会计算得到一个注意力的概率。

        2.hard-attention：

        希望直接从input中找到一个和输出的某个词对应的那一个词。但是由于NLP中词语。和词语之间往往存在联系，不会只关注某一个词语。所以在NLP中我们一般使用soft-attention。

（三）Global-attention and Local-attention：

        Global-attention指的是使用的全部的encoder端的输入的attenion的权重

        Local-attention指的是使用了部分的encoder端的输入的权重(当前时间步上的encoder的hidden state)，这样可以减少计算量，特别是当句子的长度比较长的时候。

        我们一般使用全局attention。

        全局attention计算权重方法：

        将decoder进行矩阵变换得到d1，然后将decoder与encoder的输出进行矩阵乘法得到d2，然后将d1与d2合并为一个矩阵。

（四）代码实现：

        其实attention机制简单来说就是，计算权重，采用local-attention的方法。

  1. class Attention(nn.Module):
  2.     def __init__(self,method,batch_size,hidden_size):
  3.         super(Attention,self).__init__()
  4.         self.method = method
  5.         self.hidden_size = hidden_size
  6.  
  7.         assert self.method in ["dot","general","concat"],"method 只能是 dot,general,concat,当前是{}".format(self.method)
  8.  
  9.         if self.method == "dot":
  10.             pass
  11.         elif self.method == "general":
  12.             self.Wa = nn.Linear(hidden_size,hidden_size,bias=False)
  13.         elif self.method == "concat":
  14.             self.Wa = nn.Linear(hidden_size*2,hidden_size,bias=False)
  15.             self.Va = nn.Parameter(torch.FloatTensor(batch_size,hidden_size))
  16.  
  17.     def forward(self, hidden,encoder_outputs):
  18.         """
  19.         :param hidden:[1,batch_size,hidden_size]
  20.         :param encoder_outputs: [batch_size,seq_len,hidden_size]
  21.         :return:
  22.         """
  23.         batch_size,seq_len,hidden_size = encoder_outputs.size()
  24.  
  25.         hidden = hidden.squeeze(0) #[batch_size,hidden_size]
  26.  
  27.         if self.method == "dot":
  28.             return self.dot_score(hidden,encoder_outputs)
  29.         elif self.method == "general":
  30.             return self.general_score(hidden,encoder_outputs)
  31.         elif self.method == "concat":
  32.             return self.concat_score(hidden,encoder_outputs)
  33.  
  34.     def _score(self,batch_size,seq_len,hidden,encoder_outputs):
  35.         # 速度太慢
  36.         # [batch_size,seql_len]
  37.         attn_energies = torch.zeros(batch_size,seq_len).to(config.device)
  38.         for b in range(batch_size):
  39.             for i in range(seq_len):
  40.                 #encoder_output : [batch_size,seq_len,hidden_size]
  41.                 #deocder_hidden :[batch_size,hidden_size]
  42.                 #torch.Size([256, 128]) torch.Size([128]) torch.Size([256, 24, 128]) torch.Size([128])
  43.                 # print("attn size:",hidden.size(),hidden[b,:].size(),encoder_output.size(),encoder_output[b,i].size())
  44.                     attn_energies[b,i] = hidden[b,:].dot(encoder_outputs[b,i]) #dot score
  45.         return F.softmax(attn_energies).unsqueeze(1)  # [batch_size,1,seq_len]
  46.  
  47.     def dot_score(self,hidden,encoder_outputs):
  48.         """
  49.         dot attention
  50.         :param hidden:[batch_size,hidden_size] --->[batch_size,hidden_size,1]
  51.         :param encoder_outputs: [batch_size,seq_len,hidden_size]
  52.         :return:
  53.         """
  54.         #hiiden :[hidden_size] -->[hidden_size,1] ，encoder_output:[seq_len,hidden_size]
  55.         
  56.         
  57.         hidden = hidden.unsqueeze(-1)
  58.         attn_energies = torch.bmm(encoder_outputs, hidden)
  59.         attn_energies = attn_energies.squeeze(-1) #[batch_size,seq_len,1] ==>[batch_size,seq_len]
  60.  
  61.         return F.softmax(attn_energies).unsqueeze(1)  # [batch_size,1,seq_len]
  62.  
  63.     def general_score(self,hidden,encoder_outputs):
  64.         """
  65.         general attenion
  66.         :param batch_size:int
  67.         :param hidden: [batch_size,hidden_size]
  68.         :param encoder_outputs: [batch_size,seq_len,hidden_size]
  69.         :return:
  70.         """
  71.         x = self.Wa(hidden) #[batch_size,hidden_size]
  72.         x = x.unsqueeze(-1) #[batch_size,hidden_size,1]
  73.         attn_energies = torch.bmm(encoder_outputs,x).squeeze(-1) #[batch_size,seq_len,1]
  74.         return F.softmax(attn_energies,dim=-1).unsqueeze(1)      # [batch_size,1,seq_len]
  75.  
  76.     def concat_score(self,hidden,encoder_outputs):
  77.         """
  78.         concat attention
  79.         :param batch_size:int
  80.         :param hidden: [batch_size,hidden_size]
  81.         :param encoder_outputs: [batch_size,seq_len,hidden_size]
  82.         :return:
  83.         """
  84.         #需要先进行repeat操作，变成和encoder_outputs相同的形状,让每个batch有seq_len个hidden_size
  85.         x = hidden.repeat(1,encoder_outputs.size(1),1) ##[batch_size,seq_len,hidden_size]
  86.         x = torch.tanh(self.Wa(torch.cat([x,encoder_outputs],dim=-1))) #[batch_size,seq_len,hidden_size*2] --> [batch_size,seq_len,hidden_size]
  87.         #va [batch_size,hidden_size] ---> [batch_size,hidden_size,1]
  88.         attn_energis = torch.bmm(x,self.Va.unsqueeze(2))  #[batch_size,seq_len,1]
  89.         attn_energis = attn_energis.squeeze(-1)
  90.         # print("concat attention:",attn_energis.size(),encoder_outputs.size())
  91.         return F.softmax(attn_energis,dim=-1).unsqueeze(1) #[batch_size,1,seq_len]

        将在seq2seq中的forward_step函数进行修改：四、

四、Beam Search

        基本的建模以及完成，在模型评估时我们应该选择概率最大的tokenid进行输出，但是得到的句子可能并不通顺，我们叫他为greedy search。所以为了解决输出句子不通顺的问题，我们可以选择累积概率最大的那一个，但是这就意味着句子将会特别长，不方便进行保存。

        为了解决以上两个问题，我们采用Beam Search。假设Beam width=2，表示每次保存的最大的概率的个数，这里每次保存两个，在下一个时间步骤一样，也是保留两个，这样就可以达到约束搜索空间大小的目的，从而提高算法的效率。

        Beam Search的实现，用数据结构大根堆。  

  1. class Beam:
  2.     def __init__(self):
  3.         self.heap = list() #保存数据的位置
  4.         self.beam_width = config.beam_width #保存数据的总数
  5.  
  6.     def add(self,probility,complete,seq,decoder_input,decoder_hidden):
  7.         """
  8.         添加数据，同时判断总的数据个数，多则删除
  9.         :param probility: 概率乘积
  10.         :param complete: 最后一个是否为EOS
  11.         :param seq: list，所有token的列表
  12.         :param decoder_input: 下一次进行解码的输入，通过前一次获得
  13.         :param decoder_hidden: 下一次进行解码的hidden，通过前一次获得
  14.         :return:
  15.         """
  16.         heapq.heappush(self.heap,[probility,complete,seq,decoder_input,decoder_hidden])
  17.         #判断数据的个数，如果大，则弹出。保证数据总个数小于等于3
  18.         if len(self.heap)>self.beam_width:
  19.             heapq.heappop(self.heap)
  20.  
  21.     def __iter__(self):#让该beam能够被迭代
  22.         return iter(self.heap)

        在seq2seq中加入以下方法：

  1. # decoder中的新方法
  2. def evaluatoin_beamsearch_heapq(self,encoder_outputs,encoder_hidden):
  3.     """使用 堆 来完成beam search，对是一种优先级的队列，按照优先级顺序存取数据"""
  4.  
  5.     batch_size = encoder_hidden.size(1)
  6.     #1. 构造第一次需要的输入数据，保存在堆中
  7.     decoder_input = torch.LongTensor([[word_sequence.SOS] * batch_size]).to(config.device)
  8.     decoder_hidden = encoder_hidden #需要输入的hidden
  9.  
  10.     prev_beam = Beam()
  11.     prev_beam.add(1,False,[decoder_input],decoder_input,decoder_hidden)
  12.     while True:
  13.         cur_beam = Beam()
  14.         #2. 取出堆中的数据，进行forward_step的操作，获得当前时间步的output，hidden
  15.         #这里使用下划线进行区分
  16.         for _probility,_complete,_seq,_decoder_input,_decoder_hidden in prev_beam:
  17.             #判断前一次的_complete是否为True，如果是，则不需要forward
  18.             #有可能为True，但是概率并不是最大
  19.             if _complete == True:
  20.                 cur_beam.add(_probility,_complete,_seq,_decoder_input,_decoder_hidden)
  21.             else:
  22.                 decoder_output_t, decoder_hidden,_ = self.forward_step(_decoder_input, _decoder_hidden,encoder_outputs)
  23.                 value, index = torch.topk(decoder_output_t, config.beam_width)  # [batch_size=1,beam_widht=3]
  24.              #3. 从output中选择topk（k=beam width）个输出，作为下一次的input
  25.             	for m, n in zip(value[0], index[0]):
  26.                     decoder_input = torch.LongTensor([[n]]).to(config.device)
  27.                     seq = _seq + [n]
  28.                     probility = _probility * m
  29.                     if n.item() == word_sequence.EOS:
  30.                     	complete = True
  31.                     else:
  32.                         complete = False
  33.  
  34.                  	#4. 把下一个实践步骤需要的输入等数据保存在一个新的堆中
  35.                 	  cur_beam.add(probility,complete,seq,
  36.                                    decoder_input,decoder_hidden)
  37.           #5. 获取新的堆中的优先级最高（概率最大）的数据，判断数据是否是EOS结尾或者是否达到最大长度，如果是，停止迭代
  38.           best_prob,best_complete,best_seq,_,_ = max(cur_beam)
  39.          if best_complete == True or len(best_seq)-1 == config.max_len: #减去sos
  40.             return self._prepar_seq(best_seq)
  41.          else:
  42.             #6. 则重新遍历新的堆中的数据
  43.             prev_beam = cur_beam
  44.                                     
  45.       def _prepar_seq(self,seq):#对结果进行基础的处理，共后续转化为文字使用
  46.         if seq[0].item() == word_sequence.SOS:
  47.             seq=  seq[1:]
  48.         if  seq[-1].item() == word_sequence.EOS:
  49.             seq = seq[:-1]
  50.         seq = [i.item() for i in seq]
  51.         return seq

五、优化

（一）tearch forcing

        在RNN的训练中，如果把前一个预测结果作为下一步step的输入，可能会导致步步错，可以考虑在训练过程中将真实值作为下一步输入，也可以用预测结果进行输入，这两种方式交替使用。

  1. use_teacher_forcing = random.random() > 0.5
  2. if use_teacher_forcing: #使用teacher forcing
  3.     for t in range(config.max_len):
  4.         decoder_output_t, decoder_hidden, decoder_attn_t = self.forward_step(decoder_input, decoder_hidden,
  5.                                                                              encoder_outputs)
  6.         decoder_outputs[:, t, :] = decoder_output_t
  7.         #使用正确的输出作为下一步的输入
  8.         decoder_input = target[:, t].unsqueeze(1)  # [batch_size,1]
  9.  
  10. else:#不适用teacher forcing，使用预测的输出作为下一步的输入
  11.     for t in range(config.max_len):
  12.         decoder_output_t ,decoder_hidden,decoder_attn_t = self.forward_step(decoder_input,decoder_hidden,encoder_outputs)
  13.         decoder_outputs[:,t,:] = decoder_output_t
  14.         value, index = torch.topk(decoder_output_t, 1) # index [batch_size,1]
  15.         decoder_input = index

（二）对于梯度消失和梯度爆炸的解决方法

        梯度裁剪：设置一个阈值，利用nn.utils.clip_grad_norm_方法

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/498101
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号