Python ark-nlp文本分类，命名实体识别，关系抽取，文本匹配，预训练模型，机器学习，深度学习，ERNIE，NEZHA_文本识别章节名称 python算法

本文参考了大佬的文档https://github.com/xiangking/ark-nlp#ark-nlp

一、ark-nlp简介

ark-nlp集成了机器学习和深度学习的多个模型，主要用于NLP的任务处理，这里面集合了众多大佬们的汗水，是开源的模型，也是我们这些菜菜们的福音。

（1）环境需求

python 3-3.7（3.8不太稳定）

torch >= 1.0.0，<1.10.0

tqdm >= 4.56.0

jieba >= 0.42.1

transformers >= 3.0.0

zhon >= 1.1.5

scipy >= 1.2.0

scikit-learn >= 0.17.0

（2）安装

pip install --upgrade ark-nlp

清华镜像源：

pip install --upgrade -i https://pypi.tuna.tsinghua.edu.cn/simple ark-nlp

二、Ark_nlp构成简介

（1）Ark_nlp项目结构

（2）预训练模型

（3）文本分类 (Text Classification)

ERT就不用介绍了，讲解一下ERNIE：

ERNIE（Enhanced Representation through Knowledge Integration）是百度基于BERT开发的NLP模型。ERNIE使用了更多的语料，除维基百科等数据集外，还使用了中文维基百科，百度百科，百度新闻，百度贴吧数据集。该模型的参数：L = 12，H = 768，A = 12 （BERT BASE）。ERNIE实现了实体级别的Mask，实体级别的连续Mask改变了训练Task，而BERT是基于单字的Mask。所以在涉及到实体级别的训练和预测时，一般选择ERNIE。但是现在ERNIE已经进化到2.0了。

下面来说说哪吒，NEZHA论文全名为Neural Contextualized Representation For Chinese Language Understanding，来自与华为诺亚方舟实验室。NEZHA论文是也是基于Transformer的预训练模型，从文章来看，它对BERT模型进行了四点改进，增加相对位置编码函数（Functional Relative Positional Encoding）；全词掩码（Whole Word Masking）；混合精度训练（Mixed Precision Training）；优化器改进（LAMB Optimizer）。

RoFormer（Rotary Transformer）是基于旋转式位置编码 RoPE 以及对应的 Transformer 模型的预训练模型，这是一种配合Attention机制能达到“绝对位置编码的方式实现绝对位置编码”的设计。而也正因为这种设计，它还是目前唯一一种可用于线性Attention的相对位置编码。

（4）文本匹配 (Text Matching)

（5）命名实体识别 (Named Entity Recognition)

（6）关系抽取 (Relation Extraction)

三、实际应用

CHIP2021-Task3-临床术语标准化任务-第三名

CHIP2021-Task1-医学对话临床发现阴阳性判别任务-第一名

中文医疗信息处理挑战榜CBLUE

使用方法和示例

（1）文本分类

import torch
import pandas as pd
 
from ark_nlp.model.tc.bert import Bert
from ark_nlp.model.tc.bert import BertConfig
from ark_nlp.model.tc.bert import Dataset
from ark_nlp.model.tc.bert import Task
from ark_nlp.model.tc.bert import get_default_model_optimizer
from ark_nlp.model.tc.bert import Tokenizer
 
# 加载数据集
# train_data_df的columns必选包含"text"和"label"
# text列为文本，label列为分类标签
tc_train_dataset = Dataset(train_data_df)
tc_dev_dataset = Dataset(dev_data_df)
 
# 加载分词器
tokenizer = Tokenizer(vocab='nghuyong/ernie-1.0', max_seq_len=30)
 
# 文本切分、ID化
tc_train_dataset.convert_to_ids(tokenizer)
tc_dev_dataset.convert_to_ids(tokenizer)
 
# 加载预训练模型
config = BertConfig.from_pretrained('nghuyong/ernie-1.0',
                                   num_labels=len(tc_train_dataset.cat2id))
dl_module = Bert.from_pretrained('nghuyong/ernie-1.0', 
                                 config=config)
 
# 任务构建
num_epoches = 10
batch_size = 32
optimizer = get_default_model_optimizer(dl_module)
model = Task(dl_module, optimizer, 'ce', cuda_device=0)
 
# 训练
model.fit(tc_train_dataset, 
          tc_dev_dataset,
          lr=2e-5,
          epochs=5, 
          batch_size=batch_size
         )
 
