使用序列到序列模型完成数字加法

作者: jm12138

日期: 2021.01

摘要: 本示例教程介绍如何使用飞桨完成一个数字加法任务，我们将会使用飞桨提供的LSTM的API，组建一个序列到序列模型，并在随机生成的数据集上完成数字加法任务的模型训练与预测。

一、环境配置

本教程基于Paddle 2.0 编写，如果您的环境不是本版本，请先参考官网安装 Paddle 2.0 。

  1. # 导入项目运行所需的包
  3. import paddle
  4. import paddle.nn as nn
  6. import random
  7. import numpy as np
  9. from visualdl import LogWriter
  11. # 打印Paddle版本
  12. print('paddle version: %s' % paddle.__version__)
  1. paddle version: 2.0.0

二、构建数据集

  • 随机生成数据，并使用生成的数据构造数据集

  • 通过继承 paddle.io.Dataset 来完成数据集的构造

  1. # 编码函数
  2. def encoder(text, LEN, label_dict):
  3.     # 文本转ID
  4.     ids = [label_dict[word] for word in text]
  5.     # 对长度进行补齐
  6.     ids += [label_dict[' ']]*(LEN-len(ids))
  7.     return ids
  9. # 单个数据生成函数
  10. def make_data(inputs, labels, DIGITS, label_dict):
  11.     MAXLEN = DIGITS + 1 + DIGITS
  12.     # 对输入输出文本进行ID编码
  13.     inputs = encoder(inputs, MAXLEN, label_dict)
  14.     labels = encoder(labels, DIGITS + 1, label_dict)
  15.     return inputs, labels
  17. # 批量数据生成函数
  18. def gen_datas(DATA_NUM, MAX_NUM, DIGITS, label_dict):
  19.     datas = []
  20.     while len(datas)<DATA_NUM:
  21.         # 随机取两个数
  22.         a = random.randint(0,MAX_NUM)
  23.         b = random.randint(0,MAX_NUM)
  24.         # 生成输入文本
  25.         inputs = '%d+%d' % (a, b)
  26.         # 生成输出文本
  27.         labels = str(eval(inputs))
  28.         # 生成单个数据
  29.         inputs, labels = [np.array(_).astype('int64') for _ in make_data(inputs, labels, DIGITS, label_dict)]
  30.         datas.append([inputs, labels])
  31.     return datas
  33. # 继承paddle.io.Dataset来构造数据集
  34. class Addition_Dataset(paddle.io.Dataset):
  35.     # 重写数据集初始化函数
  36.     def __init__(self, datas):
  37.         super(Addition_Dataset, self).__init__()
  38.         self.datas = datas
  40.     # 重写生成样本的函数
  41.     def __getitem__(self, index):
  42.         data, label = [paddle.to_tensor(_) for _ in self.datas[index]]
  43.         return data, label
  45.     # 重写返回数据集大小的函数
  46.     def __len__(self):
  47.         return len(self.datas)
  49. print('generating datas..')
  51. # 定义字符表
  52. label_dict = {
  53.     '0': 0, '1': 1, '2': 2, '3': 3,
  54.     '4': 4, '5': 5, '6': 6, '7': 7,
  55.     '8': 8, '9': 9, '+': 10, ' ': 11
  56. }
  58. # 输入数字最大位数
  59. DIGITS = 2
  61. # 数据数量
  62. train_num = 5000
  63. dev_num = 500
  65. # 数据批大小
  66. batch_size = 32
  68. # 读取线程数
  69. num_workers = 8
  71. # 定义一些所需变量
  72. MAXLEN = DIGITS + 1 + DIGITS
  73. MAX_NUM = 10**(DIGITS)-1
  75. # 生成数据
  76. train_datas = gen_datas(
  77.     train_num,
  78.     MAX_NUM,
  79.     DIGITS,
  80.     label_dict
  81. )
  82. dev_datas = gen_datas(
  83.     dev_num,
  84.     MAX_NUM,
  85.     DIGITS,
  86.     label_dict
  87. )
  89. # 实例化数据集
  90. train_dataset = Addition_Dataset(train_datas)
  91. dev_dataset = Addition_Dataset(dev_datas)
  93. print('making the dataset...')
  95. # 实例化数据读取器
  96. train_reader = paddle.io.DataLoader(
  97.     train_dataset,
  98.     batch_size=batch_size,
  99.     shuffle=True,
  100.     drop_last=True
  101. )
  102. dev_reader = paddle.io.DataLoader(
  103.     dev_dataset,
  104.     batch_size=batch_size,
  105.     shuffle=False,
  106.     drop_last=True
  107. )
  109. print('finish')
  1. generating datas..
  2. making the dataset...
  3. finish

