1、项目说明

智能问答是获取信息和知识的更直接、更高效的方式之一，传统的信息检索方法智能找到相关的文档，而智能问答能够直接找到精准的答案，极大的节省了人们查询信息的时间。问答按照技术分为基于阅读理解的问答和检索式的问答，阅读理解的问答是在正文中找到对应的答案片段，检索式问答则是匹配高频的问题，然后把答案返回给用户。本项目属于检索式的问答，问答的领域用途很广，比如搜索引擎，小度音响等智能硬件，政府，金融，银行，电信，电商领域的智能客服，聊天机器人等。下图是保险领域的问答示例：
手把手搭建保险问答系统 - 图1
本项目基于PaddleNLP FAQ_Finance。
本项目源代码全部开源在 PaddleNLP 中。

手把手搭建保险问答系统 - 图3
欢迎扫码填写基础问卷后，加入PaddleNLP技术交流群（微信）:

1.1 应用特色

  • 低门槛
    • 手把手搭建检索式 FAQ System
    • 无需相似 Query-Query Pair 标注数据也能构建 FAQ System
  • 效果好
    • 业界领先的检索预训练模型: RocketQA DualEncoder
    • 针对无标注数据场景的领先解决方案: 检索预训练模型 + 增强的无监督语义索引微调
  • 性能快
    • 基于 Paddle Inference 快速抽取向量
    • 基于 Milvus 快速查询和高性能建库
    • 基于 Paddle Serving 高性能部署

      1.2 问答流程设计

      手把手搭建保险问答系统 - 图4
      问答的流程分为两部分，第一部分是管理员/工程师流程，第二部分就是用户使用流程，在模型的层面，需要离线的准备数据集，训练模型，然后把训练好的模型部署上线。另外，就是线上搭建问答检索引擎，第一步把收集好的语料数据，利用训练好的模型抽取问题的向量，然后把向量插入到近似向量检索引擎中，构建语义索引库，这部分做完了之后，就可以使用这个问答服务了，但是用户输入了Query之后，发生了什么呢？第一步就是线上服务会接收Query后，对数据进行处理，并抽取用户Query的向量，然后在ANN查询模块进行检索匹配相近的问题，最终选取Top10条数据，返回给线上服务，线上服务经过一定的处理，把最终的答案呈现给用户。
      本次模型的优化流程如下：
      手把手搭建保险问答系统 - 图5

      2、安装说明

      AI Studio平台默认安装了Paddle和PaddleNLP，并定期更新版本。 如需手动更新，可参考如下说明：
      1. # 安装最新版PaddleNLP，首次更新完以后，重启后方能生效
      2. !pip install --upgrade paddlenlp
      安装项目依赖的其他库：
      备注：如果提示找不到相关文件，左上角刷新即可。
      1. !pip install -r requirements.txt
      首先导入项目所需要的第三方库：
      1. # 加载系统的API
      2. import abc
      3. import sys
      4. from functools import partial
      5. import argparse
      6. import os
      7. import random
      8. import time
      9. import numpy as np
      10. # 加载飞桨的API
      11. import paddle
      12. import paddle.nn as nn
      13. import paddle.nn.functional as F
      14. from paddle import inference
      15. # 加载PaddleNLP的API
      16. import paddlenlp as ppnlp
      17. from paddlenlp.data import Stack, Tuple, Pad
      18. from paddlenlp.datasets import load_dataset, MapDataset
      19. from paddlenlp.transformers import LinearDecayWithWarmup
      20. from paddlenlp.utils.downloader import get_path_from_url
      21. import paddle_serving_client.io as serving_io

      3、数据准备

      基于Github上公开的保险问答数据集，我们需要准备训练集，评估集和召回库三部分。首先保险的数据包含Query，Title，Reply等字段，我们选取其中的Query和Reply字段来构建问答系统。
      Github的地址为：保险
      【免责声明】：数据集是基于Github开源数据进行了处理得到的，如果有任何侵权问题，请及时联系，我们会在第一时间进行删除处理。
      有需要的同学去改地址下载数据即可。
      接下来我们构造训练集，训练集则直接使用保险数据中的Query，然后为了优化效果，我们使用同义词替换的方法构造同义句，构造的同义句如下： 训练集示例如下：
      1. 我儿子还在念小学，适不适合投保康惠保呢？
      2. 被骄车撞成右膀肱骨粉碎性骨折保守治疗怎么向车主和他的保险公司索赔
      3. 商业医疗保险报销程序?
      4. 家里有社保，还有必要买重疾险吗？
      5. 工地买了建工险，出了事故多长时间上报保险公司有效
      6. 请问下哆啦a保值不值得买呢？不晓得保障多不多
      利用同义词替换的方法生成的训练集如下：
      1. 我儿子还在念小学，适不适合投保康惠保呢？    我儿子还在念小学校，适不适合投保康惠保呢？
      2. 被骄车撞成右膀肱骨粉碎性骨折保守治疗怎么向车主和他的保险公司索赔    被骄车撞成右膀肱骨粉碎性骨折保守诊疗怎么向车主和他的保险公司索赔
      3. 商业医疗保险报销程序?    买卖医疗保险报销程序?
      4. 家里有社保，还有必要买重疾险吗？    家里有社保，再有必要买重疾险吗？
      5. 工地买了建工险，出了事故多长时间上报保险公司有效    工地买了建工险，出了事故多长时间上报保险公司管事
      用中英文回译的方法来生成评估集合，评估集是问题对，示例如下：
      1. 企业养老保险自己怎么办理    如何办理企业养老保险
      2. 西*牙签证保险怎么买？    如何为西班牙购买签证保险？
      3. 康惠保的保额要买到多少才合适？    康慧宝需要买多少？
      4. 车辆事故对方全责维修费不肯垫付怎么办    如果另一方对车辆事故负有全部责任，并且拒绝提前支付维修费，该怎么办
      5. 准备清明节去新*坡旅行，哪款旅游险好？    准备清明节去新兴坡旅游，什么样的旅游保险好？
      1. from paddlenlp.dataaug import WordSubstitute
      2. s1 = "工地买了建工险，出了事故多长时间上报保险公司有效。"
      ```java aug = WordSubstitute(‘synonym’, create_n=3, aug_percent=0.3) augmented = aug.augment(s1) print(“origin:”, s1) print(“augmented:”, augmented)

origin: 工地买了建工险，出了事故多长时间上报保险公司有效。 augmented: [‘工地买了矿工险，出完竣故多长时间上报保险公司有效。’, ‘工地买了养路工险，出了事故多长岁月上报

  1. 另一种数据增强的方法是MLM，示例如下：
  2. ```java
  3. import paddle
  4. # 在GPU环境下运行
  5. paddle.set_device("gpu")
  6. # 在CPU下环境运行
  7. # paddle.set_device("cpu")
  8. aug = WordSubstitute('mlm', create_n=2)
  9. augmented = aug.augment(s1)
  10. print("origin:", s1)
  11. print("augmented:", augmented[0])
  13. [2022-09-09 19:58:34,559] [    INFO] - We are using <class 'paddlenlp.transformers.ernie.modeling.ErnieForMaskedLM'> to load 'ernie-1.0'.
  14. [2022-09-09 19:58:34,563] [    INFO] - Already cached /home/aistudio/.paddlenlp/models/ernie-1.0/ernie_v1_chn_base.pdparams
  15. W0909 19:58:34.566742  1096 gpu_resources.cc:61] Please NOTE: device: 0, GPU Compute Capability: 7.0, Driver API Version: 11.2, Runtime API Version: 11.2
  16. W0909 19:58:34.570971  1096 gpu_resources.cc:91] device: 0, cuDNN Version: 8.2.
  17. [2022-09-09 19:58:37,409] [    INFO] - We are using <class 'paddlenlp.transformers.ernie.tokenizer.ErnieTokenizer'> to load 'ernie-1.0'.
  18. [2022-09-09 19:58:37,412] [    INFO] - Already cached /home/aistudio/.paddlenlp/models/ernie-1.0/vocab.txt
  19. [2022-09-09 19:58:37,426] [    INFO] - tokenizer config file saved in /home/aistudio/.paddlenlp/models/ernie-1.0/tokenizer_config.json
  20. [2022-09-09 19:58:37,429] [    INFO] - Special tokens file saved in /home/aistudio/.paddlenlp/models/ernie-1.0/special_tokens_map.json
  22. origin: 工地买了建工险，出了事故多长时间上报保险公司有效。
  23. augmented: 工地购保建工险，出了事故多长时间上报保险公司有效。

