bert中文分类模型训练+推理+部署

文章预览：

*
– 0. bert简介
– 1. bert结构
– 1. bert中文分类模型训练
–
+ 1 下载bert项目代码
+
* 代码结构
+ 2 下载中文预训练模型
+ 3 制作中文训练数据集
– 2. bert模型推理
–
+ 1.tensorflow推理
– 2. onnxruntime推理
–
+ 1. checkpoint格式转换为saveModel格式
+ 2. saveModel格式转换为onnx格式
+ 3. 使用onnxruntime推理onnx格式模型

0. bert简介

• BERT（Bidirectional Encoder Representation from Transformers）是google-research在2018年10月提出的一种预训练模型，在11种不同NLP测试中创出SOTA表现，成为NLP发展史上里程碑式的模型成就。
• 本篇文章从实践入手，带领大家进行Bert的中文文本分类模型的训练和推理的使用教程。

1. bert结构

1. bert中文分类模型训练

bert训练主要分为两个阶段：预训练阶段和 Fine-tuning 阶段。

什么是预训练？
BERT是一个预训练的模型，那么什么是预训练呢？举例子进行简单的介绍
假设已有A训练集，先用A对网络进行预训练，在A任务上学会网络参数，然后保存以备后用，当来一个新的任务B，采取相同的网络结构，网络参数初始化的时候可以加载A学习好的参数，其他的高层参数随机初始化，之后用B任务的训练数据来训练网络，当加载的参数保持不变时，称为”frozen”，当加载的参数随着B任务的训练进行不断的改变，称为”fine-tuning”，即更好地把参数进行调整使得更适合当前的B任务
优点：当任务B的训练数据较少时，很难很好的训练网络，但是获得了A训练的参数，会比仅仅使用B训练的参数更优

预训练
预训练阶段与 Word2Vec，ELMo 等类似，是在大型数据集上根据一些预训练任务训练得到。预训练需要巨大的运算资源，google官方预训练一个语言模型，需要在 4 到 16 个 Cloud TPU 训练四天的时间，幸运的是，google官方开源了许多预训练模型，包括中文预训练模型。大多数 NLP 研究人员永远不需要从头开始预训练他们自己的模型。

微调
Fine-tuning 阶段是后续用于一些下游任务的时候，在预训练模型基础之上进行微调，例如文本分类，词性标注，问答系统等，BERT 无需调整结构就可以在不同的任务上进行微调。

1 下载bert项目代码

https://github.com/google-research/bert

代码结构

• 预训练
  在开源的代码中，预训练的入口是在run_pretraining.py。
• 微调
  而微调的入口针对不同的任务分别在run_classifier.py和run_squad.py。
  其中run_classifier.py用于文本分类任务的训练。
  而run_squad.py用于阅读理解任务的训练。
  

; 2 下载中文预训练模型

对于中文而言，google公布了一个参数较小的BERT预训练模型。

• 模型下载地址

https://github.com/google-research/bert/blob/master/multilingual.md

• 进入下载页面，选择： BERT-Base, Chinese进行下载。

• 下载完成后，解压至与run_classifier.py同一级目录。
• 模型文件说明
  
  bert_model.ckpt：存储得模型变量
  vocab.txt：中文文本采用的字典，
  bert_config.json：是bert在训练时，可选调整的一些配置参数。

3 制作中文训练数据集

对中文文本数据进行分类模型的训练，需要编写程序对训练数据进行处理，使其按照要求传入bert模型进行训练，而BERT代码中processor类就是负责对模型的输入数据进行处理。

们以分类任务为例，介绍如何修改processor类来运行自己数据集上的fine-tune。在run_classsifier.py文件中我们可以看到，google对于一些公开数据集已经写了一些processor，如XnliProcessor,MnliProcessor,MrpcProcessor和ColaProcessor。这给我们提供了一个很好的示例，指导我们如何针对自己的数据集来写processor。

