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

闲聊机器人之Seq2Seq模型的原理_seq2seq模型原理

作者：Cpp五条 | 2024-04-05 16:04:26

赞

踩

seq2seq模型原理

闲聊机器人之Seq2Seq模型的原理

闲聊机器人的介绍

在项目准备阶段我们知道，用户说了一句话后，会判断其意图，如果是想进行闲聊，那么就会调用闲聊模型返回结果，这是我们会在项目中实现的功能。

目前市面上的常见闲聊机器人有微软小冰这种类型的模型，很久之前还有小黄鸡这种体验更差的模型

常见的闲聊模型都是一种seq2seq的结构，接下来使用seq2seq来实现我们的闲聊机器人。

Seq2Seq模型的原理

1. Seq2Seq的介绍

Sequence to sequence (seq2seq)是由encoder（编码器）和decoder（解码器）两个RNN的组成的。其中encoder负责对输入句子的理解，转化为context vector，decoder负责对理解后的句子的向量进行处理，解码，获得输出。上述的过程和我们大脑理解东西的过程很相似，听到一句话，理解之后，尝试组装答案，进行回答

那么此时，就有一个问题，在encoder的过程中得到的context vector作为decoder的输入，那么这样一个输入，怎么能够得到多个输出呢？

其实就是当前一步的输出，作为下一个单元的输入，然后得到结果

  1. outputs = []
  2. while True:
  3.     output = decoderd(output)
  4.     outputs.append(output)

那么循环什么时候停止呢？

在训练数据集中，可以再输出的最后面添加一个结束符<END>，如果遇到该结束符，则可以终止循环

  1. outputs = []
  2. while output!="<END>":
  3.     output = decoderd(output)
  4.     outputs.append(output)

这个结束符只是一个标记，很多人也会使用<EOS>(End Of Sentence)

总之：Seq2seq模型中的encoder接受一个长度为M的序列，得到1个 context vector，之后decoder把这一个context vector转化为长度为N的序列作为输出，从而构成一个M to N的模型，能够处理很多不定长输入输出的问题，比如：文本翻译，问答，文章摘要，关键字写诗等等

 

2. Seq2Seq模型的实现

下面，通过一个简单的列子，来看看普通的Seq2Seq模型应该如何实现。

需求：完成一个模型，实现往模型输入一串数字，输出这串数字+0

例如：

  • 输入123456789，输出1234567890；

  • 输入52555568，输出525555680

2.1 实现流程

  1. 文本转化为序列（数字序列，torch.LongTensor）

  2. 使用序列，准备数据集，准备Dataloader

  3. 完成编码器

  4. 完成解码器

  5. 完成seq2seq模型

  6. 完成模型训练的逻辑，进行训练

  7. 完成模型评估的逻辑，进行模型评估

2.2 文本转化为序列

由于输入的是数字，为了把这些数字和词典中的真实数字进行对应，可以把这些数字理解为字符串

那么我们需要做的就是：

  1. 把字符串对应为数字

  2. 把数字转化为字符串

完成逻辑和之前相同，创建word_sequence.py文件，实现上述逻辑

  1. class NumSequence:
  2.     UNK_TAG = "UNK"  # 未知词
  3.     PAD_TAG = "PAD"  # 填充词，实现文本对齐，即一个batch中的句子长度都是相同的，短句子会被padding
  4.     EOS_TAG = "EOS"  # 句子的开始
  5.     SOS_TAG = "SOS"  # 句子的结束
  6.  
  7.     UNK = 0
  8.     PAD = 1
  9.     EOS = 2
  10.     SOS = 3
  11.  
  12.     def __init__(self):
  13.         self.dict = {
  14.             self.UNK_TAG: self.UNK,
  15.             self.PAD_TAG: self.PAD,
  16.             self.EOS_TAG: self.EOS,
  17.             self.SOS_TAG: self.SOS
  18.         }
  19.         # 得到字符串和数字对应的字典
  20.         for i in range(10):
  21.             self.dict[str(i)] = len(self.dict)  # 随着i的增加，len(dict)++
  22.         # 得到数字和字符串对应的字典
  23.         self.index2word = dict(zip(self.dict.values(), self.dict.keys()))
  24.  
  25.     def __len__(self):
  26.         return len(self.dict)
  27.  
  28.     # 把sentence转化为数字序列
  29.     def transform(self, sequence, max_len=None, add_eos=False):
  30.         """
  31.         sequence：句子
  32.         max_len :句子的最大长度
  33.         add_eos:是否添加结束符
  34.         """
  35.  
  36.         sequence_list = list(str(sequence))
  37.         seq_len = len(sequence_list) + 1 if add_eos else len(sequence_list)
  38.  
  39.         if add_eos and max_len is not None:
  40.             assert max_len >= seq_len, "max_len 需要大于seq+eos的长度"
  41.         _sequence_index = [self.dict.get(i, self.UNK) for i in sequence_list]
  42.         if add_eos:
  43.             _sequence_index += [self.EOS]
  44.         if max_len is not None:
  45.             sequence_index = [self.PAD] * max_len
  46.             sequence_index[:seq_len] = _sequence_index
  47.             return sequence_index
  48.         else:
  49.             return _sequence_index
  50.  
  51.     # 把序列转回字符串
  52.     def inverse_transform(self, sequence_index):
  53.         result = []
  54.         for i in sequence_index:
  55.             if i == self.EOS:
  56.                 break
  57.             result.append(self.index2word.get(int(i), self.UNK_TAG))
  58.         return result
  59.  
  60.  
  61. # 实例化，供后续调用
  62. num_sequence = NumSequence()
  63.  
  64. if __name__ == '__main__':
  65.     num_sequence = NumSequence()
  66.     print(num_sequence.dict)
  67.     print(num_sequence.index2word)
  68.     print(num_sequence.transform("1231230", add_eos=True))
  69.     print(num_sequence.transform("1231230", add_eos=False))
  70.     print(num_sequence.transform("1231230AX", add_eos=True))
  71.     print(num_sequence.inverse_transform([1, 12, 3]))