用户可以根据实际情况，灵活选择数据增强的方式，然后用于自己的数据中。

  1. # 读取原始数据
  2. list_data = []
  3. with open('baoxian/train.csv','r') as f:
  4.     for item in f.readlines():
  5.         list_data.append(item.strip())
  6. # 数据增强
  7. aug_texts = []
  8. for item in list_data:
  9.     augmented = aug.augment(item)
  10.     if(len(augmented)==0):
  11.         continue
  12.     aug_texts.append([item,augmented[0]])
  13. # 数据输出到train_aug_synonym.csv
  14. with open('train_aug_synonym.csv','w') as f:
  15.     for arr in aug_texts:
  16.         f.write('\t'.join(arr)+'\n')

接下来就可以使用train_aug_synonym.csv文件进行训练了。

3.1 加载数据

加载数据集，可以选择train.csv或者train_aug.csv（本项目预先生成的增强数据集，也可以使用本项目的工具进行生成），train.csv表示的是无监督数据集，train_aug.csv表示的是同义词替换的数据集，可以二选一。

  1. from data import read_text_pair
  3. def read_simcse_text(data_path):
  4.     """Reads data."""
  5.     with open(data_path, 'r', encoding='utf-8') as f:
  6.         for line in f:
  7.             data = line.rstrip()
  8.             # 无监督训练，text_a和text_b是一样的
  9.             yield {'text_a': data, 'text_b': data}
  10. # 加载训练集， 无监督
  11. # train_set_file='baoxian/train.csv'
  12. # train_ds = load_dataset(read_simcse_text, data_path=train_set_file, lazy=False)
  14. # 加载数据集，数据增强：
  15. train_set_file='baoxian/train_aug.csv'
  16. train_ds = load_dataset(read_text_pair, data_path=train_set_file, lazy=False)
  18. # 输出三条数据
  19. for i  in range(3):
  20.     print(train_ds[i])
  1. {'text_a': '我儿子还在念小学，适不适合投保康惠保呢？', 'text_b': '我儿子还在念小学校，适不适合投保康惠保呢？'}
  2. {'text_a': '被骄车撞成右膀肱骨粉碎性骨折保守治疗怎么向车主和他的保险公司索赔', 'text_b': '被骄车撞成右膀肱骨粉碎性骨折保守诊疗怎么向车主和他的保险公司索赔'}
  3. {'text_a': '商业医疗保险报销程序?', 'text_b': '买卖医疗保险报销程序?'}

打印结果可以看出，无监督数据：输入数据的两条文本是一样的。对于增强后的数据，两条文本是不一样的，可以比较一下差别。无监督数据读取使用read_simcse_text，增强的数据读取使用read_text_pair。