三、模型组网

  • 通过继承 paddle.nn.Layer 类来搭建模型

  • 本次介绍的模型是一个简单的基于 LSTM 的 Seq2Seq 模型

  • 一共有如下四个主要的网络层：

    1. 嵌入层(Embedding)：将输入的文本序列转为嵌入向量

    2. 编码层(LSTM)：将嵌入向量进行编码

    3. 解码层(LSTM)：将编码向量进行解码

    4. 全连接层(Linear)：对解码完成的向量进行线性映射

  • 损失函数为交叉熵损失函数

  1. # 继承paddle.nn.Layer类
  2. class Addition_Model(nn.Layer):
  3.     # 重写初始化函数
  4.     # 参数：字符表长度、嵌入层大小、隐藏层大小、解码器层数、处理数字的最大位数
  5.     def __init__(self, char_len=12, embedding_size=128, hidden_size=128, num_layers=1, DIGITS=2):
  6.         super(Addition_Model, self).__init__()
  7.         # 初始化变量
  8.         self.DIGITS = DIGITS
  9.         self.MAXLEN = DIGITS + 1 + DIGITS
  10.         self.hidden_size = hidden_size
  11.         self.char_len = char_len
  13.         # 嵌入层
  14.         self.emb = nn.Embedding(
  15.             char_len,
  16.             embedding_size
  17.         )
  19.         # 编码器
  20.         self.encoder = nn.LSTM(
  21.             input_size=embedding_size,
  22.             hidden_size=hidden_size,
  23.             num_layers=1
  24.         )
  26.         # 解码器
  27.         self.decoder = nn.LSTM(
  28.             input_size=hidden_size,
  29.             hidden_size=hidden_size,
  30.             num_layers=num_layers
  31.         )
  33.         # 全连接层
  34.         self.fc = nn.Linear(
  35.             hidden_size,
  36.             char_len
  37.         )
  39.     # 重写模型前向计算函数
  40.     # 参数：输入[None, MAXLEN]、标签[None, DIGITS + 1]
  41.     def forward(self, inputs, labels=None):
  42.         # 嵌入层
  43.         out = self.emb(inputs)
  45.         # 编码器
  46.         out, (_, _) = self.encoder(out)
  48.         # 按时间步切分编码器输出
  49.         out = paddle.split(out, self.MAXLEN, axis=1)
  51.         # 取最后一个时间步的输出并复制 DIGITS + 1 次
  52.         out = paddle.expand(out[-1], [out[-1].shape[0], self.DIGITS + 1, self.hidden_size])
  54.         # 解码器
  55.         out, (_, _) = self.decoder(out)
  57.         # 全连接
  58.         out = self.fc(out)
  60.         # 如果标签存在，则计算其损失和准确率
  61.         if labels is not None:
  62.             # 转置解码器输出
  63.             tmp = paddle.transpose(out, [0, 2, 1])
  65.             # 计算交叉熵损失
  66.             loss = nn.functional.cross_entropy(tmp, labels, axis=1)
  68.             # 计算准确率
  69.             acc = paddle.metric.accuracy(paddle.reshape(out, [-1, self.char_len]), paddle.reshape(labels, [-1, 1]))
  71.             # 返回损失和准确率
  72.             return loss, acc
  74.         # 返回输出
  75.         return out