# 推断
from ark_nlp.model.tc.bert import Predictor
 
tc_predictor_instance = Predictor(model.module, tokenizer, tc_train_dataset.cat2id)
 
tc_predictor_instance.predict_one_sample(待预测文本)

（2）文本匹配

import torch
import pandas as pd
 
from ark_nlp.model.tm.bert import Bert
from ark_nlp.model.tm.bert import BertConfig
from ark_nlp.model.tm.bert import Dataset
from ark_nlp.model.tm.bert import Task
from ark_nlp.model.tm.bert import get_default_model_optimizer
from ark_nlp.model.tm.bert import Tokenizer
 
# 加载数据集
# train_data_df的columns必选包含"text_a"、"text_b"和"label"
# text_a和text_b列为文本，label列为匹配标签
tm_train_dataset = Dataset(train_data_df)
tm_dev_dataset = Dataset(dev_data_df)
 
# 加载分词器
tokenizer = Tokenizer(vocab='nghuyong/ernie-1.0', max_seq_len=30)
 
# 文本切分、ID化
tm_train_dataset.convert_to_ids(tokenizer)
tm_dev_dataset.convert_to_ids(tokenizer)
 
# 加载预训练模型
config = BertConfig.from_pretrained('nghuyong/ernie-1.0', 
                                   num_labels=len(tm_train_dataset.cat2id))
dl_module = Bert.from_pretrained('nghuyong/ernie-1.0', 
                                 config=config)
 
# 任务构建
num_epoches = 10
batch_size = 32
optimizer = get_default_model_optimizer(dl_module)
model = Task(dl_module, optimizer, 'ce', cuda_device=0)
 
# 训练
model.fit(tm_train_dataset, 
          tm_dev_dataset,
          lr=2e-5,
          epochs=5, 
          batch_size=batch_size
         )
 
# 推断
from ark_nlp.model.tm.bert import Predictor
 
tm_predictor_instance = Predictor(model.module, tokenizer, tm_train_dataset.cat2id)
 
tm_predictor_instance.predict_one_sample([待预测文本A, 待预测文本B])

（3）命名实体识别

import torch
import pandas as pd
 
from ark_nlp.model.ner.crf_bert import CRFBert
from ark_nlp.model.ner.crf_bert import CRFBertConfig
from ark_nlp.model.ner.crf_bert import Dataset
from ark_nlp.model.ner.crf_bert import Task
from ark_nlp.model.ner.crf_bert import get_default_model_optimizer
from ark_nlp.model.ner.crf_bert import Tokenizer
 
# 加载数据集
# train_data_df的columns必选包含"text"和"label"
# text列为文本
# label列为列表形式，列表中每个元素是如下组织的字典
# {'start_idx': 实体首字符在文本的位置, 'end_idx': 实体尾字符在文本的位置, 'type': 实体类型标签, 'entity': 实体}
ner_train_dataset = Dataset(train_data_df)
ner_dev_dataset = Dataset(dev_data_df)
 
# 加载分词器
tokenizer = Tokenizer(vocab='nghuyong/ernie-1.0', max_seq_len=30)
 
# 文本切分、ID化
ner_train_dataset.convert_to_ids(tokenizer)
ner_dev_dataset.convert_to_ids(tokenizer)
 
# 加载预训练模型
config = CRFBertConfig.from_pretrained('nghuyong/ernie-1.0', 
                                  num_labels=len(ner_train_dataset.cat2id))
dl_module = CRFBert.from_pretrained('nghuyong/ernie-1.0', 
                                    config=config)
 
# 任务构建
num_epoches = 10
batch_size = 32
optimizer = get_default_model_optimizer(dl_module)
model = Task(dl_module, optimizer, 'ce', cuda_device=0)
 
# 训练
model.fit(ner_train_dataset, 
          ner_dev_dataset,
          lr=2e-5,
          epochs=5, 
          batch_size=batch_size
         )
 
# 推断
from ark_nlp.model.ner.crf_bert import Predictor
 
ner_predictor_instance = Predictor(model.module, tokenizer, ner_train_dataset.cat2id)
 
ner_predictor_instance.predict_one_sample(待抽取文本)

（4）Casrel关系抽取

import torch
import pandas as pd
 