3.2 构建Dataloader

  1. def convert_example(example, tokenizer, max_seq_length=512, do_evalute=False):
  2.     # 把文本转换成id的形式
  3.     result = []
  5.     for key, text in example.items():
  6.         if 'label' in key:
  7.             # do_evaluate
  8.             result += [example['label']]
  9.         else:
  10.             # do_train
  11.             encoded_inputs = tokenizer(text=text, max_seq_len=max_seq_length)
  12.             input_ids = encoded_inputs["input_ids"]
  13.             token_type_ids = encoded_inputs["token_type_ids"]
  14.             result += [input_ids, token_type_ids]
  15.     return result
  18. # 序列的最大的长度，根据数据集的情况进行设置
  19. max_seq_length=64
  20. # batch_size越大，效果会更好
  21. batch_size=64
  22. # 使用rocketqa开放领域的问答模型
  23. model_name_or_path='rocketqa-zh-base-query-encoder'
  24. tokenizer = ppnlp.transformers.ErnieTokenizer.from_pretrained(model_name_or_path)
  25. # partial赋默认的值
  26. trans_func = partial(
  27.         convert_example,
  28.         tokenizer=tokenizer,
  29.         max_seq_length=max_seq_length)
  30. # 对齐组装成小批次数据
  31. batchify_fn = lambda samples, fn=Tuple(
  32.         Pad(axis=0, pad_val=tokenizer.pad_token_id,dtype='int64'),  # query_input
  33.         Pad(axis=0, pad_val=tokenizer.pad_token_type_id,dtype='int64'),  # query_segment
  34.         Pad(axis=0, pad_val=tokenizer.pad_token_id,dtype='int64'),  # title_input
  35.         Pad(axis=0, pad_val=tokenizer.pad_token_type_id,dtype='int64'),  # tilte_segment
  36.     ): [data for data in fn(samples)]
  1. [2022-09-09 20:05:10,960] [    INFO] - Downloading https://bj.bcebos.com/paddlenlp/models/transformers/ernie_3.0/ernie_3.0_base_zh_vocab.txt and saved to /home/aistudio/.paddlenlp/models/rocketqa-zh-base-query-encoder
  2. [2022-09-09 20:05:10,964] [    INFO] - Downloading ernie_3.0_base_zh_vocab.txt from https://bj.bcebos.com/paddlenlp/models/transformers/ernie_3.0/ernie_3.0_base_zh_vocab.txt
  3. 100%|██████████| 182k/182k [00:00<00:00, 2.41MB/s]
  4. [2022-09-09 20:05:11,156] [    INFO] - tokenizer config file saved in /home/aistudio/.paddlenlp/models/rocketqa-zh-base-query-encoder/tokenizer_config.json
  5. [2022-09-09 20:05:11,159] [    INFO] - Special tokens file saved in /home/aistudio/.paddlenlp/models/rocketqa-zh-base-query-encoder/special_tokens_map.json
  1. # 明文数据 -> ID 序列训练数据
  2. def create_dataloader(dataset,
  3.                       mode='train',
  4.                       batch_size=1,
  5.                       batchify_fn=None,
  6.                       trans_fn=None):
  7.     if trans_fn:
  8.         dataset = dataset.map(trans_fn)
  10.     shuffle = True if mode == 'train' else False
  11.     if mode == 'train':
  12.         batch_sampler = paddle.io.DistributedBatchSampler(
  13.             dataset, batch_size=batch_size, shuffle=shuffle)
  14.     else:
  15.         batch_sampler = paddle.io.BatchSampler(
  16.             dataset, batch_size=batch_size, shuffle=shuffle)
  18.     return paddle.io.DataLoader(
  19.         dataset=dataset,
  20.         batch_sampler=batch_sampler,
  21.         collate_fn=batchify_fn,
  22.         return_list=True)
  24. # 构建训练的Dataloader
  25. train_data_loader = create_dataloader(
  26.         train_ds,
  27.         mode='train',
  28.         batch_size=batch_size,
  29.         batchify_fn=batchify_fn,
  30.         trans_fn=trans_func)
  31. # 展示一下输入的dataloader的数据
  32. for idx, batch in enumerate(train_data_loader):
  33.     if idx == 0:
  34.         print(batch)
  35.         break 
  37. [Tensor(shape=[64, 44], dtype=int64, place=Place(gpu_pinned), stop_gradient=True,
  38.        [[1   , 278 , 26  , ..., 0   , 0   , 0   ],
  39.         [1   , 1042, 15  , ..., 0   , 0   , 0   ],
  40.         [1   , 320 , 645 , ..., 0   , 0   , 0   ],
  41.         ...,
  42.         [1   , 68  , 124 , ..., 0   , 0   , 0   ],
  43.         [1   , 276 , 1023, ..., 0   , 0   , 0   ],
  44.         [1   , 118 , 19  , ..., 0   , 0   , 0   ]]), Tensor(shape=[64, 44], dtype=int64, place=Place(gpu_pinned), stop_gradient=True,
  45.        [[0, 0, 0, ..., 0, 0, 0],
  46.         [0, 0, 0, ..., 0, 0, 0],
  47.         [0, 0, 0, ..., 0, 0, 0],
  48.         ...,
  49.         [0, 0, 0, ..., 0, 0, 0],
  50.         [0, 0, 0, ..., 0, 0, 0],
  51.         [0, 0, 0, ..., 0, 0, 0]]), Tensor(shape=[64, 42], dtype=int64, place=Place(gpu_pinned), stop_gradient=True,
  52.        [[1   , 1042, 1225, ..., 0   , 0   , 0   ],
  53.         [1   , 1042, 15  , ..., 0   , 0   , 0   ],
  54.         [1   , 320 , 645 , ..., 0   , 0   , 0   ],
  55.         ...,
  56.         [1   , 68  , 124 , ..., 0   , 0   , 0   ],
  57.         [1   , 276 , 1023, ..., 0   , 0   , 0   ],
  58.         [1   , 118 , 19  , ..., 0   , 0   , 0   ]]), Tensor(shape=[64, 42], dtype=int64, place=Place(gpu_pinned), stop_gradient=True,
  59.        [[0, 0, 0, ..., 0, 0, 0],
  60.         [0, 0, 0, ..., 0, 0, 0],
  61.         [0, 0, 0, ..., 0, 0, 0],
  62.         ...,
  63.         [0, 0, 0, ..., 0, 0, 0],
  64.         [0, 0, 0, ..., 0, 0, 0],
  65.         [0, 0, 0, ..., 0, 0, 0]])]

上面展示的是一个batch的数据，包含两个Tensor，第一个Tensor表示的是input_ids，第二个Tensor表示的是token_type_ids；第一个Tensor中，32是batch_size的维度，44代表的是序列的长度，表示输入的文本的最大长度是44；第二个Tensor中，32表示的也是batch_size，44表示的是序列的长度。

4、模型选择

首先保险问答场景的数据只有问题和答案对，再没有其他的数据了。如果使用有监督方法，需要问题-问题对，还需要收集一些问题进行人工标注。因此可以考虑使用无监督语义索引技术SimCSE模型。
总体上无监督技术没有有监督技术效果好，所以为了提升SimCSE的性能，我们使用了开放问答领域的预训练语言模型RocketQA，并且在SimCSE的基础上利用WR，R-Drop等策略进行优化。

4.1 模型方案设计

无监督方案
第一步：基于检索式问答SOTA预训练模型RocketQA
第二步：无监督训练策略SimCSE
第三步：无监督增强策略Word Reptition, WR, RDrop
手把手搭建保险问答系统 - 图6
整个方案无需人工参与数据标注，所以是一个无监督的解决方案。

5、模型构建

5.1 SimCSE模型