运行结果：

 

2.3 准备数据集

2.3.1 准备Dataset  【在样本的target中，需要实现EOS、SOS分别表示句子的开始和结束；在target中需要添加EOS，在transform中需要实现添加EOS的操作】

这里，我们使用随机创建的[0,100000000]的整型，来准备数据集

  1. from torch.utils.data import Dataset, DataLoader
  2. import numpy as np
  3.  
  4.  
  5. class RandomDataset(Dataset):
  6.     def __init__(self):
  7.         super(RandomDataset, self).__init__()
  8.         self.total_data_size = 500000
  9.         np.random.seed(10)
  10.         self.total_data = np.random.randint(1, 100000000, size=[self.total_data_size])
  11.  
  12.     def __getitem__(self, idx):
  13.         """返回input，target，input_length,target_length(真实长度)"""
  14.         input = str(self.total_data[idx])
  15.         return input, input + "0", len(input), len(input) + 1
  16.  
  17.     def __len__(self):
  18.         return self.total_data_size

通过随机数的结果，可以看到，大部分的数字长度为8，在目标值后面添加上0和EOS之后，最大长度为10

所以常见config配置文件，添加上max_len：文本最大长度，方便后续的修改

2.3.2 准备DataLoader

在准备DataLoader的过程中，可以通过定义的collate_fn来实现对dataset中batch数据的处理

其中需要注意：

  1. 需要对batch中的数据进行排序，根据数据的真实长度进行降序排序（后面需要用到）

  2. 需要调用文本序列化的方法，把文本进行序列化的操作，同时target需要进行add eos的操作

  3. 最后返回序列的LongTensor格式

  4. 在DataLoader中有drop_last参数，当数据量无法被batch_size整除时，最后一个batch的数据个数和之前的数据个数长度不同，可以考虑进行删除

  1. def collate_fn(batch):
  2.     # 1. 对batch进行排序，按照长度从长到短的顺序排序
  3.     batch = sorted(batch, key=lambda x: x[3], reverse=True)
  4.     input, target, input_length, target_length = zip(*batch)
  5.  
  6.     # 2.进行padding的操作
  7.     input = torch.LongTensor([num_sequence.transform(i, max_len=config.max_len) for i in input])
  8.     target = torch.LongTensor([num_sequence.transform(i, max_len=config.max_len, add_eos=True) for i in target])
  9.     input_length = torch.LongTensor(input_length)
  10.     target_length = torch.LongTensor(target_length)
  11.  
  12.     return input, target, input_length, target_length
  13.  
  14.  
  15. data_loader = DataLoader(dataset=RandomDataset(), batch_size=config.batch_size, collate_fn=collate_fn, drop_last=True)

Dataset,Dataloader 完整代码：

config.py

  1. from word_sequence import NumSequence
  2.  
  3. train_batch_size = 128
  4. num_sequence = NumSequence()
  5. max_len = 9

word_sequence.py   【此文件和上面的稍微有点区别】

  1. class NumSequence(object):
  2.     PAD_TAG = 'PAD'  # 填充标记
  3.     UNK_TAG = 'UNK'  # 未知词标记
  4.     SOS_TAG = 'SOS'  # strat of sequence
  5.     EOS_TAG = 'EOS'  # end of sequence
  6.  
  7.     PAD = 0
  8.     UNK = 1
  9.     SOS = 2
  10.     EOS = 3
  11.  
  12.     def __init__(self):
  13.         self.dict = {
  14.             self.PAD_TAG: self.PAD,
  15.             self.UNK_TAG: self.UNK,
  16.             self.SOS_TAG: self.SOS,
  17.             self.EOS_TAG: self.EOS
  18.         }
  19.         for i in range(10):
  20.             self.dict[str(i)] = len(self.dict)
  21.  
  22.         self.inverse_dict = dict(zip(self.dict.values(), self.dict.keys()))
  23.  
  24.     def transform(self, sentence, max_len, add_eos=False):
  25.         """
  26.         把sentence 转化为 序列
  27.         :param max_len 句子最大长度
  28.         :param add_eos 是否添加结束符
  29.         add_eos : True时，输出句子长度为max_len + 1
  30.         add_eos : False时，输出句子长度为max_len
  31.         :return:
  32.         """
  33.         if len(sentence) > max_len:
  34.             sentence = sentence[:max_len]
  35.  
  36.         # 提前计算句子长度,实现add_eos后,句子长度统一
  37.         sentence_len = len(sentence)
  38.  
  39.         # sentence[1,3,4,5,UNK,EOS,PAD,PAD....]
  40.         if add_eos:
  41.             sentence += [self.EOS_TAG]
  42.  
  43.         if sentence_len < max_len:
  44.             # 句子长度不够，用PAD填充
  45.             sentence += (max_len - sentence_len) * [self.PAD_TAG]
  46.         # 对于新出现的词采用特殊标记
  47.         result = [self.dict.get(i, self.UNK) for i in sentence]
  48.  
  49.         return result
  50.  
  51.     def invert_transform(self, indices):
  52.         """
  53.         序列转化为sentence
  54.         :param indices:
  55.         :return:
  56.         """
  57.         return [self.inverse_dict.get(i, self.UNK_TAG) for i in indices]
  58.  
  59.  
  60. if __name__ == '__main__':
  61.     num_sequence = NumSequence()
  62.     print(num_sequence.dict)
  63.     print(num_sequence.inverse_dict)