class kedataProcessor(DataProcessor):
  """Processor for the XNLI data set."""

  def get_train_examples(self, data_dir):
      return self._create_examples(

          self._read_tsv(os.path.join(data_dir, "train.tsv")), "train")

  def get_dev_examples(self, data_dir):
      return self._create_examples(
          self._read_tsv(os.path.join(data_dir, "dev.tsv")), "dev")

  def get_test_examples(self, data_dir):
      return self._create_examples(
          self._read_tsv(os.path.join(data_dir, "test.tsv")), "test")

  def get_labels(self):
      # 这里返回的为具体的你的分类的类别
      labelf = open(FLAGS.data_dir+'\label.csv', 'r', newline='', encoding = 'gb2312')
      labeldata = csv.reader(labelf, delimiter="\t")
      labelList=[]
      for line in labeldata:
          label=line[1]
          labelList.append(label)

      return labelList

  def _create_examples(self, lines, set_type):
      """Creates examples for the training and dev sets."""
      examples = []
      for (i, line) in enumerate(lines):
          guid = "%s-%s" % (set_type, i)
          text_a = tokenization.convert_to_unicode(line[1])
          label = tokenization.convert_to_unicode(line[0])
          # print('guid:',guid," text:",text_a,' label:',label)
          examples.append(
              InputExample(guid=guid, text_a=text_a, text_b=None, label=label))

      return examples

自定义的processor里需要继承DataProcessor，并重载获取label的get_labels和获取单个输入的get_train_examples,get_dev_examples和get_test_examples函数。其分别会在main函数的FLAGS.do_train、FLAGS.do_eval和FLAGS.do_predict阶段被调用。
这三个函数的内容是相差无几的，区别只在于需要指定各自读入文件的地址。

以get_train_examples为例，函数需要返回一个由InputExample类组成的list。InputExample类是一个很简单的类，只有初始化函数，需要传入的参数中guid是用来区分每个example的，可以按照train-%d’%(i)的方式进行定义。text_a是一串字符串，text_b则是另一串字符串。在进行后续输入处理后(BERT代码中已包含，不需要自己完成) text_a和text_b将组合成[CLS] text_a [SEP] text_b [SEP]的形式传入模型。最后一个参数label也是字符串的形式，label的内容需要保证出现在get_labels函数返回的list里。

举一个例子，假设我们想要处理一个能够判断句子相似度的模型，现在在data_dir的路径下有一个名为train.csv的输入文件，如果我们现在输入文件的格式如下csv形式：

肯定    嗯，对，是。
求职状态_已找到工作   呃，我有工作了谢谢。
中性    哦，你您说吧。
询问岗位地址    嗯那，那你们就是上班的话，是就近安排吗，我看有很多你们那个
肯定    在听得见我说话吗。
中性    啊，你说你说。
智能助理    的用户暂时无法接听你的电话，短信通知请挂机语音留言，请按一如需人工帮助，请按零
没听清什么事    干啥呀什么事情？
在忙    哦，等会我现在在去面试的路上。
否定    嗯，现在没有了，不好意思啊。

label.csv

0   打错了    226
1   打过电话    127
2   拒绝来电    177
3   电话号码获取    19
4   反问听见与否    55
5   非机主    285
6   否定    4477
7   福利_其他   15
8   福利_食宿   47
9   福利_五险一金   83
10  岗位_年龄要求   58

修改processor字典
修改完成processor后，需要在在原本main函数的processor字典里，加入修改后的processor类，即可在运行参数里指定调用该processor。

processors = {
      "cola": ColaProcessor,
      "mnli": MnliProcessor,
      "mrpc": MrpcProcessor,
      "xnli": XnliProcessor,
      "kedata": kedataProcessor,
  }

运行run_classifier.py
之后就可以直接运行run_classsifier.py进行模型的训练。在运行时需要制定一些参数，一个较为完整的运行参数如下所示：