搭建SimCSE模型，主要部分是用query和title分别得到embedding向量，然后计算余弦相似度。
手把手搭建保险问答系统 - 图7
上图是SimCSE的原理图，SimCSE主要是通过dropout来把同一个句子变成正样本（做两次前向，但是dropout有随机因素，所以产生的向量不一样，但是本质上还是表示的是同一句话），把一个batch里面其他的句子变成负样本的。
SimCSE网络结构搭建，搭建代码如下：

  1. class SimCSE(nn.Layer):
  2.     def __init__(self,
  3.                  pretrained_model,
  4.                  dropout=None,
  5.                  margin=0.0,
  6.                  scale=20,
  7.                  output_emb_size=None):
  9.         super().__init__()
  11.         self.ptm = pretrained_model
  12.         # 显式的加一个dropout来控制
  13.         self.dropout = nn.Dropout(dropout if dropout is not None else 0.1)
  15.         # 考虑到性能和效率，我们推荐把output_emb_size设置成256
  16.         # 向量越大，语义信息越丰富，但消耗资源越多
  17.         self.output_emb_size = output_emb_size
  18.         if output_emb_size > 0:
  19.             weight_attr = paddle.ParamAttr(
  20.                 initializer=paddle.nn.initializer.TruncatedNormal(std=0.02))
  21.             self.emb_reduce_linear = paddle.nn.Linear(
  22.                 768, output_emb_size, weight_attr=weight_attr)
  24.         self.margin = margin
  26.         # 为了使余弦相似度更容易收敛，我们选择把计算出来的余弦相似度扩大scale倍，一般设置成20左右
  27.         self.sacle = scale
  28.         # 二分类计算
  29.         self.classifier = nn.Linear(output_emb_size, 2)
  30.         # R-Drop的损失
  31.         self.rdrop_loss = ppnlp.losses.RDropLoss()
  33.     # 加入jit注释能够把该提取向量的函数导出成静态图
  34.     # 对应input_id,token_type_id两个
  35.     @paddle.jit.to_static(input_spec=[
  36.         paddle.static.InputSpec(
  37.             shape=[None, None], dtype='int64'), paddle.static.InputSpec(
  38.                 shape=[None, None], dtype='int64')
  39.     ])
  40.     def get_pooled_embedding(self,
  41.                              input_ids,
  42.                              token_type_ids=None,
  43.                              position_ids=None,
  44.                              attention_mask=None,
  45.                              with_pooler=True):
  47.         # Note: cls_embedding is poolerd embedding with act tanh 
  48.         sequence_output, cls_embedding = self.ptm(input_ids, token_type_ids,
  49.                                                   position_ids, attention_mask)
  51.         if with_pooler == False:
  52.             cls_embedding = sequence_output[:, 0, :]
  54.         if self.output_emb_size > 0:
  55.             cls_embedding = self.emb_reduce_linear(cls_embedding)
  57.         cls_embedding = self.dropout(cls_embedding)
  58.         cls_embedding = F.normalize(cls_embedding, p=2, axis=-1)
  60.         return cls_embedding
  62.     def get_semantic_embedding(self, data_loader):
  63.         self.eval()
  64.         with paddle.no_grad():
  65.             for batch_data in data_loader:
  66.                 input_ids, token_type_ids = batch_data
  67.                 input_ids = paddle.to_tensor(input_ids)
  68.                 token_type_ids = paddle.to_tensor(token_type_ids)
  70.                 text_embeddings = self.get_pooled_embedding(
  71.                     input_ids, token_type_ids=token_type_ids)
  73.                 yield text_embeddings
  75.     def cosine_sim(self,
  76.                    query_input_ids,
  77.                    title_input_ids,
  78.                    query_token_type_ids=None,
  79.                    query_position_ids=None,
  80.                    query_attention_mask=None,
  81.                    title_token_type_ids=None,
  82.                    title_position_ids=None,
  83.                    title_attention_mask=None,
  84.                    with_pooler=True):
  86.         query_cls_embedding = self.get_pooled_embedding(
  87.             query_input_ids,
  88.             query_token_type_ids,
  89.             query_position_ids,
  90.             query_attention_mask,
  91.             with_pooler=with_pooler)
  93.         title_cls_embedding = self.get_pooled_embedding(
  94.             title_input_ids,
  95.             title_token_type_ids,
  96.             title_position_ids,
  97.             title_attention_mask,
  98.             with_pooler=with_pooler)
  100.         cosine_sim = paddle.sum(query_cls_embedding * title_cls_embedding,
  101.                                 axis=-1)
  102.         return cosine_sim
  104.     def forward(self,
  105.                 query_input_ids,
  106.                 title_input_ids,
  107.                 query_token_type_ids=None,
  108.                 query_position_ids=None,
  109.                 query_attention_mask=None,
  110.                 title_token_type_ids=None,
  111.                 title_position_ids=None,
  112.                 title_attention_mask=None):
  113.         # 第 1 次编码: 文本经过无监督语义索引模型编码后的语义向量 
  114.         # [N, output_emb_size]
  115.         query_cls_embedding = self.get_pooled_embedding(
  116.             query_input_ids, query_token_type_ids, query_position_ids,
  117.             query_attention_mask)
  119.         # 第 2 次编码: 文本经过无监督语义索引模型编码后的语义向量 
  120.         # [N, output_emb_size]
  121.         title_cls_embedding = self.get_pooled_embedding(
  122.             title_input_ids, title_token_type_ids, title_position_ids,
  123.             title_attention_mask)
  125.         # 使用R-Drop
  126.         logits1=self.classifier(query_cls_embedding)
  127.         logits2 = self.classifier(title_cls_embedding)
  128.         kl_loss = self.rdrop_loss(logits1, logits2)
  130.         # 相似度矩阵: [N, N]
  131.         cosine_sim = paddle.matmul(
  132.             query_cls_embedding, title_cls_embedding, transpose_y=True)
  134.         # substract margin from all positive samples cosine_sim()
  135.         # 填充self.margin值，比如margin为0.2，query_cls_embedding.shape[0]=2 
  136.         # margin_diag: [0.2,0.2]
  137.         margin_diag = paddle.full(
  138.             shape=[query_cls_embedding.shape[0]],
  139.             fill_value=self.margin,
  140.             dtype=paddle.get_default_dtype())
  141.         # input paddle.diag(margin_diag): [[0.2,0],[0,0.2]]
  142.         # input cosine_sim : [[1.0,0.6],[0.6,1.0]]
  143.         # output cosine_sim: [[0.8,0.6],[0.6,0.8]]
  144.         cosine_sim = cosine_sim - paddle.diag(margin_diag)
  146.         # scale cosine to ease training converge
  147.         cosine_sim *= self.sacle
  148.         # 转化成分类任务: 对角线元素是正例，其余元素为负例
  149.         # labels : [0,1,2,3]
  150.         labels = paddle.arange(0, query_cls_embedding.shape[0], dtype='int64')
  151.         # labels : [[0],[1],[2],[3]]
  152.         labels = paddle.reshape(labels, shape=[-1, 1])
  153.         # 交叉熵损失函数
  154.         loss = F.cross_entropy(input=cosine_sim, label=labels)
  156.         return loss, kl_loss

5.2 模型优化策略

5.2.1 WR 策略

策略 举例 解释
原句 企业养老保险自己怎么办理 -
WR策略（Yes） 企业养老老保险自己怎么么办理 语义改变较小
随机插入(No) 无企业养老保险自己怎么办理 语义改变较大
随机删除（No） 企业养保险自己怎么办理 语义改变较大