from ark_nlp.model.re.casrel_bert import CasRelBert
from ark_nlp.model.re.casrel_bert import CasRelBertConfig
from ark_nlp.model.re.casrel_bert import Dataset
from ark_nlp.model.re.casrel_bert import Task
from ark_nlp.model.re.casrel_bert import get_default_model_optimizer
from ark_nlp.model.re.casrel_bert import Tokenizer
from ark_nlp.factory.loss_function import CasrelLoss
 
# 加载数据集
# train_data_df的columns必选包含"text"和"label"
# text列为文本
# label列为列表形式，列表中每个元素是如下组织的字典
# [头实体, 头实体首字符在文本的位置, 头实体尾字符在文本的位置, 关系类型, 尾实体, 尾实体首字符在文本的位置, 尾实体尾字符在文本的位置]
re_train_dataset = Dataset(train_data_df)
re_dev_dataset = Dataset(dev_data_df,
                         categories = re_train_dataset.categories,
                         is_train=False)
 
# 加载分词器
tokenizer = Tokenizer(vocab='nghuyong/ernie-1.0', max_seq_len=100)
 
# 文本切分、ID化
# 注意：casrel的代码这部分其实并没有进行切分、ID化，仅是将分词器赋予dataset对象
re_train_dataset.convert_to_ids(tokenizer)
re_dev_dataset.convert_to_ids(tokenizer)
 
# 加载预训练模型
config = CasRelBertConfig.from_pretrained('nghuyong/ernie-1.0',
                                          num_labels=len(re_train_dataset.cat2id))
dl_module = CasRelBert.from_pretrained('nghuyong/ernie-1.0', 
                                       config=config)
 
# 任务构建
num_epoches = 40
batch_size = 16
optimizer = get_default_model_optimizer(dl_module)
model = Task(dl_module, optimizer, CasrelLoss(), cuda_device=0)
 
# 训练
model.fit(re_train_dataset, 
          re_dev_dataset,
          lr=2e-5,
          epochs=5, 
          batch_size=batch_size
         )
 
# 推断
from ark_nlp.model.re.casrel_bert import Predictor
 
casrel_re_predictor_instance = Predictor(model.module, tokenizer, re_train_dataset.cat2id)
 
casrel_re_predictor_instance.predict_one_sample(待抽取文本)

（5）PRGC关系抽取

import torch
import pandas as pd
 
from ark_nlp.model.re.prgc_bert import PRGCBert
from ark_nlp.model.re.prgc_bert import PRGCBertConfig
from ark_nlp.model.re.prgc_bert import Dataset
from ark_nlp.model.re.prgc_bert import Task
from ark_nlp.model.re.prgc_bert import get_default_model_optimizer
from ark_nlp.model.re.prgc_bert import Tokenizer
 
# 加载数据集
# train_data_df的columns必选包含"text"和"label"
# text列为文本
# label列为列表形式，列表中每个元素是如下组织的字典
# [头实体, 头实体首字符在文本的位置, 头实体尾字符在文本的位置, 关系类型, 尾实体, 尾实体首字符在文本的位置, 尾实体尾字符在文本的位置]
re_train_dataset = Dataset(train_df, is_retain_dataset=True)
re_dev_dataset = Dataset(dev_df,
                         categories = re_train_dataset.categories,
                         is_train=False)
 
# 加载分词器
tokenizer = Tokenizer(vocab='nghuyong/ernie-1.0', max_seq_len=100)
 
# 文本切分、ID化
re_train_dataset.convert_to_ids(tokenizer)
re_dev_dataset.convert_to_ids(tokenizer)
 
# 加载预训练模型
config = PRGCBertConfig.from_pretrained('nghuyong/ernie-1.0',
                                          num_labels=len(re_train_dataset.cat2id))
dl_module = PRGCBert.from_pretrained('nghuyong/ernie-1.0', 
                                       config=config)
 
# 任务构建
num_epoches = 40
batch_size = 16
optimizer = get_default_model_optimizer(dl_module)
model = Task(dl_module, optimizer, None, cuda_device=0)
 
# 训练
model.fit(re_train_dataset, 
          re_dev_dataset,
          lr=2e-5,
          epochs=5, 
          batch_size=batch_size
         )
 
# 推断
from ark_nlp.model.re.prgc_bert import Predictor
 
prgc_re_predictor_instance = Predictor(model.module, tokenizer, re_train_dataset.cat2id)
 
prgc_re_predictor_instance.predict_one_sample(待抽取文本)

 总结：ark-nlp模型集合了很多大厂开源的深度学习模型，并且在集成的基础上优化了调用方法，大家可以尽情的使用啦~~~