四、模型训练与评估

  • 使用 Adam 作为优化器进行模型训练

  • 以模型准确率作为评价指标

  • 使用 VisualDL 对训练数据进行可视化

  • 训练过程中会同时进行模型评估和最佳模型的保存

  1. # 初始化log写入器
  2. log_writer = LogWriter(logdir="./log")
  4. # 模型参数设置
  5. embedding_size = 128
  6. hidden_size=128
  7. num_layers=1
  9. # 训练参数设置
  10. epoch_num = 50
  11. learning_rate = 0.001
  12. log_iter = 2000
  13. eval_iter = 500
  15. # 定义一些所需变量
  16. global_step = 0
  17. log_step = 0
  18. max_acc = 0
  20. # 实例化模型
  21. model = Addition_Model(
  22.     char_len=len(label_dict),
  23.     embedding_size=embedding_size,
  24.     hidden_size=hidden_size,
  25.     num_layers=num_layers,
  26.     DIGITS=DIGITS)
  28. # 将模型设置为训练模式
  29. model.train()
  31. # 设置优化器，学习率，并且把模型参数给优化器
  32. opt = paddle.optimizer.Adam(
  33.     learning_rate=learning_rate,
  34.     parameters=model.parameters()
  35. )
  37. # 启动训练，循环epoch_num个轮次
  38. for epoch in range(epoch_num):
  39.     # 遍历数据集读取数据
  40.     for batch_id, data in enumerate(train_reader()):
  41.         # 读取数据
  42.         inputs, labels = data
  44.         # 模型前向计算
  45.         loss, acc = model(inputs, labels=labels)
  47.         # 打印训练数据
  48.         if global_step%log_iter==0:
  49.             print('train epoch:%d step: %d loss:%f acc:%f' % (epoch, global_step, loss.numpy(), acc.numpy()))
  50.             log_writer.add_scalar(tag="train/loss", step=log_step, value=loss.numpy())
  51.             log_writer.add_scalar(tag="train/acc", step=log_step, value=acc.numpy())
  52.             log_step+=1
  54.         # 模型验证
  55.         if global_step%eval_iter==0:
  56.             model.eval()
  57.             losses = []
  58.             accs = []
  59.             for data in dev_reader():
  60.                 loss, acc = model(inputs, labels=labels)
  61.                 losses.append(loss.numpy())
  62.                 accs.append(acc.numpy())
  63.             avg_loss = np.concatenate(losses).mean()
  64.             avg_acc = np.concatenate(accs).mean()
  65.             print('eval epoch:%d step: %d loss:%f acc:%f' % (epoch, global_step, avg_loss, avg_acc))
  66.             log_writer.add_scalar(tag="dev/loss", step=log_step, value=avg_loss)
  67.             log_writer.add_scalar(tag="dev/acc", step=log_step, value=avg_acc)
  69.             # 保存最佳模型
  70.             if avg_acc>max_acc:
  71.                 max_acc = avg_acc
  72.                 print('saving the best_model...')
  73.                 paddle.save(model.state_dict(), 'best_model')
  74.             model.train()
  76.         # 反向传播
  77.         loss.backward()
  79.         # 使用优化器进行参数优化
  80.         opt.step()
  82.         # 清除梯度
  83.         opt.clear_grad()
  85.         # 全局步数加一
  86.         global_step += 1
  88. # 保存最终模型
  89. paddle.save(model.state_dict(),'final_model')
  1. train epoch:0 step: 0 loss:2.468403 acc:0.177083
  2. eval epoch:0 step: 0 loss:2.468403 acc:0.177083
  3. saving the best_model...
  4. eval epoch:3 step: 500 loss:1.204414 acc:0.552083
  5. saving the best_model...
  6. eval epoch:6 step: 1000 loss:0.900309 acc:0.687500
  7. saving the best_model...
  8. eval epoch:9 step: 1500 loss:0.882398 acc:0.729167
  9. saving the best_model...

五、模型测试

  • 使用保存的最佳模型进行测试
  1. # 反转字符表
  2. label_dict_adv = {v: k for k, v in label_dict.items()}
  4. # 输入计算题目
  5. input_text = '12+40'
  7. # 编码输入为ID
  8. inputs = encoder(input_text, MAXLEN, label_dict)
  10. # 转换输入为向量形式
  11. inputs = np.array(inputs).reshape(-1, MAXLEN)
  12. inputs = paddle.to_tensor(inputs)
  14. # 加载模型
  15. params_dict= paddle.load('best_model')
  16. model.set_dict(params_dict)
  18. # 设置为评估模式
  19. model.eval()
  21. # 模型推理
  22. out = model(inputs)
  24. # 结果转换
  25. result = ''.join([label_dict_adv[_] for _ in np.argmax(out.numpy(), -1).reshape(-1)])
  27. # 打印结果
  28. print('the model answer: %s=%s' % (input_text, result))
  29. print('the true answer: %s=%s' % (input_text, eval(input_text)))

六、总结

  • 你还可以通过变换网络结构，调整数据集，尝试不同的参数的方式来进一步提升本示例当中的数字加法的效果

  • 同时，也可以尝试在其他的类似的任务中用飞桨来完成实际的实践