上图是WR策略跟其他策略的简单比较，其中WR策略对原句的语义改变很小，但是改变了句子的长度，破除了SimCSE句子长度相等的假设。WR策略起源于ESimCSE的论文，有兴趣可以从论文里了解其原理。

  1. def word_repetition(input_ids, token_type_ids, dup_rate=0.32):
  2.     """Word Reptition strategy."""
  3.     input_ids = input_ids.numpy().tolist()
  4.     token_type_ids = token_type_ids.numpy().tolist()
  6.     batch_size, seq_len = len(input_ids), len(input_ids[0])
  7.     repetitied_input_ids = []
  8.     repetitied_token_type_ids = []
  9.     rep_seq_len = seq_len
  10.     for batch_id in range(batch_size):
  11.         cur_input_id = input_ids[batch_id]
  12.         actual_len = np.count_nonzero(cur_input_id)
  13.         dup_word_index = []
  14.         # If sequence length is less than 5, skip it
  15.         if (actual_len > 5):
  16.             dup_len = random.randint(a=0, b=max(2, int(dup_rate * actual_len)))
  17.             # Skip cls and sep position
  18.             dup_word_index = random.sample(
  19.                 list(range(1, actual_len - 1)), k=dup_len)
  21.         r_input_id = []
  22.         r_token_type_id = []
  23.         for idx, word_id in enumerate(cur_input_id):
  24.             # Insert duplicate word
  25.             if idx in dup_word_index:
  26.                 r_input_id.append(word_id)
  27.                 r_token_type_id.append(token_type_ids[batch_id][idx])
  28.             r_input_id.append(word_id)
  29.             r_token_type_id.append(token_type_ids[batch_id][idx])
  30.         after_dup_len = len(r_input_id)
  31.         repetitied_input_ids.append(r_input_id)
  32.         repetitied_token_type_ids.append(r_token_type_id)
  34.         if after_dup_len > rep_seq_len:
  35.             rep_seq_len = after_dup_len
  36.     # Padding the data to the same length
  37.     for batch_id in range(batch_size):
  38.         after_dup_len = len(repetitied_input_ids[batch_id])
  39.         pad_len = rep_seq_len - after_dup_len
  40.         repetitied_input_ids[batch_id] += [0] * pad_len
  41.         repetitied_token_type_ids[batch_id] += [0] * pad_len
  43.     return paddle.to_tensor(repetitied_input_ids, dtype='int64'), paddle.to_tensor(
  44.         repetitied_token_type_ids, dtype='int64')

5.2.2 R-Drop策略

R-Drop的原理：为了避免过拟合，通常会加入Dropout等较为成熟的正则话策略，即同样的输入，分别用模型预测两次，因为有Dropout的存在，所以会得到两个不同分布的输出，可以近似的看作两个不同的模型的网络的输出。我们用P1和P2表示模型输出的两个不同分布，R-Drop的目的就是在训练的过程中不断拉低这两个分布之间的KL散度。
R-Drop的API请参考：https://paddlenlp.readthedocs.io/zh/latest/source/paddlenlp.losses.rdrop.html
手把手搭建保险问答系统 - 图8

6.训练配置

训练配置包括一些超参数，优化器，模型实例化等设置。

  1. # 关键参数
  2. scale=20 # 推荐值: 10 ~ 30
  3. margin=0.1 # 推荐值: 0.0 ~ 0.2
  5. epochs= 3 
  6. # 学习率设置
  7. learning_rate=5E-5
  8. warmup_proportion=0.0
  9. weight_decay=0.0
  10. save_steps=10
  12. # 可以根据实际情况进行设置
  13. output_emb_size=256
  14. dup_rate=0.3 # 建议设置在0~0.3之间
  15. save_dir='checkpoints'
  1. # 使用预训练模型
  2. pretrained_model = ppnlp.transformers.ErnieModel.from_pretrained(model_name_or_path)
  3. # 无监督+R-Drop，类似于多任务学习
  4. model = SimCSE(
  5.         pretrained_model,
  6.         margin=margin,
  7.         scale=scale,
  8.         output_emb_size=output_emb_size)
  10. num_training_steps = len(train_data_loader) * epochs
  12. lr_scheduler = LinearDecayWithWarmup(learning_rate, num_training_steps,
  13.                                          warmup_proportion) 
  15. # Generate parameter names needed to perform weight decay.
  16. # All bias and LayerNorm parameters are excluded.
  17. decay_params = [
  18.         p.name for n, p in model.named_parameters()
  19.         if not any(nd in n for nd in ["bias", "norm"])
  20.     ]
  21. # AdamW优化器
  22. optimizer = paddle.optimizer.AdamW(
  23.         learning_rate=lr_scheduler,
  24.         parameters=model.parameters(),
  25.         weight_decay=weight_decay,
  26.         apply_decay_param_fun=lambda x: x in decay_params)
  1. [2022-09-09 20:05:11,540] [    INFO] - Downloading https://paddlenlp.bj.bcebos.com/models/transformers/rocketqa/rocketqa-zh-base-query-encoder.pdparams and saved to /home/aistudio/.paddlenlp/models/rocketqa-zh-base-query-encoder
  2. [2022-09-09 20:05:11,542] [    INFO] - Downloading rocketqa-zh-base-query-encoder.pdparams from https://paddlenlp.bj.bcebos.com/models/transformers/rocketqa/rocketqa-zh-base-query-encoder.pdparams
  3. 100%|██████████| 450M/450M [00:08<00:00, 53.2MB/s] 
  4. [2022-09-09 20:05:21,869] [    INFO] - Weights from pretrained model not used in ErnieModel: ['classifier.weight', 'classifier.bias']

7. 模型训练