BERT_BASE_DIR=/path/to/bert/chinese_L-12_H-768_A-12 #全局变量 下载的预训练bert地址
MY_DATASET=/path/to/kedata #全局变量 数据集所在地址

python run_classifier.py \
  --task_name=kedata \ #自己添加processor在processors字典里的key名
  --do_train=true \
  --do_eval=true \
  --dopredict=true \
  --data_dir=$MY_DATASET \
  --vocab_file=$BERT_BASE_DIR/vocab.txt \
  --bert_config_file=$BERT_BASE_DIR/bert_config.json \
  --init_checkpoint=$BERT_BASE_DIR/bert_model.ckpt \
  --max_seq_length=128 \ #模型参数
  --train_batch_size=32 \
  --learning_rate=5e-5 \
  --num_train_epochs=2.0 \
  --output_dir=/tmp/selfsim_output/ #模型输出路径

2. bert模型推理

1.tensorflow推理

• 问题：
  用Estimater.predict总是把模型重新load一遍，这样工程业务根本没法用。

• 解决方案：

• 使用python的生成器，让程序”误以为”有很多序列需要预测，这里构造yield形式即可；

• 利用tf.data.Dataset.from_generator，加载生成器，声明好数据结构和类型；
• 利用class类的实例变量self的全局性，通过self.inputs把数据”喂给到”生成器内部，这样就保证了数据的”源源不断”；
• 程序需要close的机制，用于保证停掉生成器的工作。

from tokenization import FullTokenizer, validate_case_matches_checkpoint
from modeling import BertConfig
from run_classifier import model_fn_builder
import tensorflow as tf
from tensorflow.python.estimator.estimator import Estimator
from tensorflow.python.estimator.run_config import RunConfig
from run_classifier import FLAGS,InputExample,convert_single_example
import csv
import os
import numpy as np

class model(object):
    def __init__(self, labelfile,vocabfile,bert_config_file,init_checkpoint,ckptdir,max_seq_length):
        self.label = self.loadLabel(labelfile)
        self.closed = False
        self.first_run = True
        self.bert_config_file=bert_config_file
        self.ckptdir=ckptdir

        self.tokenizer = FullTokenizer(
            vocab_file=vocabfile,
            do_lower_case=True)
        self.init_checkpoint = init_checkpoint
        self.seq_length = max_seq_length
        self.text = None
        self.num_examples = None
        self.predictions = None
        self.estimator = self.get_estimator()

    def loadLabel(sel, labelfile):
        labelf = open(labelfile, 'r', newline='', encoding='gbk')
        labeldata = csv.reader(labelf, delimiter="\t")
        labelList = []
        for line in labeldata:
            label = line[1]
            labelList.append(label)
        return labelList

    def get_estimator(self):
        validate_case_matches_checkpoint(True, self.init_checkpoint)
        bert_config = BertConfig.from_json_file(self.bert_config_file)  # 载入bert自定义配置
        if FLAGS.max_seq_length > bert_config.max_position_embeddings:  # 验证配置信息准确性
            raise ValueError(
                "Cannot use sequence length %d because the BERT pre_model "
                "was only trained up to sequence length %d" %
                (self.seq_length, bert_config.max_position_embeddings))
        run_config = RunConfig(
            model_dir=self.ckptdir,
            save_checkpoints_steps=FLAGS.save_checkpoints_steps,
            session_config=None
        )

        model_fn = model_fn_builder(  # 估计器函数，提供Estimator使用的model_fn，内部使用EstimatorSpec构建的
            bert_config=bert_config,
            num_labels=len(self.label),
            init_checkpoint=self.init_checkpoint,
            learning_rate=FLAGS.learning_rate,
            num_train_steps=0,
            num_warmup_steps=0,
            use_tpu=FLAGS.use_tpu,
            use_one_hot_embeddings=FLAGS.use_tpu)
        estimator = Estimator(  # 实例化估计器
            model_fn=model_fn,
            config=run_config,
            warm_start_from=self.init_checkpoint  # 新增预热
        )
        return estimator

    def get_feature(self, index, text):
        example = InputExample(f"text_{index}", text, None, self.label[0])
        feature = convert_single_example(index, example, self.label, self.seq_length, self.tokenizer)
        return feature.input_ids, feature.input_mask, feature.segment_ids, feature.label_id

    def create_generator(self):
        """构建生成器"""
        while not self.closed:
            self.num_examples = len(self.text)
            features = (self.get_feature(*f) for f in enumerate(self.text))

            yield dict(zip(("input_ids", "input_mask", "segment_ids", "label_ids"), zip(*features)))

    def input_fn_builder(self):
        """用于预测单独对预测数据进行创建，不基于文件数据"""
        dataset = tf.data.Dataset.from_generator(
            self.create_generator,
            output_types={'input_ids': tf.int32,
                          'input_mask': tf.int32,
                          'segment_ids': tf.int32,
                          'label_ids': tf.int32},
            output_shapes={
                'label_ids': (None),
                'input_ids': (None, None),
                'input_mask': (None, None),
                'segment_ids': (None, None)}
        )
        return dataset

    def predict(self, text):
        self.text = text
        if self.first_run:
            self.predictions = self.estimator.predict(
                input_fn=self.input_fn_builder, yield_single_examples=True)
            self.first_run = False

        probabilities = next(self.predictions)
        # 获取最大值索引
        index = np.argmax(probabilities["probabilities"])
        label = self.label[index]
        # return [self.label[i] for i in probabilities["probabilities"].argmax(axis=1)]

        return label

    def close(self):
        self.closed = True