dataset.py

  1. """
  2. 准备数据集,准备dataset,dataloader
  4. """
  5. import config
  6. from torch.utils.data import Dataset, DataLoader
  7. import numpy as np
  8. import torch
  9.  
  10.  
  11. class NumDataset(Dataset):
  12.     def __init__(self):
  13.         # 使用numpy随机创建, 1e8 = 10^8
  14.         self.data = np.random.randint(0, 1e8, size=[500000])
  15.  
  16.     def __getitem__(self, index):
  17.         input = list(str(self.data[index]))
  18.         target = input + ['0']
  19.         input_lenth = len(input)
  20.         target_lenth = len(target)
  21.         # target_length = input_length + 1
  22.         return input, target, input_lenth, target_lenth
  23.  
  24.     def __len__(self):
  25.         return self.data.shape[0]
  26.  
  27.  
  28. def collate_fn(batch):
  29.     """
  31.     :param batch:[(input,target,input_length,target_length),...,]
  32.     :return:
  33.     """
  34.     batch = sorted(batch, key=lambda x: x[3], reverse=True)
  35.     input, target, input_length, target_length = list(zip(*batch))
  36.     # 把input 转化为序列
  37.     input = torch.LongTensor([config.num_sequence.transform(i, max_len=config.max_len) for i in input])
  38.     target = torch.LongTensor(
  39.         [config.num_sequence.transform(i, max_len=config.max_len + 1, 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.  
  46. train_dataloader = DataLoader(NumDataset(), batch_size=config.train_batch_size, shuffle=True, collate_fn=collate_fn)
  47.  
  48. if __name__ == '__main__':
  49.     for input, target, input_length, target_length in train_dataloader:
  50.         print(input.size())
  51.         print(target.size())
  52.         print(input)
  53.         print(target)
  54.         print(input_length)
  55.         print(target_length)
  56.         break

运行结果：

2.4 准备编码器

编码器（encoder）的目的就是为了对文本进行编码，把编码后的结果交给后续的程序使用，所以在这里可以使用Embedding+GRU的结构来使用，使用最后一个time step的输出(hidden state)作为句子的编码结果

注意点：

  1. Embedding和GRU的参数,这里我们让GRU中batch放在前面

  2. 输出结果的形状

  3. 在LSTM和GRU中，每个time step的输入会进行计算，得到结果，整个过程是一个和句子长度相关的一个循环，手动实现速度较慢

    1. pytorch中实现了nn.utils.rnn.pack_padded_sequence 对padding后的句子进行打包的操作能够更快获得LSTM or GRU的结果

    2. 同时实现了nn.utils.rnn.pad_packed_sequence对打包的内容进行解包的操作

  4. nn.utils.rnn.pack_padded_sequence使用过程中需要对batch中的内容按照句子的长度降序排序

（batch = sorted(batch, key = lambda x : x[3], reverse = True)------->batch:[(input,target,input_length,target_length),...,]）

  1. embeded = nn.utils.rnn.pack_padded_sequence
  2. 		(
  3. 			embeded,
  4. 			lengths=input_length, # 真实长度
  5. 			batch_first=True
  6. 	)
  7. out,outputs_length = nn.utils.rnn.pad_packed_sequence
  8. 		(
  9. 			out,
  10. 			batch_first=True,
  11. 			padding_value=num_sequence.PAD  # 填充值
  12. 	)

实现代码如下：

  1. import torch.nn as nn
  2. from word_sequence import num_sequence
  3. import config
  4.  
  5.  
  6. class NumEncoder(nn.Module):
  7.     def __init__(self):
  8.         super(NumEncoder, self).__init__()
  9.         self.vocab_size = len(num_sequence)
  10.         self.dropout = config.dropout
  11.         self.embedding = nn.Embedding(num_embeddings=self.vocab_size, embedding_dim=config.embedding_dim,
  12.                                       padding_idx=num_sequence.PAD)
  13.         self.gru = nn.GRU(input_size=config.embedding_dim,
  14.                           hidden_size=config.hidden_size,
  15.                           num_layers=1,
  16.                           batch_first=True)
  17.  
  18.     def forward(self, input, input_length):
  19.         """
  20.         input:[batch_size,max_len]
  21.         input_length:[batch_size]
  22.         """
  23.         embeded = self.embedding(input)  # [batch_size,max_len , embedding_dim]
  24.  
  25.         # 对文本对齐之后的句子进行打包，能够加速在LSTM or GRU中的计算过程
  26.         embeded = nn.utils.rnn.pack_padded_sequence(embeded, lengths=input_length, batch_first=True)
  27.  
  28.         # hidden:[1,batch_size,vocab_size]
  29.         out, hidden = self.gru(embeded)
  30.  
  31.         # 对前面打包后的结果再进行解包
  32.         out, outputs_length = nn.utils.rnn.pad_packed_sequence(out, batch_first=True, padding_value=num_sequence.PAD)
  33.         # out [batch_size,seq_len,hidden_size]
  34.         return out, hidden

完整实现代码：

config.py

  1. import torch
  2. from word_sequence import NumSequence
  3.  
  4. train_batch_size = 128
  5. num_sequence = NumSequence()
  6. max_len = 9
  7. embedding_dim = 100
  8. num_layer = 1
  9. hidden_size = 64
  10. model_save_path = './model.pkl'
  11. optimizer_save_path = './optimizer.pkl'
  12. device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')

encode.py

  1. """
  2. 编码器
  3. """
  4. import torch.nn as nn
  5. import config
  6. from torch.nn.utils.rnn import pad_packed_sequence, pack_padded_sequence
  7.  
  8.  
  9. class Encoder(nn.Module):
  10.     def __init__(self):
  11.         super(Encoder, self).__init__()
  12.         #  torch.nn.Embedding(num_embeddings词典大小即不重复词数,embedding_dim单个词用多长向量表示)
  13.         self.embedding = nn.Embedding(
  14.             num_embeddings=len(config.num_sequence.dict),
  15.             embedding_dim=config.embedding_dim,
  16.             padding_idx=config.num_sequence.PAD
  17.         )
  18.         self.gru = nn.GRU(
  19.             input_size=config.embedding_dim,
  20.             num_layers=config.num_layer,
  21.             hidden_size=config.hidden_size,
  22.             bidirectional=False,
  23.             batch_first=True
  24.         )
  25.  
  26.     def forward(self, input, input_length):
  27.         """
  28.         :param input: [batch_size, max_len]
  29.         :return:
  30.         """
  31.         embedded = self.embedding(input)  # embedded [batch_size, max_len, embedding_dim]
  32.         # 加速循环过程
  33.         embedded = pack_padded_sequence(embedded, input_length, batch_first=True)  # 打包
  34.         out, hidden = self.gru(embedded)
  35.         out, out_length = pad_packed_sequence(out, batch_first=True, padding_value=config.num_sequence.PAD)  # 解包
  36.  
  37.         # hidden即h_n [num_layer*[1/2],batchsize, hidden_size]
  38.         # out : [batch_size, seq_len/max_len, hidden_size]
  39.         return out, hidden, out_length
  40.  
  41.  
  42. if __name__ == '__main__':
  43.     from dataset import train_dataloader
  44.  
  45.     encoder = Encoder()
  46.     print(encoder)
  47.     for input, target, input_length, target_length in train_dataloader:
  48.         out, hidden, out_length = encoder(input, input_length)
  49.         print(input.size())
  50.         print(out.size())
  51.         print(hidden.size())
  52.         print(out_length)
  53.         break

运行结果：

  1. Encoder(
  2.   (embedding): Embedding(14, 100, padding_idx=0)
  3.   (gru): GRU(100, 64, batch_first=True)
  4. )
  5. torch.Size([128, 9])
  6. torch.Size([128, 8, 64])
  7. torch.Size([1, 128, 64])
  8. tensor([8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  9.         8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  10.         8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  11.         8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  12.         8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 7, 7, 7,
  13.         7, 7, 7, 7, 7, 7, 7, 6])
  14.  
  15. Process finished with exit code 0

2.5 实现解码器

加码器主要负责实现对编码之后结果的处理，得到预测值，为后续计算损失做准备

此时需要思考：

  1. 使用什么样的损失函数，预测值需要是什么格式的

    • 结合之前的经验，我们可以理解为当前的问题是一个分类的问题，即每次的输出其实对选择一个概率最大的词

    • 真实值的形状是[batch_size,max_len]，从而我们知道输出的结果需要是一个[batch_size,max_len,vocab_size]的形状

    • 即预测值的最后一个维度进行计算log_softmax,然后和真实值进行相乘，从而得到损失

  2. 如何把编码结果[1,batch_size,hidden_size]进行操作，得到预测值。解码器也是一个RNN，即也可以使用LSTM or GRU的结构，所以在解码器中：

    • 通过循环，每次计算的一个time step的内容

    • 编码器的结果作为初始的隐层状态，定义一个[batch_size,1]的全为SOS的数据作为最开始的输入，告诉解码器，要开始工作了

    • 通过解码器预测一个输出[batch_size,hidden_size](会进行形状的调整为[batch_size,vocab_size])，把这个输出作为输入再使用解码器进行解码

    • 上述是一个循环，循环次数就是句子的最大长度，那么就可以得到max_len个输出

    • 把所有输出的结果进行concate，得到[batch_size,max_len,vocab_size]

  3. 在RNN的训练过程中，使用前一个预测的结果作为下一个step的输入，可能会导致一步错，步步错的结果，如果提高模型的收敛速度？

    • 可以考虑在训练的过程中，把真实值作为下一步的输入，这样可以避免步步错的局面

    • 同时在使用真实值的过程中，仍然使用预测值作为下一步的输入，两种输入随机使用

    • 上述这种机制我们把它称为Teacher forcing，就像是一个指导老师，在每一步都会对我们的行为进行纠偏，从而达到在多次训练之后能够需要其中的规律

示例代码：

  1. import torch
  2. import torch.nn as nn
  3. import config
  4. import random
  5. import torch.nn.functional as F
  6. from word_sequence import num_sequence
  7.  
  8.  
  9. class NumDecoder(nn.Module):
  10.     def __init__(self):
  11.         super(NumDecoder, self).__init__()
  12.         self.max_seq_len = config.max_len
  13.         self.vocab_size = len(num_sequence)
  14.         self.embedding_dim = config.embedding_dim
  15.         self.dropout = config.dropout
  16.  
  17.         self.embedding = nn.Embedding(num_embeddings=self.vocab_size, embedding_dim=self.embedding_dim,
  18.                                       padding_idx=num_sequence.PAD)
  19.         self.gru = nn.GRU(input_size=self.embedding_dim,
  20.                           hidden_size=config.hidden_size,
  21.                           num_layers=1,
  22.                           batch_first=True,
  23.                           dropout=self.dropout)
  24.         self.log_softmax = nn.LogSoftmax()
  25.  
  26.         self.fc = nn.Linear(config.hidden_size, self.vocab_size)
  27.  
  28.     def forward(self, encoder_hidden, target, target_length):
  29.         # encoder_hidden [batch_size,hidden_size]
  30.         # target [batch_size,max_len]
  31.  
  32.         # 初始的全为SOS的输入
  33.         decoder_input = torch.LongTensor([[num_sequence.SOS]] * config.batch_size)
  34.  
  35.         # 解码器的输出，用来后保存所有的输出结果
  36.         decoder_outputs = torch.zeros(config.batch_size, config.max_len, self.vocab_size)
  37.  
  38.         decoder_hidden = encoder_hidden  # [batch_size,hidden_size]
  39.  
  40.         for t in range(config.max_len):
  41.             decoder_output_t, decoder_hidden = self.forward_step(decoder_input, decoder_hidden)
  42.  
  43.             # 在不同的time step上进行复制，decoder_output_t [batch_size,vocab_size]
  44.             decoder_outputs[:, t, :] = decoder_output_t
  45.  
  46.             # 在训练的过程中，使用 teacher forcing，进行纠偏
  47.             use_teacher_forcing = random.random() > 0.5
  48.             if use_teacher_forcing:
  49.                 # 下一次的输入使用真实值
  50.                 decoder_input = target[:, t].unsqueeze(1)  # [batch_size,1]
  51.             else:
  52.                 # 使用预测值，topk中k=1，即获取最后一个维度的最大的一个值
  53.                 value, index = torch.topk(decoder_output_t, 1)  # index [batch_size,1]
  54.                 decoder_input = index
  55.         return decoder_outputs, decoder_hidden
  56.  
  57.     def forward_step(self, decoder_input, decoder_hidden):
  58.         """
  59.         :param decoder_input:[batch_size,1]
  60.         :param decoder_hidden: [1,batch_size,hidden_size]
  61.         :return: out:[batch_size,vocab_size],decoder_hidden:[1,batch_size,didden_size]
  62.         """
  63.         embeded = self.embedding(decoder_input)  # embeded: [batch_size,1 , embedding_dim]
  64.  
  65.         out, decoder_hidden = self.gru(embeded, decoder_hidden)  # out [1, batch_size, hidden_size]
  66.  
  67.         out = out.squeeze(0)  # 去除第0维度的1
  68.         # 进行全连接形状变化，同时进行求取log_softmax
  69.         out = F.log_softmax(self.fc(out), dim=-1)  # out [batch_Size,1, vocab_size]
  70.         out = out.squeeze(1)
  71.         return out, decoder_hidden

完整代码实现：

decode.py

  1. """
  2. 实现解码器
  3. """
  4. import torch.nn as nn
  5. import config
  6. import torch
  7. import torch.nn.functional as F
  8.  
  9.  
  10. class Decoder(nn.Module):
  11.     def __init__(self):
  12.         super(Decoder, self).__init__()
  13.         self.embedding = nn.Embedding(
  14.             num_embeddings=len(config.num_sequence),
  15.             embedding_dim=config.embedding_dim,
  16.             padding_idx=config.num_sequence.PAD
  17.         )
  18.         self.gru = nn.GRU(
  19.             input_size=config.embedding_dim,
  20.             hidden_size=config.hidden_size,
  21.             num_layers=config.num_layer,
  22.             batch_first=True,
  23.             bidirectional=False
  24.         )
  25.         self.fc = nn.Linear(config.hidden_size, len(config.num_sequence))
  26.  
  27.     def forward(self, target, encoder_hidden):
  28.         # 1.获取encoder最后一次的输出,作为decoder第一次的隐藏状态
  29.         decoder_hidden = encoder_hidden
  30.         batch_size = target.size(0)
  31.         # 2.准备第一次decoder第一个时间步的输入,[batch_size,1]的SOS作为输入
  32.         decoder_input = torch.LongTensor(torch.ones([batch_size, 1], dtype=torch.int64) * config.num_sequence.SOS).to(
  33.             config.device)
  34.         # 3.在第一个时间步上进行计算,得到第一个时间步的输出,hidden_state
  35.         # 4.对前一个时间步的输出进行计算,得到第一个最后的输出的结果
  36.         # 5.把前一次的hidden_state作为当前时间步的hidden_state的输入，把前一次的输出，作为当前时间步的输入
  37.         # 6.循环4-5
  38.  
  39.         # 保存预测结果
  40.         # output:[batch_size, vocab_size]
  41.         decoder_outputs = torch.zeros([batch_size, config.max_len + 2, len(config.num_sequence)]).to(config.device)
  42.  
  43.         # config.max_len+2 dataset中获取target时,max_len+1且add_eos=True,因此+2
  44.         for t in range(config.max_len + 2):
  45.             # 当前时刻的输出和隐藏状态
  46.             decoder_output_t, decoder_hidden = self.forward_step(decoder_input, decoder_hidden)
  47.             # 保存decoder_output_t到decoder_outputs中
  48.             decoder_outputs[:, t, :] = decoder_output_t
  49.             # 使用预测值，topk中k = 1，即获取最后一个维度的最大的一个值
  50.             value, index = torch.topk(decoder_output_t, k=1)
  51.             # 获取下一次的input
  52.             decoder_input = index
  53.         return decoder_outputs, decoder_hidden
  54.  
  55.     def forward_step(self, decoder_input, decoder_hidden):
  56.         """
  57.         计算每个时间步上的结果
  58.         :param decoder_input: [batch_size, 1]
  59.         :param decoder_hidden: [num_layer * [1/2],batch_size, hidden_size] decoder_hidden也就是encoder最后一次的隐藏状态
  60.         :return:
  61.         """
  62.         decoder_input_embedded = self.embedding(decoder_input)  # [batch_size, 1] -->[batch_size, 1, embedding_dim]
  63.         # out [batch_size, 1, hidden_size]
  64.         # decoder_hidden [num_layer*[1/2],batch_size,hidden_size]
  65.         out, decoder_hidden = self.gru(decoder_input_embedded, decoder_hidden)
  66.         out = out.squeeze(1)  # [batch_size, 1, hidden_size] --> [batch_size, hidden_size]
  67.         output = F.log_softmax(self.fc(out), dim=-1)  # fc后,out [batch_size, hidden_size]-->[batch_size, vocab_size]
  68.         # print('output:',output.size())
  69.         return output, decoder_hidden

2.6 完成seq2seq模型

调用之前的encoder和decoder，完成模型的搭建  【合并encode和decode】

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

2.7 完成训练逻辑

思路流程和之前相同

示例代码：

  1. import torch
  2. import config
  3. from torch import optim
  4. import torch.nn as nn
  5. from encoder import NumEncoder
  6. from decoder import NumDecoder
  7. from seq2seq import Seq2Seq
  8. from dataset import data_loader as train_dataloader
  9. from word_sequence import num_sequence
  10.  
  11. encoder = NumEncoder()
  12. decoder = NumDecoder()
  13. model = Seq2Seq(encoder, decoder)
  14. print(model)
  15.  
  16. # 自定义初始化参数
  17. # for name, param in model.named_parameters():
  18. #    if 'bias' in name:
  19. #        torch.nn.init.constant_(param, 0.0)
  20. #    elif 'weight' in name:
  21. #        torch.nn.init.xavier_normal_(param)
  22.  
  23. # model.load_state_dict(torch.load("model/seq2seq_model.pkl"))
  24. optimizer = optim.Adam(model.parameters())
  25. # optimizer.load_state_dict(torch.load("model/seq2seq_optimizer.pkl"))
  26. criterion = nn.NLLLoss(ignore_index=num_sequence.PAD, reduction="mean")
  27.  
  28.  
  29. def get_loss(decoder_outputs, target):
  30.     # 很多时候如果tensor进行了转置等操作，直接调用view进行形状的修改是无法成功的
  31.     # target = target.contiguous().view(-1) #[batch_size*max_len]
  32.     target = target.view(-1)
  33.     decoder_outputs = decoder_outputs.view(config.batch_size * config.max_len, -1)
  34.     return criterion(decoder_outputs, target)
  35.  
  36.  
  37. def train(epoch):
  38.     for idx, (input, target, input_length, target_len) in enumerate(train_dataloader):
  39.         optimizer.zero_grad()
  40.         ##[seq_len,batch_size,vocab_size] [batch_size,seq_len]
  41.         decoder_outputs, decoder_hidden = model(input, target, input_length, target_len)
  42.         loss = get_loss(decoder_outputs, target)
  43.         loss.backward()
  44.         optimizer.step()
  45.  
  46.         print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
  47.             epoch, idx * len(input), len(train_dataloader.dataset),
  48.                    100. * idx / len(train_dataloader), loss.item()))
  49.  
  50.         torch.save(model.state_dict(), "model/seq2seq_model.pkl")
  51.         torch.save(optimizer.state_dict(), 'model/seq2seq_optimizer.pkl')
  52.  
  53.  
  54. if __name__ == '__main__':
  55.     for i in range(10):
  56.         train(i)

完整代码：

seq2seq.py

  1. import torch.nn as nn
  2. from encode import Encoder
  3. from decode import Decoder
  4.  
  5. encoder = Encoder()
  6. decoder = Decoder()
  7.  
  8.  
  9. class Seq2Seq(nn.Module):
  10.     def __init__(self):
  11.         super(Seq2Seq, self).__init__()
  12.         self.encoder = Encoder()
  13.         self.decoder = Decoder()
  14.  
  15.     def forward(self, input, target, input_length, target_length):
  16.         # 进行编码
  17.         encoder_outputs, encoder_hidden, out_length = self.encoder(input, input_length)
  18.         # 进行解码
  19.         # decoder_outputs, decoder_hidden = self.decoder(encoder_hidden, target, target_length)
  20.         decoder_outputs, decoder_hidden = self.decoder(target, encoder_hidden)
  21.         return decoder_outputs, decoder_hidden

train.py

  1. from dataset import train_dataloader
  2. import os
  3. from encode import Encoder
  4. from decode import Decoder
  5. from seq2seq import Seq2Seq
  6. from torch.optim import Adam
  7. import torch.nn.functional as F
  8. import config
  9. from tqdm import tqdm
  10. import torch
  11.  
  12. # 训练流程
  13. # 1.实例化model, optimizer, loss
  14. # seq2seq = Seq2Seq(encoder, decoder).to(config.device)
  15. seq2seq = Seq2Seq().to(config.device)
  16. optimizer = Adam(seq2seq.parameters(), lr=0.001)
  17. # 2.遍历dataloader
  18. # 3.调用模型得到output
  19. # 4.计算损失,更新参数
  20. if os.path.exists(config.model_save_path):
  21.     seq2seq.load_state_dict(torch.load(config.model_save_path))
  22.     optimizer.load_state_dict(torch.load(config.optimizer_save_path))
  23.  
  24.  
  25. def train(epoch):
  26.     bar = tqdm(train_dataloader, desc='训练', total=len(train_dataloader))
  27.     for index, (input, target, input_length, target_length) in enumerate(bar):
  28.  
  29.         input = input.to(config.device)
  30.         target = target.to(config.device)
  31.         input_length = input_length.to(config.device)
  32.         target_length = target_length.to(config.device)
  33.  
  34.         optimizer.zero_grad()
  35.         decoder_outputs, _decoder_hidden = seq2seq(input, target, input_length, target_length)
  36.         # print(decoder_outputs.size(), target.size())
  37.         decoder_outputs = decoder_outputs.view(decoder_outputs.size(0) * decoder_outputs.size(1),
  38.                                                -1)  # [batch_size * seq_len, -1]
  39.         target = target.view(-1)  # [batch_size * seq_len]
  40.         loss = F.nll_loss(decoder_outputs, target, ignore_index=config.num_sequence.PAD)
  41.         loss.backward()
  42.         optimizer.step()
  43.  
  44.         bar.set_description('epoch:{}\tidx{}\tloss{} '.format(epoch, index, loss.item()))
  45.  
  46.         # 5.模型保存和加载
  47.         if index % 100 == 0:
  48.             torch.save(seq2seq.state_dict(), config.model_save_path)
  49.             torch.save(optimizer.state_dict(), config.optimizer_save_path)
  50.  
  51.  
  52. if __name__ == '__main__':
  53.     for i in range(3):
  54.         train(i)

运行结果：

2.8 完成模型评估逻辑

完成评估逻辑，和decoder中的训练过程稍微不同，可以在其中新建evaluation的方法，传入encoder_hidden，得到预测的结果

  1.     def evaluation(self, encoder_hidden):  # [1, 20, 14]
  2.         batch_size = encoder_hidden.size(1)  # 评估的时候和训练的batch_size不同，不适用config的配置
  3.  
  4.         decoder_input = torch.LongTensor([[config.num_sequence.SOS] * batch_size])
  5.         decoder_outputs = torch.zeros(batch_size, config.max_len, self.vocab_size)  # [batch_size，seq_len,vocab_size]
  6.         decoder_hidden = encoder_hidden
  7.  
  8.         # 评估，不再使用teacher forcing，完全使用预测值作为下一次的输入
  9.         for t in range(config.max_len):
  10.             decoder_output_t, decoder_hidden = self.forward_step(decoder_input, decoder_hidden)
  11.             decoder_outputs[:, t, :] = decoder_output_t
  12.             value, index = torch.topk(decoder_output_t, 1)  # index [20,1]
  13.             decoder_input = index.transpose(0, 1)
  14.  
  15.         # 获取输出的id
  16.         decoder_indices = []  # [[1,2,4],[23,3,2]]
  17.         for i in range(config.max_len):
  18.             value, index = torch.topk(decoder_outputs[:, i, :], k=1, dim=-1)
  19.             decoder_indices.append(index.view(-1).numpy())
  20.         # transpose 调整为按句子输出
  21.         decoder_indices = np.array(decoder_indices).transpose()
  22.         return decoder_indices

之后再seq2seq的model中，添加evaluation的逻辑

示例代码：

  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

更新seq2seq.py

  1. import torch.nn as nn
  2. from encode import Encoder
  3. from decode import Decoder
  4.  
  5. encoder = Encoder()
  6. decoder = Decoder()
  7.  
  8.  
  9. class Seq2Seq(nn.Module):
  10.     def __init__(self):
  11.         super(Seq2Seq, self).__init__()
  12.         self.encoder = encoder
  13.         self.decoder = decoder
  14.  
  15.     def forward(self, input, target, input_length, target_length):
  16.         # 进行编码
  17.         encoder_outputs, encoder_hidden, out_length = self.encoder(input, input_length)
  18.         # 进行解码
  19.         # decoder_outputs, decoder_hidden = self.decoder(encoder_hidden, target, target_length)
  20.         decoder_outputs, decoder_hidden = self.decoder(target, encoder_hidden)
  21.         return decoder_outputs, decoder_hidden
  22.  
  23.     def evaluation(self, inputs, input_length):
  24.         encoder_outputs, encoder_hidden, out_length = self.encoder(inputs, input_length)
  25.         decoded_sentence = self.decoder.evaluation(encoder_hidden)
  26.         return decoded_sentence

创建eval.py，完成模型评估的逻辑

  1. import torch
  2. import config
  3. from torch import optim
  4. import torch.nn as nn
  5. from encoder import NumEncoder
  6. from decoder import NumDecoder
  7. from seq2seq import Seq2Seq
  8. from dataset import data_loader as train_dataloader
  9. from word_sequence import num_sequence
  10. import numpy as np
  11. import random
  12.  
  13.  
  14.  
  15. encoder = NumEncoder()
  16. decoder = NumDecoder()
  17. model = Seq2Seq(encoder,decoder)
  18. model.load_state_dict(torch.load("model/seq2seq_model.pkl"))
  19.  
  20. def evalaute():
  21.     data = [str(i) for i in np.random.randint(0, 100000000, [10])]
  22.     data = sorted(data,key=lambda x:len(x),reverse=True)
  23.     print(data)
  24.  
  25.     _data_length = torch.LongTensor([len(i) for i in data])
  26.     _data = torch.LongTensor([num_sequence.transform(i,max_len=config.max_len) for i in data])
  27.     output = seq2seq.evaluate(_data,_data_length)
  28.     print([num_sequence.inverse_transform(i) for i in output])
  29.  
  30. if __name__ == '__main__':
  31.     evalaute()

目前存在问题？？？

在model训练一个epoch之后，loss已经很低了,评估输出如下（为True表示预测正确）：

  1. 39304187 >>>>> 393041870 True
  2. 41020882 >>>>> 410208820 True
  3. 85784317 >>>>> 857843170 True
  4. 1394232 >>>>> 13942320 True
  5. 44548446 >>>>> 445484460 True
  6. 49457730 >>>>> 494577300 True
  7. 82451872 >>>>> 824518720 True
  8. 64380958 >>>>> 643809580 True
  9. 97501723 >>>>> 975017230 True
  10. 21656800 >>>>> 216568000 True

总结：

  1. seq2seq流程
  2. 1. encoder
  3. 	a. 对input 进行embedding
  4. 	b. 对embedding结果进行打包 pack_padded_sequence
  5. 	c. 传入gru进行计算，得到output和hidden
  6. 	d. 对output进行解包 pad_packed_sequence
  7. 2. decoder
  8. 	a. 构造起始符，构造[batch_size, 1]的SOS，作为第一个时间步的输入
  9. 	b. 对第一个时间步的输入进行embedding，得到embeded
  10. 	c. 对embedded 进行gru计算，得到output 和 hidden,hidden 作为下一个时间步的hidden,
  11. 	d. 计算第一个时间步输出的值：第一个时间步的输出进行变形，之后计算log_softmax,得到output,并获取值最大的位置dim = -1,作为第一个时间步的输出 
  12. 	out = out.squeeze(1) # [batch_size, 1, hidden_size] --> [batch_size, hidden_size]
  13.     output = F.log_softmax(self.fc(out), dim = -1)  # fc后,out [batch_size, hidden_size]-->[batch_size, vocab_size]
  14.     e. 保存output
  15.     # 保存decoder_output_t到decoder_outputs中
  16.     decoder_outputs[:, t, :] = decoder_output_t
  17. 	f. 第二个时间步，输入有：hidden和第一个时间步输出的具体值（是一个索引）,使用teacher_forcing机制,加速训练
  18. 	# 使用预测值，topk中k = 1，即获取最后一个维度的最大的一个值
  19.     value, index = torch.topk(decoder_output_t, k = 1)
  20.     	# 使用teacher_forcing机制,加速训练
  21.        if random.random() > config.teacher.focing: 
  22.            decoder_input = target[t] # [batch_size, 1]
  23.        else:
  24.            # 获取下一次的input
  25.            decoder_input = index
  26.     g. 重复b-f步，重复max_lenth次，即target长度（config.max_len+2 dataset中获取target时,max_len+1且add_eos=True,因此+2）
  27.     h. 得到decoder_outputs
  28. 3. train
  29. 	a. output 和 target 计算nll_loss(带权损失)，若是三阶，则需要变形
  30. 	decoder_outputs = decoder_outputs.view(decoder_outputs.size(0) * decoder_outputs.size(1), -1) # [batch_size * seq_len, -1]
  31.     target = target.view(-1) # [batch_size * seq_len]
  32.     loss = F.nll_loss(decoder_outputs, target, ignore_index = config.num_sequence.PAD)
  33. 4. eval
  34. 	a. 和decoder大致相同，但是不需要保存output, 只需要batch数据每个时间步的输出
  35. 	b. 每个时间步的输出放在列表中，其每一列才是输入的最终结果
  36. 	indices = seq2seq.evaluate(input, input_length)
  37. 	indices = np.array(indices).transpose()

 

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

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

  

闽ICP备14008679号