训练过程是从train_data_loader中不断得到小批次的数据，然后送入模型预测得到损失，然后反向更新梯度，代码如下：

  1. def do_train(model,train_data_loader,**kwargs):
  2.     save_dir=kwargs['save_dir']
  3.     global_step = 0
  4.     tic_train = time.time()
  5.     for epoch in range(1, epochs + 1):
  6.         for step, batch in enumerate(train_data_loader, start=1):
  7.             query_input_ids, query_token_type_ids, title_input_ids, title_token_type_ids = batch
  8.             # sample的方式使用同义词语句和WR策略
  9.             # 概率可以设置
  10.             if(random.random()<0.2):
  11.                 title_input_ids,title_token_type_ids=query_input_ids,query_token_type_ids
  12.                 query_input_ids,query_token_type_ids=word_repetition(query_input_ids,query_token_type_ids,dup_rate)
  13.                 title_input_ids,title_token_type_ids=word_repetition(title_input_ids,title_token_type_ids,dup_rate)
  14.             # else:
  15.             #     query_input_ids,query_token_type_ids=word_repetition(query_input_ids,query_token_type_ids,dup_rate)
  16.             #     title_input_ids,title_token_type_ids=word_repetition(title_input_ids,title_token_type_ids,dup_rate)
  18.             loss, kl_loss = model(
  19.                 query_input_ids=query_input_ids,
  20.                 title_input_ids=title_input_ids,
  21.                 query_token_type_ids=query_token_type_ids,
  22.                 title_token_type_ids=title_token_type_ids)
  23.             # 加入R-Drop的损失优化，默认设置的是0.1，参数可以调
  24.             loss = loss + kl_loss * 0.1
  25.             # 每隔5个step打印日志
  26.             global_step += 1
  27.             if global_step % 5 == 0:
  28.                 print(
  29.                     "global step %d, epoch: %d, batch: %d, loss: %.5f, speed: %.2f step/s"
  30.                     % (global_step, epoch, step, loss,
  31.                        10 / (time.time() - tic_train)))
  32.                 tic_train = time.time()
  33.             # 反向梯度求导更新
  34.             loss.backward()
  35.             optimizer.step()
  36.             lr_scheduler.step()
  37.             optimizer.clear_grad()
  38.             # 每隔save_steps保存模型
  39.             if global_step % save_steps == 0:
  40.                 save_path = os.path.join(save_dir, "model_%d" % global_step)
  41.                 if not os.path.exists(save_path):
  42.                     os.makedirs(save_path)
  43.                 save_param_path = os.path.join(save_path, 'model_state.pdparams')
  44.                 paddle.save(model.state_dict(), save_param_path)
  45.                 tokenizer.save_pretrained(save_path)
  46.     # 保存最后一个batch的模型
  47.     save_path = os.path.join(save_dir, "model_%d" % global_step)
  48.     if not os.path.exists(save_path):
  49.         os.makedirs(save_path)
  50.         save_param_path = os.path.join(save_path, 'model_state.pdparams')
  51.         paddle.save(model.state_dict(), save_param_path)
  52.         tokenizer.save_pretrained(save_path)
  53. # 模型训练
  54. do_train(model,train_data_loader,save_dir=save_dir)
  1. global step 5, epoch: 1, batch: 5, loss: 0.96966, speed: 1.78 step/s
  2. global step 10, epoch: 1, batch: 10, loss: 0.77097, speed: 7.91 step/s
  4. [2022-09-09 20:05:33,501] [    INFO] - tokenizer config file saved in checkpoints/model_10/tokenizer_config.json
  5. [2022-09-09 20:05:33,505] [    INFO] - Special tokens file saved in checkpoints/model_10/special_tokens_map.json
  7. global step 15, epoch: 1, batch: 15, loss: 0.77326, speed: 1.84 step/s
  8. global step 20, epoch: 1, batch: 20, loss: 0.42818, speed: 7.48 step/s
  10. [2022-09-09 20:05:40,584] [    INFO] - tokenizer config file saved in checkpoints/model_20/tokenizer_config.json
  11. [2022-09-09 20:05:40,588] [    INFO] - Special tokens file saved in checkpoints/model_20/special_tokens_map.json
  13. global step 25, epoch: 1, batch: 25, loss: 0.12546, speed: 1.64 step/s
  14. global step 30, epoch: 1, batch: 30, loss: 0.43253, speed: 7.37 step/s
  16. [2022-09-09 20:05:49,713] [    INFO] - tokenizer config file saved in checkpoints/model_30/tokenizer_config.json
  17. [2022-09-09 20:05:49,770] [    INFO] - Special tokens file saved in checkpoints/model_30/special_tokens_map.json
  19. global step 35, epoch: 1, batch: 35, loss: 0.23268, speed: 1.29 step/s
  20. global step 40, epoch: 1, batch: 40, loss: 0.29480, speed: 7.09 step/s
  22. [2022-09-09 20:05:57,148] [    INFO] - tokenizer config file saved in checkpoints/model_40/tokenizer_config.json
  23. [2022-09-09 20:05:57,151] [    INFO] - Special tokens file saved in checkpoints/model_40/special_tokens_map.json
  25. global step 45, epoch: 1, batch: 45, loss: 0.23914, speed: 1.74 step/s
  26. global step 50, epoch: 2, batch: 2, loss: 0.16835, speed: 7.59 step/s
  28. [2022-09-09 20:06:04,064] [    INFO] - tokenizer config file saved in checkpoints/model_50/tokenizer_config.json
  29. [2022-09-09 20:06:04,067] [    INFO] - Special tokens file saved in checkpoints/model_50/special_tokens_map.json
  31. global step 55, epoch: 2, batch: 7, loss: 0.16169, speed: 1.78 step/s
  32. global step 60, epoch: 2, batch: 12, loss: 0.25203, speed: 7.51 step/s
  34. [2022-09-09 20:06:11,131] [    INFO] - tokenizer config file saved in checkpoints/model_60/tokenizer_config.json
  35. [2022-09-09 20:06:11,135] [    INFO] - Special tokens file saved in checkpoints/model_60/special_tokens_map.json
  37. global step 65, epoch: 2, batch: 17, loss: 0.14274, speed: 1.76 step/s
  38. global step 70, epoch: 2, batch: 22, loss: 0.20095, speed: 7.12 step/s
  40. [2022-09-09 20:06:18,097] [    INFO] - tokenizer config file saved in checkpoints/model_70/tokenizer_config.json
  41. [2022-09-09 20:06:18,100] [    INFO] - Special tokens file saved in checkpoints/model_70/special_tokens_map.json
  43. global step 75, epoch: 2, batch: 27, loss: 0.06234, speed: 1.80 step/s
  44. global step 80, epoch: 2, batch: 32, loss: 0.17870, speed: 6.71 step/s
  46. [2022-09-09 20:06:25,124] [    INFO] - tokenizer config file saved in checkpoints/model_80/tokenizer_config.json
  47. [2022-09-09 20:06:25,128] [    INFO] - Special tokens file saved in checkpoints/model_80/special_tokens_map.json
  49. global step 85, epoch: 2, batch: 37, loss: 0.10579, speed: 1.79 step/s
  50. global step 90, epoch: 2, batch: 42, loss: 0.21619, speed: 6.46 step/s
  52. [2022-09-09 20:06:32,605] [    INFO] - tokenizer config file saved in checkpoints/model_90/tokenizer_config.json
  53. [2022-09-09 20:06:32,608] [    INFO] - Special tokens file saved in checkpoints/model_90/special_tokens_map.json
  55. global step 95, epoch: 2, batch: 47, loss: 0.19882, speed: 1.71 step/s
  56. global step 100, epoch: 3, batch: 4, loss: 0.09295, speed: 8.30 step/s
  58. [2022-09-09 20:06:39,310] [    INFO] - tokenizer config file saved in checkpoints/model_100/tokenizer_config.json
  59. [2022-09-09 20:06:39,313] [    INFO] - Special tokens file saved in checkpoints/model_100/special_tokens_map.json
  61. global step 105, epoch: 3, batch: 9, loss: 0.24489, speed: 1.80 step/s
  62. global step 110, epoch: 3, batch: 14, loss: 0.08912, speed: 7.11 step/s
  64. [2022-09-09 20:06:46,416] [    INFO] - tokenizer config file saved in checkpoints/model_110/tokenizer_config.json
  65. [2022-09-09 20:06:46,419] [    INFO] - Special tokens file saved in checkpoints/model_110/special_tokens_map.json
  67. global step 115, epoch: 3, batch: 19, loss: 0.12242, speed: 1.75 step/s
  68. global step 120, epoch: 3, batch: 24, loss: 0.06808, speed: 8.03 step/s
  70. [2022-09-09 20:06:53,253] [    INFO] - tokenizer config file saved in checkpoints/model_120/tokenizer_config.json
  71. [2022-09-09 20:06:53,257] [    INFO] - Special tokens file saved in checkpoints/model_120/special_tokens_map.json
  73. global step 125, epoch: 3, batch: 29, loss: 0.03077, speed: 1.77 step/s
  74. global step 130, epoch: 3, batch: 34, loss: 0.12143, speed: 6.62 step/s
  76. [2022-09-09 20:07:00,416] [    INFO] - tokenizer config file saved in checkpoints/model_130/tokenizer_config.json
  77. [2022-09-09 20:07:00,421] [    INFO] - Special tokens file saved in checkpoints/model_130/special_tokens_map.json
  79. global step 135, epoch: 3, batch: 39, loss: 0.12516, speed: 1.74 step/s
  80. global step 140, epoch: 3, batch: 44, loss: 0.20067, speed: 7.14 step/s
  82. [2022-09-09 20:07:07,614] [    INFO] - tokenizer config file saved in checkpoints/model_140/tokenizer_config.json
  83. [2022-09-09 20:07:07,618] [    INFO] - Special tokens file saved in checkpoints/model_140/spec