pythonfile=os.path.realpath(os.path.realpath(__file__))
pardir=os.path.abspath(os.path.join(pythonfile,os.path.pardir))
labelfile=os.path.join(pardir,'ckpt/label.csv')
init_checkpoint=os.path.join(pardir,'chinese_L-12_H-768_A-12/bert_model.ckpt')
vocabfile=os.path.join(pardir,'chinese_L-12_H-768_A-12/vocab.txt')
bert_config_file=os.path.join(pardir,'chinese_L-12_H-768_A-12/bert_config.json')
ckptdir=os.path.join(pardir,'ckpt/')
max_seq_length=128
def getModel():
    bert = model(labelfile,vocabfile,bert_config_file,init_checkpoint,ckptdir,max_seq_length)
    bert.predict([""])
    return bert

if __name__=="__main__":
    bert=getModel()
    for i in range(1000):
        label=bert.predict(["打错了"])

2. onnxruntime推理

ONNX Runtime是一个高性能的机器学习模型推理引擎。它与PyTorch、TensorFlow以及许多其他支持ONNX标准的框架和工具兼容。ONNX Runtime设计了一个开放和可扩展的体系结构，通过利用内置的图形优化和跨CPU、GPU和边缘设备的各种硬件加速功能，可以轻松地优化和加速推理。ONNX Runtime可以很容易地插入到你的技术堆栈中，因为它可以在Linux、Windows、Mac和Android上工作，并且为Python、c#、c++、C和Java提供了方便的api。

为加快bert的推理时间，部署到服务器上，可食用onnxruntime进行推理加速。

1. checkpoint格式转换为saveModel格式

from tokenization import FullTokenizer, validate_case_matches_checkpoint
from modeling import BertConfig
from run_classifier import model_fn_builder
import tensorflow as tf
from tensorflow.python.estimator.estimator import Estimator
from tensorflow.python.estimator.run_config import RunConfig
from run_classifier import FLAGS
import csv