8. 效果评估

评估过程首先加载召回集corpus.csv，然后抽取向量，插入到hnswlib索引引擎中，然后用测试集的每个query去hnswlib检索，得到返回结果后计算Recall@N。

  1. from data import gen_id2corpus
  2. corpus_file = 'baoxian/corpus.csv'
  3. id2corpus = gen_id2corpus(corpus_file)
  4. # conver_example function's input must be dict
  5. corpus_list = [{idx: text} for idx, text in id2corpus.items()]
  6. print(corpus_list[:4])
  8. [{0: '如何办理企业养老保险'}, {1: '如何为西班牙购买签证保险？'}, {2: '康慧宝需要买多少？'}
  1. from data import convert_example_test
  3. trans_func_corpus = partial(
  4.         convert_example_test,
  5.         tokenizer=tokenizer,
  6.         max_seq_length=max_seq_length)
  7. batchify_fn_corpus = lambda samples, fn=Tuple(
  8.         Pad(axis=0, pad_val=tokenizer.pad_token_id, dtype='int64'),  # text_input
  9.         Pad(axis=0, pad_val=tokenizer.pad_token_type_id, dtype='int64'),  # text_segment
  10.     ): [data for data in fn(samples)]
  11. corpus_ds = MapDataset(corpus_list)
  12. corpus_data_loader = create_dataloader(
  13.         corpus_ds,
  14.         mode='predict',
  15.         batch_size=batch_size,
  16.         batchify_fn=batchify_fn_corpus,
  17.         trans_fn=trans_func_corpus)
  18. for item in corpus_data_loader:
  19.     print(item)
  20.     break
  1. [Tensor(shape=[64, 45], dtype=int64, place=Place(gpu_pinned), stop_gradient=True,
  2.        [[1   , 142 , 449 , ..., 0   , 0   , 0   ],
  3.         [1   , 142 , 449 , ..., 0   , 0   , 0   ],
  4.         [1   , 736 , 1497, ..., 0   , 0   , 0   ],
  5.         ...,
  6.         [1   , 530 , 211 , ..., 0   , 0   , 0   ],
  7.         [1   , 189 , 31  , ..., 0   , 0   , 0   ],
  8.         [1   , 75  , 52  , ..., 0   , 0   , 0   ]]), Tensor(shape=[64, 45], dtype=int64, place=Place(gpu_pinned), stop_gradient=True,
  9.        [[0, 0, 0, ..., 0, 0, 0],
  10.         [0, 0, 0, ..., 0, 0, 0],
  11.         [0, 0, 0, ..., 0, 0, 0],
  12.         ...,
  13.         [0, 0, 0, ..., 0, 0, 0],
  14.         [0, 0, 0, ..., 0, 0, 0],
  15.         [0, 0, 0, ..., 0, 0, 0]])]

上图显示的是预测数据的id的形式，第一个Tensor表示的是input_ids，第二个Tensor表示的是Token_type_ids。
使用hnswlib来构建索引库。
手把手搭建保险问答系统 - 图9
支持三种距离计算的方式，本项目使用的是ip，内积的方式
更多参数设置信息可以参考链接：https://github.com/nmslib/hnswlib。

  1. from ann_util import build_index
  2. # 索引的大小
  3. hnsw_max_elements=1000000
  4. # 控制时间和精度的平衡参数
  5. hnsw_ef=100
  6. hnsw_m=100
  8. final_index = build_index(corpus_data_loader, model,output_emb_size=output_emb_size,hnsw_max_elements=hnsw_max_elements,
  9.                 hnsw_ef=hnsw_ef,
  10.                 hnsw_m=hnsw_m)
  1. [2022-09-09 20:07:08,722] [    INFO] - start build index..........
  2. [2022-09-09 20:07:11,919] [    INFO] - Total index number:3788
  1. def gen_text_file(similar_text_pair_file):
  2.     text2similar_text = {}
  3.     texts = []
  4.     with open(similar_text_pair_file, 'r', encoding='utf-8') as f:
  5.         for line in f:
  6.             splited_line = line.rstrip().split("\t")
  7.             if len(splited_line) != 2:
  8.                 continue
  10.             text, similar_text = line.rstrip().split("\t")
  12.             if not text or not similar_text:
  13.                 continue
  15.             text2similar_text[text] = similar_text
  16.             texts.append({"text": text})
  17.     return texts, text2similar_text
  19. similar_text_pair_file='baoxian/test_pair.csv'  
  20. text_list, text2similar_text = gen_text_file(similar_text_pair_file)
  21. print(text_list[:2])
  22. # print(text2similar_text)
  1. [{'text': '企业养老保险自己怎么办理'}, {'text': '西*牙签证保险怎么买？'}]
  1. query_ds = MapDataset(text_list)
  2. query_data_loader = create_dataloader(
  3.         query_ds,
  4.         mode='predict',
  5.         batch_size=batch_size,
  6.         batchify_fn=batchify_fn_corpus,
  7.         trans_fn=trans_func_corpus)
  8. query_embedding = model.get_semantic_embedding(query_data_loader)
  9. recall_result_dir='recall_result_dir'
  10. os.makedirs(recall_result_dir,exist_ok=True)
  1. recall_num = 10
  2. recall_result_file = 'recall_result.txt'
  3. recall_result_file = os.path.join(recall_result_dir,
  4.                                       recall_result_file)
  5. with open(recall_result_file, 'w', encoding='utf-8') as f:
  6.     for batch_index, batch_query_embedding in enumerate(query_embedding):
  7.         recalled_idx, cosine_sims = final_index.knn_query(
  8.             batch_query_embedding.numpy(), recall_num)
  9.         batch_size = len(cosine_sims)
  10.         for row_index in range(batch_size):
  11.             text_index = batch_size * batch_index + row_index
  12.             for idx, doc_idx in enumerate(recalled_idx[row_index]):
  13.                 f.write("{}\t{}\t{}\n".format(text_list[text_index][
  14.                         "text"], id2corpus[doc_idx], 1.0 - cosine_sims[
  15.                             row_index][idx]))
  1. recall_N = []
  2. from evaluate import recall
  3. from data import get_rs
  4. similar_text_pair="baoxian/test_pair.csv"
  5. rs=get_rs(similar_text_pair,recall_result_file,10)
  6. recall_num = [1, 5, 10]
  7. for topN in recall_num:
  8.     R = round(100 * recall(rs, N=topN), 3)
  9.     recall_N.append(str(R))
  10. for key, val in zip(recall_num, recall_N):
  11.     print('recall@{}={}'.format(key, val))
  13. recall@1=75.826
  14. recall@5=87.186
  15. recall@10=89.696

9. 模型推理

取出一条文本数据，模型预测得到向量后，利用hnswlib进行向量检索，得到候选的问题。

  1. example="买了社保，是不是就不用买商业保险了？"
  2. print('输入文本：{}'.format(example))
  3. encoded_inputs = tokenizer(
  4.             text=[example],
  5.             max_seq_len=max_seq_length)
  6. input_ids = encoded_inputs["input_ids"]
  7. token_type_ids = encoded_inputs["token_type_ids"]
  8. input_ids = paddle.to_tensor(input_ids, dtype='int64')
  9. token_type_ids = paddle.to_tensor(token_type_ids, dtype='int64')
  10. cls_embedding=model.get_pooled_embedding( input_ids=input_ids,token_type_ids=token_type_ids)
  11. # print('提取特征:{}'.format(cls_embedding))
  12. recalled_idx, cosine_sims = final_index.knn_query(
  13.             cls_embedding.numpy(), 10)
  14. print('检索召回')
  15. for doc_idx,cosine_sim in zip(recalled_idx[0],cosine_sims[0]):
  16.     print(id2corpus[doc_idx],cosine_sim)
  1. 输入文本：买了社保，是不是就不用买商业保险了？
  2. 检索召回
  3. 如果你买社会保险，你不需要买商业保险吗？ 0.14880443
  4. 已有社会保险还需要买商业保险吗 0.17555356
  5. 社保跟商业保险的区别在哪？有了社保还需要买商业保险不？ 0.23631889
  6. 通过保险代理公司买保险有什么好处？ 0.35900533
  7. 有了社保要不要追加商业医保 0.3692271
  8. 网上买商业保险有什么好处？ 0.3757109
  9. 个人买商业保险划算吗？还有就是买社保好呀？ 0.38109982
  10. 给孩子买了学平险之后还有必要买其他的保险吗？ 0.3914312
  11. 买保险,一定要找代理人吗,直接去保险公司买不可以吗? 0.3958943
  12. 购买商业保险并获得生存金意味着什么 0.41219425

输入的文本是：”买了社保，是不是就不用买商业保险了？”，经过向量检索，返回了10个候选的问题，其中第一个问题跟输入文本非常接近，说明得到了正确的召回。
下一步就把召回的第一条数据的答案返回给用户：
社保是基础的，就是我们通常说的“五险”包括：基本养老保险、基本医疗保险、失业保险、工伤保险和生育保险。而商业保险则是保障。

10 预测部署

预测部署首先需要把动态图模型转换成静态图，然后基于Mivus构建近似向量检索引擎，向Mivus的索引库中插入语料的向量，最后把抽取向量用PaddleServing部署，使得线上的文本都能够从paddleServing抽取向量。 下面为大家展示部署的几个关键步骤：

10.1 动转静导出

首先把模型转换成静态图模型。

  1. output_path='output'
  2. # 切换成eval模式，关闭dropout
  3. model.eval()
  4. # Convert to static graph with specific input description
  5. model = paddle.jit.to_static(
  6.         model,
  7.         input_spec=[
  8.             paddle.static.InputSpec(
  9.                 shape=[None, None], dtype="int64"),  # input_ids
  10.             paddle.static.InputSpec(
  11.                 shape=[None, None], dtype="int64")  # segment_ids
  12.         ])
  13. # Save in static graph model.
  14. save_path = os.path.join(output_path, "inference")
  15. paddle.jit.save(model, save_path)

10.2 问答检索引擎

模型准备结束以后，开始搭建 Milvus 的语义检索引擎，用于语义向量的快速检索，本项目使用Milvus开源工具进行向量检索，Milvus 的搭建教程请参考官方教程 Milvus官方安装教程本案例使用的是 Milvus 的1.1.1 CPU版本，建议使用官方的 Docker 安装方式，简单快捷。

10.3 Paddle Serving 部署

使用Pipeline的方式进行部署。

  1. dirname="output"
  2. # 模型的路径
  3. model_filename="inference.get_pooled_embedding.pdmodel"
  4. # 参数的路径
  5. params_filename="inference.get_pooled_embedding.pdiparams" 
  6. # server的保存地址
  7. server_path="serving_server"
  8. # client的保存地址
  9. client_path="serving_client"
  10. # 指定输出的别名
  11. feed_alias_names=None
  12. # 制定输入的别名
  13. fetch_alias_names="output_embedding"
  14. # 设置为True会显示日志
  15. show_proto=False
  16. serving_io.inference_model_to_serving(
  17.         dirname=dirname,
  18.         serving_server=server_path,
  19.         serving_client=client_path,
  20.         model_filename=model_filename,
  21.         params_filename=params_filename,
  22.         show_proto=show_proto,
  23.         feed_alias_names=feed_alias_names,
  24.         fetch_alias_names=fetch_alias_names)
  26. (dict_keys(['input_ids', 'token_type_ids']), dict_keys(['elementwise_div_0']))

搭建结束以后，就可以启动server部署服务，使用client端访问server端就行了。具体细节参考代码：https://github.com/PaddlePaddle/PaddleNLP/tree/develop/applications/question_answering/faq_finance/deploy/python

  1. !rm -rf output/
  2. # !rm -rf checkpoints/
  3. !rm -rf serving_server/
  4. !rm -rf serving_client/

11 参考文献

[1] Gao, Tianyu, Xingcheng Yao, and Danqi Chen. “SimCSE: Simple Contrastive Learning of Sentence Embeddings.” ArXiv:2104.08821 [Cs], April 18, 2021. http://arxiv.org/abs/2104.08821.
[2] Wu, Xing, et al. “ESimCSE: Enhanced Sample Building Method for Contrastive Learning of Unsupervised Sentence Embedding.” arXiv preprint arXiv:2109.04380 (2021). https://arxiv.org/abs/2109.04380.
[3] Liang, Xiaobo, Lijun Wu, Juntao Li, Yue Wang, Qi Meng, Tao Qin, Wei Chen, Min Zhang, and Tie-Yan Liu. “R-Drop: Regularized Dropout for Neural Networks.” ArXiv:2106.14448 [Cs], June 28, 2021. http://arxiv.org/abs/2106.14448.