class Fast(object):
    def __init__(self, labelfile,vocabfile,bert_config_file,init_checkpoint,ckptdir):
        self.label = self.loadLabel(labelfile)
        self.closed = False
        self.first_run = True
        self.bert_config_file=bert_config_file
        self.ckptdir=ckptdir

        self.tokenizer = FullTokenizer(
            vocab_file=vocabfile,
            do_lower_case=True)
        self.init_checkpoint = init_checkpoint
        # self.seq_length = FLAGS.max_seq_length
        self.seq_length = 128
        self.text = None
        self.num_examples = None
        self.predictions = None
        self.estimator = self.get_estimator()

    def loadLabel(sel, labelfile):
        labelf = open(labelfile, 'r', newline='', encoding='gbk')
        labeldata = csv.reader(labelf, delimiter="\t")
        labelList = []
        # for i in range(60):
        #    labelList.append(i)
        for line in labeldata:
            label = line[1]
            labelList.append(label)
        return labelList

    def get_estimator(self):
        validate_case_matches_checkpoint(True, self.init_checkpoint)
        print("FLAGS.bert_config_file:",FLAGS.bert_config_file)
        bert_config = BertConfig.from_json_file(self.bert_config_file)  # 载入bert自定义配置
        if FLAGS.max_seq_length > bert_config.max_position_embeddings:  # 验证配置信息准确性
            raise ValueError(
                "Cannot use sequence length %d because the BERT pre_model "
                "was only trained up to sequence length %d" %
                (self.seq_length, bert_config.max_position_embeddings))
        print("FLAGS.save_checkpoints_steps:",FLAGS.save_checkpoints_steps)
        run_config = RunConfig(
            model_dir=self.ckptdir,
            save_checkpoints_steps=FLAGS.save_checkpoints_steps,
            session_config=None
        )

        model_fn = model_fn_builder(  # 估计器函数，提供Estimator使用的model_fn，内部使用EstimatorSpec构建的
            bert_config=bert_config,
            num_labels=len(self.label),
            init_checkpoint=self.init_checkpoint,
            learning_rate=FLAGS.learning_rate,
            num_train_steps=0,
            num_warmup_steps=0,
            use_tpu=FLAGS.use_tpu,
            use_one_hot_embeddings=FLAGS.use_tpu)
        print("model_fn:",model_fn)
        estimator = Estimator(  # 实例化估计器
            model_fn=model_fn,
            config=run_config,
            warm_start_from=self.init_checkpoint  # 新增预热
        )
        print("estimator.params:",estimator.params)
        print("estimator:",estimator)
        return estimator

    def serving_input_fn(self):
        receiver_tensors = {
            'input_ids': tf.compat.v1.placeholder(dtype=tf.int64, shape=[None, self.seq_length], name='input_ids'),
            'input_mask': tf.compat.v1.placeholder(dtype=tf.int64, shape=[None, self.seq_length], name='input_mask'),
            'segment_ids': tf.compat.v1.placeholder(dtype=tf.int64, shape=[None, self.seq_length], name='segment_ids'),
            'label_ids': tf.compat.v1.placeholder(dtype=tf.int64, shape=[None], name="label_ids")
        }

        return tf.estimator.export.ServingInputReceiver(features= receiver_tensors ,receiver_tensors=receiver_tensors)
    def transModel(self):

        self.estimator.export_saved_model('./savemodel',self.serving_input_fn)

labelfile='./ckpt/label.csv'
init_checkpoint='./chinese_L-12_H-768_A-12/bert_model.ckpt'
vocabfile='./chinese_L-12_H-768_A-12/vocab.txt'
bert_config_file='./chinese_L-12_H-768_A-12/bert_config.json'
ckptdir='./ckpt/'
model = Fast(labelfile,vocabfile,bert_config_file,init_checkpoint,ckptdir)
model.transModel()

2. saveModel格式转换为onnx格式

import os

pbdir="1631247382"
onnxname="model.onnx"
cmdstr="python -m tf2onnx.convert --saved-model ./savemodel/{pbdir} --output ./onnx/{onnxname}".format(pbdir=pbdir,onnxname=onnxname)

os.system(cmdstr)

3. 使用onnxruntime推理onnx格式模型

import onnxruntime as ort
from tokenization import FullTokenizer
from run_classifier import convert_single_example
from run_classifier import InputExample
import time
import numpy as np
import csv

import os

class model(object):
    def __init__(self, vocab_file,labelfile,modelfile,max_seq_length):
        self.closed = False
        self.first_run = True
        self.tokenizer = FullTokenizer(
            vocab_file=vocab_file,
            do_lower_case=True)
        self.seq_length = max_seq_length
        self.label = self.loadLabel(labelfile)

        so = ort.SessionOptions()

        #so.execution_mode = ort.ExecutionMode.ORT_SEQUENTIAL
        # so.execution_mode = ort.ExecutionMode.ORT_PARALLEL

        so.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL

        #self.model = ort.InferenceSession(modelfile,sess_options=so,providers=['CPUExecutionProvider'])
        self.model = ort.InferenceSession(modelfile,sess_options=so,providers=['CUDAExecutionProvider'])
        #self.model.set_providers(['CUDAExecutionProvider'], [{'device_id': device_id,"gpu_mem_limit" :  3  *  1024  *  1024  *  1024}])
        # self.model.set_providers(['CUDAExecutionProvider'], [{'device_id': device_id }])

    def loadLabel(sel,labelfile):
        labelf = open(labelfile, 'r', newline='',encoding='gbk')
        labeldata = csv.reader(labelf, delimiter="\t")
        labelList = []
        #for i in range(60):
        #    labelList.append(i)
        for line in labeldata:
           label = line[1]
           labelList.append(label)
        return labelList

    def get_feature(self, index, text):
        example = InputExample(f"text_{index}", text, None, self.label[0])
        feature = convert_single_example(index, example, self.label, self.seq_length, self.tokenizer)
        return feature.input_ids, feature.input_mask, feature.segment_ids, feature.label_id

    def predict(self, text):
        dataList=[]
        input_ids_L=[]
        input_mask_L=[]
        segment_ids_L=[]
        label_ids_L=[]
        for i in range(len(text)):
            input_ids,input_mask,segment_ids,label_ids=self.get_feature(i,text[i])
            input_ids_L.append(input_ids)
            input_mask_L.append(input_mask)
            segment_ids_L.append(segment_ids)
            label_ids_L.append(label_ids)

        data = {
            "input_ids:0": np.array(input_ids_L, dtype=np.int64),
            "input_mask:0": np.array(input_mask_L, dtype=np.int64),
            "label_ids:0": np.array(label_ids_L, dtype=np.int64),
            "segment_ids:0": np.array(segment_ids_L, dtype=np.int64)
        }
        dataList.append(data)
        result = self.model.run(output_names=["loss/Softmax:0"], input_feed=data)
        label_l=[]
        for i in range(len(text)):
            # 获取最大值索引
            maxProbabilities=max(result[0][i])

            index=np.argmax(result[0][i])

            label=self.label[index]
            item={"label":label,"score":maxProbabilities}
            label_l.append(label)

        return label_l

pythonfile=os.path.realpath(os.path.realpath(__file__))
pardir=os.path.abspath(os.path.join(pythonfile,os.path.pardir))
datadir=os.path.join(pardir,'zhaopin')

labelfile=os.path.join(datadir,'label.csv')
modelfile=os.path.join(datadir,'model.onnx')
vocabfile=os.path.join(pardir,'vocab.txt')
max_seq_length=128

def getModel():
    bert = model(vocabfile,labelfile,modelfile ,max_seq_length)
    return bert

if __name__=="__main__":
    bert=getModel()
    for i in range(1000):
        time1=time.time()
        bert.predict(["已经打过电话了"])

Original: https://blog.csdn.net/weixin_43590290/article/details/120208429
Author: 菜菜菜菜菜菜菜
Title: bert中文分类模型训练+推理+部署