『NLP经典项目集』10 - 快递单信息抽取

飞桨PaddlePaddle

于 2021-10-28 14:53:58 发布

阅读量1.8k

点赞数 2

文章标签：自然语言处理人工智能深度学习

原文链接：https://aistudio.baidu.com/aistudio/projectdetail/1584124

版权

PaddleNLP简介

PaddleNLP基于飞桨深度学习框架Paddle 2.0开发，拥有覆盖多场景的模型库、简洁易用的全流程API与动静统一的高性能分布式训练能力，旨在帮助开发者提升文本处理、建模效率，提供从模型搭建到训练部署的优质体验，提供基于PaddlePaddle 2.0的NLP领域最佳实践。

GitHub链接：https://github.com/PaddlePaddle/PaddleNLP

丰富的模型库

涵盖了NLP主流应用相关的前沿模型，包括中文词向量、预训练模型、词法分析、文本分类、文本匹配、文本生成、机器翻译、通用对话、问答系统等。
简洁易用的全流程API

深度兼容飞桨2.0的高层API体系，提供更多可复用的文本建模模块，可大幅度减少数据处理、组网、训练环节的代码开发，提高开发效率。
高性能分布式训练

通过高度优化的Transformer网络实现，结合混合精度与Fleet分布式训练API，可充分利用GPU集群资源，高效完成预训练模型的分布式训练。

图1：PaddleNLP API概览

PaddleNLP提供了基本组网单元和预训练模型两类组网API。

图2：一行代码快速实现组网

这里，我们以快递单信息抽取为例，介绍如何使用这两类API完成网络搭建。包括：

方案1: PaddleNLP中的基本组网单元BiGRU、CRF、ViterbiDecoder。
方案2: 通过paddlenlp.embedding的功能，热启动加载中文词向量，提升效果
方案3：使用预训练模型ernie组网

项目介绍 - 如何从快递单中抽取关键信息

本项目将演示如何从用户提供的快递单中，抽取姓名、电话、省、市、区、详细地址等内容，形成结构化信息。辅助物流行业从业者进行有效信息的提取，从而降低客户填单的成本。

快递单信息抽取任务介绍

如何从物流信息中抽取想要的关键信息呢？我们首先要定义好需要抽取哪些字段。

比如现在拿到一个快递单，可以作为我们的模型输入，例如“张三18625584663广东省深圳市南山区学府路东百度国际大厦”，那么序列标注模型的目的就是识别出其中的“张三”为人名（用符号 P 表示），“18625584663”为电话名（用符号 T 表示），“广东省深圳市南山区百度国际大厦”分别是 1-4 级的地址（分别用 A1~A4 表示，可以释义为省、市、区、街道）。

这是一个典型的命名实体识别（Named Entity Recognition，NER）场景，各实体类型及相应符号表示见下表：

抽取实体/字段	符号	抽取结果
姓名	P	张三
电话	T	18625584663
省	A1	广东省
市	A2	深圳市
区	A3	南山区
详细地址	A4	百度国际大厦

序列标注模型介绍

我们可以用序列标注模型来解决快递单的信息抽取任务，下面具体介绍一下序列标注模型。

在序列标注任务中，一般会定义一个标签集合，来表示所以可能取到的预测结果。在本案例中，针对需要被抽取的“姓名、电话、省、市、区、详细地址”等实体，标签集合可以定义为：

label = {P-B, P-I, T-B, T-I, A1-B, A1-I, A2-B, A2-I, A3-B, A3-I, A4-B, A4-I, O}

每个标签的定义分别为：

标签	定义
P-B	姓名起始位置
P-I	姓名中间位置或结束位置
T-B	电话起始位置
T-I	电话中间位置或结束位置
A1-B	省份起始位置
A1-I	省份中间位置或结束位置
A2-B	城市起始位置
A2-I	城市中间位置或结束位置
A3-B	县区起始位置
A3-I	县区中间位置或结束位置
A4-B	详细地址起始位置
A4-I	详细地址中间位置或结束位置
O	无关字符

注意每个标签的结果只有 B、I、O 三种，这种标签的定义方式叫做 BIO 体系，也有稍麻烦一点的 BIESO 体系，这里不做展开。其中 B 表示一个标签类别的开头，比如 P-B 指的是姓名的开头；相应的，I 表示一个标签的延续。

对于句子“张三18625584663广东省深圳市南山区百度国际大厦”，每个汉字及对应标签为：

图3：数据集标注示例

注意到“张“，”三”在这里表示成了“P-B” 和 “P-I”，“P-B”和“P-I”合并成“P” 这个标签。这样重新组合后可以得到以下信息抽取结果：

张三	18625584663	广东省	深圳市	南山区	百度国际大厦
P	T	A1	A2	A3	A4

门控循环单元（GRU，Gate Recurrent Unit）

BIGRU是一种经典的循环神经网络（RNN，Recurrent Neural Network），用于对句子等序列信息进行建模。这里我们重点解释下其概念和相关原理。一个 RNN 的示意图如下所示，

图4：RNN示意图

左边是原始的 RNN，可以看到绿色的点代码输入 x，红色的点代表输出 y，中间的蓝色是 RNN 模型部分。橙色的箭头由自身指向自身，表示 RNN 的输入来自于上时刻的输出，这也是为什么名字中带有循环（Recurrent）这个词。

右边是按照时间序列展开的示意图，注意到蓝色的 RNN 模块是同一个，只不过在不同的时刻复用了。这时候能够清晰地表示序列标注模型的输入输出。

GRU为了解决长期记忆和反向传播中梯度问题而提出来的，和LSTM一样能够有效对长序列建模，且GRU训练效率更高。

条件随机场（CRF，Conditional Random Fields)

长句子的问题解决了，序列标注任务的另外一个问题也亟待解决，即标签之间的依赖性。举个例子，我们预测的标签一般不会出现 P-B，T-I 并列的情况，因为这样的标签不合理，也无法解析。无论是 RNN 还是 LSTM 都只能尽量不出现，却无法从原理上避免这个问题。下面要提到的条件随机场（CRF，Conditional Random Field）却很好的解决了这个问题。

条件随机场这个模型属于概率图模型中的无向图模型，这里我们不做展开，只直观解释下该模型背后考量的思想。一个经典的链式 CRF 如下图所示，

图5：CRF示意图

CRF 本质是一个无向图，其中绿色点表示输入，红色点表示输出。点与点之间的边可以分成两类，一类是 $x$ 与 $y$ 之间的连线，表示其相关性；另一类是相邻时刻的 $y$ 之间的相关性。也就是说，在预测某时刻 $y$ 时，同时要考虑相邻的标签解决。当 CRF 模型收敛时，就会学到类似 P-B 和 T-I 作为相邻标签的概率非常低。

预训练模型

除了GRU+CRF方案外，我们也可以使用预训练模型，将序列信息抽取问题，建模成字符级分类问题。这里我们采用强大的语义模型ERNIE，完成字符级分类任务。

图6：ERNIE模型示意图

代码实践

本项目基于PaddleNLP NER example的代码进行修改，分别基于基本组网单元GRU、CRF、TokenEmbedding和预训练模型，实现了多个方案。

方案1: PaddleNLP中的基本组网单元BiGRU、CRF、ViterbiDecoder。
方案2: 通过paddlenlp.embedding的功能，热启动加载中文词向量，提升效果
方案3：使用预训练模型ernie组网

AI Studio平台默认安装了Paddle和PaddleNLP，并定期更新版本。如需手动更新Paddle，可参考飞桨安装说明，安装相应环境下最新版飞桨框架。

使用如下命令确保安装最新版PaddleNLP：

!pip install --upgrade paddlenlp -i https://pypi.org/simple

Collecting paddlenlp
[?25l  Downloading https://files.pythonhosted.org/packages/b0/7d/6c24cda54d018d350ee342f715523ade7871660444ed95f3d3e753d6f388/paddlenlp-2.0.8-py3-none-any.whl (571kB)
[K     |████████████████████████████████| 573kB 194kB/s eta 0:00:01
[?25hRequirement already satisfied, skipping upgrade: jieba in /opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages (from paddlenlp) (0.42.1)
Requirement already satisfied, skipping upgrade: seqeval in /opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages (from paddlenlp) (1.2.2)
Requirement already satisfied, skipping upgrade: colorama in /opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages (from paddlenlp) (0.4.4)
Requirement already satisfied, skipping upgrade: colorlog in /opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages (from paddlenlp) (4.1.0)
Requirement already satisfied, skipping upgrade: multiprocess in /opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages (from paddlenlp) (0.70.11.1)
Requirement already satisfied, skipping upgrade: h5py in /opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages (from paddlenlp) (2.9.0)
Requirement already satisfied, skipping upgrade: numpy>=1.14.0 in /opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages (from seqeval->paddlenlp) (1.20.3)
Requirement already satisfied, skipping upgrade: scikit-learn>=0.21.3 in /opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages (from seqeval->paddlenlp) (0.24.2)
Requirement already satisfied, skipping upgrade: dill>=0.3.3 in /opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages (from multiprocess->paddlenlp) (0.3.3)
Requirement already satisfied, skipping upgrade: six in /opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages (from h5py->paddlenlp) (1.15.0)
Requirement already satisfied, skipping upgrade: threadpoolctl>=2.0.0 in /opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages (from scikit-learn>=0.21.3->seqeval->paddlenlp) (2.1.0)
Requirement already satisfied, skipping upgrade: scipy>=0.19.1 in /opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages (from scikit-learn>=0.21.3->seqeval->paddlenlp) (1.6.3)
Requirement already satisfied, skipping upgrade: joblib>=0.11 in /opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages (from scikit-learn>=0.21.3->seqeval->paddlenlp) (0.14.1)
Installing collected packages: paddlenlp
  Found existing installation: paddlenlp 2.0.7
    Uninstalling paddlenlp-2.0.7:
      Successfully uninstalled paddlenlp-2.0.7
Successfully installed paddlenlp-2.0.8

PART A. 使用基本组网单元 - BiGRU、CRF、ViterbiDecoder搭建网络

import paddle
import paddle.nn as nn

import paddlenlp
from paddlenlp.datasets import MapDataset
from paddlenlp.data import Stack, Tuple, Pad
from paddlenlp.layers import LinearChainCrf, ViterbiDecoder, LinearChainCrfLoss
from paddlenlp.metrics import ChunkEvaluator
from utils import load_dict, evaluate, predict, parse_decodes1, parse_decodes2

A.1 数据准备

依赖以下词典数据，词典数据存放在conf目录中。

输入文本词典word.dic
对输入文本中特殊字符进行转换的词典q2b.dic
标记标签的词典tag.dic

这里我们提供一份已标注的快递单关键信息数据集。训练使用的数据也可以由大家自己组织数据。数据格式除了第一行是 text_a\tlabel 固定的开头，后面的每行数据都是由两列组成，以制表符分隔，第一列是 utf-8 编码的中文文本，以 \002 分割，第二列是对应每个字的标注，以 \002 分割。

在训练和预测阶段，我们都需要进行原始数据的预处理，具体处理工作包括：

从原始数据文件中抽取出句子和标签，构造句子序列和标签序列
将句子序列中的特殊字符进行转换
依据词典获取词对应的id索引

自定义数据集

# 解压数据集
!unzip -o /home/aistudio/work/data/express_ner.zip -d /home/aistudio/  -x __MACOSX/*

Archive:  /home/aistudio/work/data/express_ner.zip
  inflating: /home/aistudio/express_ner/dev.txt  
  inflating: /home/aistudio/express_ner/train.txt  
  inflating: /home/aistudio/express_ner/test.txt

看一下数据

训练集中除第一行是 text_a\tlabel，后面的每行数据都是由两列组成，以制表符分隔，第一列是 utf-8 编码的中文文本，以 \002 分割，第二列是对应序列标注的结果，以 \002 分割。

!head -2  express_ner/train.txt

!cat ./conf/tag.dic

text_a	label
16620200077宣荣嗣甘肃省白银市会宁县河畔镇十字街金海超市西行50米	T-BT-IT-IT-IT-IT-IT-IT-IT-IT-IT-IP-BP-IP-IA1-BA1-IA1-IA2-BA2-IA2-IA3-BA3-IA3-IA4-BA4-IA4-IA4-IA4-IA4-IA4-IA4-IA4-IA4-IA4-IA4-IA4-IA4-IA4-I
P-B
P-I
T-B
T-I
A1-B
A1-I
A2-B
A2-I
A3-B
A3-I
A4-B
A4-I
O

推荐使用MapDataset()自定义数据集。

如需自定义数据集，我们推荐基于MapDataset或IterDataset自定义。

我们推荐使用yield将数据读取代码写成生成器(generator)的形式，这样可以便捷得构建 MapDataset 和 IterDataset 两种数据集。

MapDataset和IterDataset均提供了map()函数，便于进行任意形式的数据处理。

更详细的方法可参考自定义数据集说明文档和
数据处理说明文档。

def load_dataset(datafiles):
    def read(data_path):
        with open(data_path, 'r', encoding='utf-8') as fp:
            next(fp)
            for line in fp.readlines():
                words, labels = line.strip('\n').split('\t')
                words = words.split('\002')
                labels = labels.split('\002')
                yield words, labels

    if isinstance(datafiles, str):
        return MapDataset(list(read(datafiles)))
    elif isinstance(datafiles, list) or isinstance(datafiles, tuple):
        return [MapDataset(list(read(datafile))) for datafile in datafiles]

train_ds, dev_ds, test_ds = load_dataset(datafiles=('express_ner/train.txt', 'express_ner/dev.txt', 'express_ner/test.txt'))

for i in range(2):
    print(train_ds[i])

(['1', '6', '6', '2', '0', '2', '0', '0', '0', '7', '7', '宣', '荣', '嗣', '甘', '肃', '省', '白', '银', '市', '会', '宁', '县', '河', '畔', '镇', '十', '字', '街', '金', '海', '超', '市', '西', '行', '5', '0', '米'], ['T-B', 'T-I', 'T-I', 'T-I', 'T-I', 'T-I', 'T-I', 'T-I', 'T-I', 'T-I', 'T-I', 'P-B', 'P-I', 'P-I', 'A1-B', 'A1-I', 'A1-I', 'A2-B', 'A2-I', 'A2-I', 'A3-B', 'A3-I', 'A3-I', 'A4-B', 'A4-I', 'A4-I', 'A4-I', 'A4-I', 'A4-I', 'A4-I', 'A4-I', 'A4-I', 'A4-I', 'A4-I', 'A4-I', 'A4-I', 'A4-I', 'A4-I'])
(['1', '3', '5', '5', '2', '6', '6', '4', '3', '0', '7', '姜', '骏', '炜', '云', '南', '省', '德', '宏', '傣', '族', '景', '颇', '族', '自', '治', '州', '盈', '江', '县', '平', '原', '镇', '蜜', '回', '路', '下', '段'], ['T-B', 'T-I', 'T-I', 'T-I', 'T-I', 'T-I', 'T-I', 'T-I', 'T-I', 'T-I', 'T-I', 'P-B', 'P-I', 'P-I', 'A1-B', 'A1-I', 'A1-I', 'A2-B', 'A2-I', 'A2-I', 'A2-I', 'A2-I', 'A2-I', 'A2-I', 'A2-I', 'A2-I', 'A2-I', 'A3-B', 'A3-I', 'A3-I', 'A4-B', 'A4-I', 'A4-I', 'A4-I', 'A4-I', 'A4-I', 'A4-I', 'A4-I'])

构造dataloder

label_vocab = load_dict('./conf/tag.dic')
word_vocab = load_dict('./conf/word.dic')

# 将token转换为id
def convert_tokens_to_ids(tokens, vocab, oov_token=None):
    token_ids = []
    oov_id = vocab.get(oov_token) if oov_token else None
    for token in tokens:
        token_id = vocab.get(token, oov_id)
        token_ids.append(token_id)
    return token_ids

# 将文本和label转换为id
def convert_example(example):
        tokens, labels = example
        token_ids = convert_tokens_to_ids(tokens, word_vocab, 'OOV')
        label_ids = convert_tokens_to_ids(labels, label_vocab, 'O')
        return token_ids, len(token_ids), label_ids

# 调用内置的map()方法，进行数据处理：转换id
train_ds.map(convert_example)
dev_ds.map(convert_example)
test_ds.map(convert_example)

<paddlenlp.datasets.dataset.MapDataset at 0x7f6299ea0b10>

调用map()函数，将文本和标签转换为id后，我们需要组batch，通过paddle.io.DataLoader封装。

通过paddle.io.DataLoader的collate_fn 参数，指定如何将样本列表组合为mini-batch数据。

构建collate_fn时，我们借助PaddleNLP内置的API：

paddlenlp.data.Stack，用于堆叠N个具有相同shape的输入数据来构建一个batch。
paddlenlp.data.Pad，用于堆叠N个输入数据来构建一个batch，每个输入数据将会被padding到N个输入数据中最大的长度。
paddlenlp.data.Tuple，用于将多个batchify函数包装在一起，返回tuple类型。

batchify_fn = lambda samples, fn=Tuple(
        Pad(axis=0, pad_val=word_vocab.get('OOV')),  # token_ids
        Stack(),  # seq_len
        Pad(axis=0, pad_val=label_vocab.get('O'))  # label_ids
    ): fn(samples)

train_loader = paddle.io.DataLoader(
        dataset=train_ds,
        batch_size=32,
        shuffle=True,
        drop_last=True,
        return_list=True,
        collate_fn=batchify_fn)

dev_loader = paddle.io.DataLoader(
        dataset=dev_ds,
        batch_size=32,
        drop_last=True,
        return_list=True,
        collate_fn=batchify_fn)

test_loader = paddle.io.DataLoader(
        dataset=test_ds,
        batch_size=32,
        drop_last=True,
        return_list=True,
        collate_fn=batchify_fn)

您可通过以下小示例清晰理解Stack, Pad, Tuple的作用。

a = [1, 2, 3, 4]
b = [3, 4, 5, 6]
c = [5, 6, 7, 8]
result = Stack()([a, b, c])
print("Stacked Data: \n", result)
print()

a = [1, 2, 3, 4]
b = [5, 6, 7]
c = [8, 9]
result = Pad(pad_val=0)([a, b, c])
print("Padded Data: \n", result)
print()

data = [
        [[1, 2, 3, 4], [1]],
        [[5, 6, 7], [0]],
        [[8, 9], [1]],
       ]
batchify_fn = Tuple(Pad(pad_val=0), Stack())
ids, labels = batchify_fn(data)
print("ids: \n", ids)
print()
print("labels: \n", labels)
print()

Stacked Data: 
 [[1 2 3 4]
 [3 4 5 6]
 [5 6 7 8]]

Padded Data: 
 [[1 2 3 4]
 [5 6 7 0]
 [8 9 0 0]]

ids: 
 [[1 2 3 4]
 [5 6 7 0]
 [8 9 0 0]]

labels: 
 [[1]
 [0]
 [1]]

A.2 网络构建

图3：训练流程图

序列标注任务常用的模型是RNN+CRF。GRU和LSTM都是常用的RNN单元。这里我们以Bi-GRU+CRF模型为例，介绍如何使用 PaddleNLP 定义序列化标注任务的网络结构。如下图所示，GRU的输出可以作为 CRF 的输入，最后 CRF 的输出作为模型整体的预测结果。

图4：Bi-GRU+CRF

class BiGRUWithCRF(nn.Layer):
    def __init__(self,
                 emb_size,
                 hidden_size,
                 word_num,
                 label_num,
                 use_w2v_emb=False):
        super(BiGRUWithCRF, self).__init__()
        if use_w2v_emb:
            self.word_emb = TokenEmbedding(
                extended_vocab_path='./conf/word.dic', unknown_token='OOV')
        else:
            self.word_emb = nn.Embedding(word_num, emb_size)
        self.gru = nn.GRU(emb_size,
                          hidden_size,
                          num_layers=2,
                          direction='bidirectional')
        self.fc = nn.Linear(hidden_size * 2, label_num + 2)  # BOS EOS
        self.crf = LinearChainCrf(label_num)
        self.decoder = ViterbiDecoder(self.crf.transitions)

    def forward(self, x, lens):
        embs = self.word_emb(x)
        output, _ = self.gru(embs)
        output = self.fc(output)
        _, pred = self.decoder(output, lens)
        return output, lens, pred

# Define the model netword and its loss
network = BiGRUWithCRF(300, 300, len(word_vocab), len(label_vocab))
model = paddle.Model(network)

这里的use_w2v_emb参数，决定是否使用预训练的词向量对embedding层进行初始化。

A.3 网络配置

定义网络结构后，需要配置优化器、损失函数、评价指标。

评价指标

针对每条序列样本的预测结果，序列标注任务将预测结果按照语块（chunk）进行结合并进行评价。评价指标通常有 Precision、Recall 和 F1。

Precision，精确率，也叫查准率，由模型预测正确的个数除以模型总的预测的个数得到，关注模型预测出来的结果准不准
Recall，召回率，又叫查全率，由模型预测正确的个数除以真实标签的个数得到，关注模型漏了哪些东西
F1，综合评价指标，计算公式如下， $\frac{2*Precision*Recall}{Precision+Recall}$ ，同时考虑 Precision 和 Recall ，是 Precision 和 Recall 的折中。

paddlenlp.metrics中集成了ChunkEvaluator评价指标，并逐步丰富中，

optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
crf_loss = LinearChainCrfLoss(network.crf)
chunk_evaluator = ChunkEvaluator(label_list=label_vocab.keys(), suffix=True)
model.prepare(optimizer, crf_loss, chunk_evaluator)

A.4 模型训练

model.fit(train_data=train_loader,
              eval_data=dev_loader,
              epochs=10,
              save_dir='./results',
              log_freq=1)



![](https://img-blog.csdnimg.cn/img_convert/63c6a3c26db9df726c5b47e16d8f31aa.png)

### A.5 模型评估
调用`model.evaluate`，查看序列化标注模型在测试集（test.txt）上的评测结果。


```python
model.evaluate(eval_data=test_loader, log_freq=1)

Eval begin...
step 1/6 - loss: 0.0000e+00 - precision: 1.0000 - recall: 1.0000 - f1: 1.0000 - 105ms/step
step 2/6 - loss: 0.0000e+00 - precision: 0.9896 - recall: 0.9922 - f1: 0.9909 - 110ms/step
step 3/6 - loss: 22.5424 - precision: 0.9808 - recall: 0.9808 - f1: 0.9808 - 107ms/step
step 4/6 - loss: 0.1191 - precision: 0.9791 - recall: 0.9804 - f1: 0.9797 - 110ms/step
step 5/6 - loss: 0.0000e+00 - precision: 0.9812 - recall: 0.9822 - f1: 0.9817 - 109ms/step
step 6/6 - loss: 0.0000e+00 - precision: 0.9688 - recall: 0.9738 - f1: 0.9713 - 109ms/step
Eval samples: 192





{'loss': [0.0],
 'precision': 0.96875,
 'recall': 0.9738219895287958,
 'f1': 0.9712793733681463}

A.6 预测

利用已有模型，可在未知label的数据集（此处复用测试集test.txt）上进行预测，得到模型预测结果及各label的概率。

outputs, lens, decodes = model.predict(test_data=test_loader)
preds = parse_decodes1(test_ds, decodes, lens, label_vocab)
print(len(preds))
print('\n'.join(preds[:5]))

Predict begin...
step 6/6 [==============================] - ETA: 0s - 71ms/ste - ETA: 0s - 71ms/ste - 71ms/step          
Predict samples: 192
192
('黑龙江省', 'A1')('双鸭山市', 'A2')('尖山区', 'A3')('八马路与东平行路交叉口北40米', 'A4')('韦业涛', 'P')('18600009172', 'T')
('广西壮族自治区', 'A1')('桂林市', 'A2')('雁山区', 'A3')('雁山镇西龙村老年活动中心', 'A4')('17610348888', 'T')('羊卓卫', 'P')
('15652864561', 'T')('河南省', 'A1')('开封市', 'A2')('顺河回族区', 'A3')('顺河区公园路32号', 'A4')('赵本山', 'P')
('河北省', 'A1')('唐山市', 'A2')('玉田县', 'A3')('无终大街159号', 'A4')('18614253058', 'T')('尚汉生', 'P')
('台湾', 'A1')('台中市', 'A2')('北区', 'A3')('北区锦新街18号', 'A4')('18511226708', 'T')('蓟丽', 'P')

PART B 优化进阶-使用预训练的词向量优化模型效果

在Baseline版本中，我们调用了paddle.nn.Embedding获取词的向量表示。

这里，我们调用paddlenlp.embeddings中内置的向量表示TokenEmbedding，能够提升效果。

这里的use_w2v_emb参数，决定是否使用预训练的词向量对embedding层进行初始化。

from paddlenlp.embeddings import TokenEmbedding # EMB

network = BiGRUWithCRF(300, 300, len(word_vocab), len(label_vocab), True)
model = paddle.Model(network)

optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
crf_loss = LinearChainCrfLoss(network.crf)
chunk_evaluator = ChunkEvaluator(label_list=label_vocab.keys(), suffix=True)
model.prepare(optimizer, crf_loss, chunk_evaluator)

100%|██████████| 694483/694483 [00:10<00:00, 69213.46it/s]
[2021-08-30 09:42:49,527] [    INFO] - Loading token embedding...
[2021-08-30 09:42:51,029] [    INFO] - Start extending vocab.
[2021-08-30 09:42:58,697] [    INFO] - Finish extending vocab.
[2021-08-30 09:43:01,132] [    INFO] - Finish loading embedding vector.
[2021-08-30 09:43:01,135] [    INFO] - Token Embedding info:             
Unknown index: 20939             
Unknown token: OOV             
Padding index: 643697             
Padding token: [PAD]             
Shape :[643698, 300]

model.fit(train_data=train_loader,
            eval_data=dev_loader,
            epochs=10,
            save_dir='./results',
            log_freq=1)



![](https://img-blog.csdnimg.cn/img_convert/0e8f40d95abe62c3517a5b16074cf063.png)


```python
model.evaluate(eval_data=test_loader)

Eval begin...
step 6/6 - loss: 0.0000e+00 - precision: 0.9749 - recall: 0.9834 - f1: 0.9791 - 103ms/step
Eval samples: 192





{'loss': [0.0],
 'precision': 0.9749134948096886,
 'recall': 0.9834205933682374,
 'f1': 0.9791485664639443}

模型在验证集上的f1 score较之前有明显提升。

outputs, lens, decodes = model.predict(test_data=test_loader)
preds = parse_decodes1(test_ds, decodes, lens, label_vocab)

print('\n'.join(preds[:10]))

Predict begin...
step 6/6 [==============================] - ETA: 0s - 72ms/ste - ETA: 0s - 71ms/ste - 73ms/step          
Predict samples: 192
('黑龙江省', 'A1')('双鸭山市', 'A2')('尖山区', 'A3')('八马路与东平行路交叉口北40米', 'A4')('韦业涛', 'P')('18600009172', 'T')
('广西壮族自治区', 'A1')('桂林市', 'A2')('雁山区', 'A3')('雁山镇西龙村老年活动中心', 'A4')('17610348888', 'T')('羊卓卫', 'P')
('15652864561', 'T')('河南省', 'A1')('开封市', 'A2')('顺河回族区', 'A3')('顺河区公园路32号', 'A4')('赵本山', 'P')
('河北省', 'A1')('唐山市', 'A2')('玉田县', 'A3')('无终大街159号', 'A4')('18614253058', 'T')('尚汉生', 'P')
('台湾', 'A1')('台中市', 'A2')('北区', 'A3')('北区锦新街18号', 'A4')('18511226708', 'T')('蓟丽', 'P')
('廖梓琪', 'P')('18514743222', 'T')('湖北省', 'A1')('宜昌市', 'A2')('长阳土家族自治县', 'A3')('贺家坪镇贺家坪村一组临河1号', 'A4')
('江苏省', 'A1')('南通市', 'A2')('海门市', 'A3')('孝威村孝威路88号', 'A4')('18611840623', 'T')('计星仪', 'P')
('17601674746', 'T')('赵春丽', 'P')('内蒙古自治区', 'A1')('乌兰察布市', 'A2')('凉城县', 'A3')('新建街', 'A4')
('云南省', 'A1')('临沧市', 'A2')('耿马傣族佤族自治县', 'A3')('鑫源路法院对面', 'A4')('许贞爱', 'P')('18510566685', 'T')
('四川省', 'A1')('成都市', 'A2')('双流区', 'A3')('东升镇北仓路196号', 'A4')('耿丕岭', 'P')('18513466161', 'T')

PART C 优化进阶-使用预训练模型

上面我们采用了PaddleNLP中的基本组网单元BiGRU、CRF、ViterbiDecoder组建模型。

接下来，我们采用预训练模型，来看看效果吧。

from paddlenlp.transformers import ErnieTokenizer, ErnieForTokenClassification
from utils import convert_example

C.1 数据准备

定义数据集

沿用前面的数据集。

# Create dataset, tokenizer and dataloader.
train_ds, dev_ds, test_ds = load_dataset(datafiles=(
        './express_ner/train.txt', './express_ner/dev.txt', './express_ner/test.txt'))

数据处理：一键加载预训练模型相应的tokenizer

预训练模型ERNIE对中文数据的处理是以字为单位。PaddleNLP对于各种预训练模型已经内置了相应的tokenizer。指定想要使用的模型名字即可加载对应的tokenizer。

tokenizer作用为将原始输入文本转化成模型model可以接受的输入数据形式。

关于tokenizer更详细的用法介绍参考：使用PaddleNLP语义预训练模型ERNIE优化情感分析

这里使用Python中的偏函数（Partial function）。Partial函数的作用就是：将所作用的函数作为partial()函数的第一个参数，原函数的各个参数依次作为partial()函数的后续参数。

当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。

from functools import partial

label_vocab = load_dict('./conf/tag.dic')

# 设置想要使用模型的名称
MODEL_NAME = "ernie-1.0"
tokenizer = ErnieTokenizer.from_pretrained(MODEL_NAME)

trans_func = partial(convert_example, tokenizer=tokenizer, label_vocab=label_vocab)

train_ds.map(trans_func)
dev_ds.map(trans_func)
test_ds.map(trans_func)
print (train_ds[0])

[2021-08-30 09:48:35,579] [    INFO] - Downloading https://paddlenlp.bj.bcebos.com/models/transformers/ernie/vocab.txt and saved to /home/aistudio/.paddlenlp/models/ernie-1.0
[2021-08-30 09:48:35,581] [    INFO] - Downloading vocab.txt from https://paddlenlp.bj.bcebos.com/models/transformers/ernie/vocab.txt
100%|██████████| 90/90 [00:00<00:00, 3332.04it/s]


([1, 208, 515, 515, 249, 540, 249, 540, 540, 540, 589, 589, 803, 838, 2914, 1222, 1734, 244, 368, 797, 99, 32, 863, 308, 457, 2778, 484, 167, 436, 930, 192, 233, 634, 99, 213, 40, 317, 540, 256, 2], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 40, [12, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 1, 1, 4, 5, 5, 6, 7, 7, 8, 9, 9, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12])

数据加载

使用paddle.io.DataLoader接口多线程异步加载数据。

ignore_label = -1
batchify_fn = lambda samples, fn=Tuple(
    Pad(axis=0, pad_val=tokenizer.pad_token_id),  # input_ids
    Pad(axis=0, pad_val=tokenizer.pad_token_type_id),  # token_type_ids
    Stack(),  # seq_len
    Pad(axis=0, pad_val=ignore_label)  # labels
): fn(samples)

train_loader = paddle.io.DataLoader(
    dataset=train_ds,
    batch_size=200,
    return_list=True,
    collate_fn=batchify_fn)
dev_loader = paddle.io.DataLoader(
    dataset=dev_ds,
    batch_size=200,
    return_list=True,
    collate_fn=batchify_fn)
test_loader = paddle.io.DataLoader(
    dataset=test_ds,
    batch_size=200,
    return_list=True,
    collate_fn=batchify_fn)

C.2 调用模型

调用paddlenlp.transformers.ErnieForTokenClassification.from_pretrained()方法只需指定想要使用的模型名称和文本分类的类别数即可完成定义模型网络。

# Define the model netword and its loss
model = ErnieForTokenClassification.from_pretrained("ernie-1.0", num_classes=len(label_vocab))

[2021-08-30 09:48:35,704] [    INFO] - Downloading https://paddlenlp.bj.bcebos.com/models/transformers/ernie/ernie_v1_chn_base.pdparams and saved to /home/aistudio/.paddlenlp/models/ernie-1.0
[2021-08-30 09:48:35,706] [    INFO] - Downloading ernie_v1_chn_base.pdparams from https://paddlenlp.bj.bcebos.com/models/transformers/ernie/ernie_v1_chn_base.pdparams
100%|██████████| 392507/392507 [00:05<00:00, 66978.95it/s]

C.3 模型配置

适用于ERNIE/BERT这类Transformer模型的迁移优化学习率策略为warmup的动态学习率。

图6：动态学习率示意图

metric = ChunkEvaluator(label_list=label_vocab.keys(), suffix=True)
loss_fn = paddle.nn.loss.CrossEntropyLoss(ignore_index=ignore_label)
optimizer = paddle.optimizer.AdamW(learning_rate=2e-5, parameters=model.parameters())

C.4 模型训练与评估

模型训练的过程通常有以下步骤：

从dataloader中取出一个batch data
将batch data喂给model，做前向计算
将前向计算结果传给损失函数，计算loss。将前向计算结果传给评价方法，计算评价指标。
loss反向回传，更新梯度。重复以上步骤。

每训练一个epoch时，程序将会评估一次，评估当前模型训练的效果。

step = 0
for epoch in range(10):
    # Switch the model to training mode
    model.train()
    for idx, (input_ids, token_type_ids, length, labels) in enumerate(train_loader):
        logits = model(input_ids, token_type_ids)
        loss = paddle.mean(loss_fn(logits, labels))
        loss.backward()
        optimizer.step()
        optimizer.clear_grad()
        step += 1
        print("epoch:%d - step:%d - loss: %f" % (epoch, step, loss))
    evaluate(model, metric, dev_loader)

    paddle.save(model.state_dict(),
                './ernie_result/model_%d.pdparams' % step)
# model.save_pretrained('./checkpoint')
# tokenizer.save_pretrained('./checkpoint')

epoch:0 - step:1 - loss: 2.637663
epoch:0 - step:2 - loss: 2.415838
epoch:0 - step:3 - loss: 2.211699
epoch:0 - step:4 - loss: 2.047472
epoch:0 - step:5 - loss: 1.906023
epoch:0 - step:6 - loss: 1.781460
epoch:0 - step:7 - loss: 1.706305
epoch:0 - step:8 - loss: 1.598978


[2021-08-30 09:48:48,159] [ WARNING] - Compatibility Warning: The params of ChunkEvaluator.compute has been modified. The old version is `inputs`, `lengths`, `predictions`, `labels` while the current version is `lengths`, `predictions`, `labels`.  Please update the usage.


eval precision: 0.073559 - recall: 0.062237 - f1: 0.067426
epoch:1 - step:9 - loss: 1.530092
epoch:1 - step:10 - loss: 1.435075
epoch:1 - step:11 - loss: 1.369539
epoch:1 - step:12 - loss: 1.304705
epoch:1 - step:13 - loss: 1.235642
epoch:1 - step:14 - loss: 1.179712
epoch:1 - step:15 - loss: 1.135550
epoch:1 - step:16 - loss: 1.071953
eval precision: 0.221549 - recall: 0.276703 - f1: 0.246073
epoch:2 - step:17 - loss: 1.036248
epoch:2 - step:18 - loss: 0.982880
epoch:2 - step:19 - loss: 0.935160
epoch:2 - step:20 - loss: 0.888983
epoch:2 - step:21 - loss: 0.843256
epoch:2 - step:22 - loss: 0.800330
epoch:2 - step:23 - loss: 0.777416
epoch:2 - step:24 - loss: 0.718935
eval precision: 0.566188 - recall: 0.597140 - f1: 0.581253
epoch:3 - step:25 - loss: 0.703598
epoch:3 - step:26 - loss: 0.656673
epoch:3 - step:27 - loss: 0.624823
epoch:3 - step:28 - loss: 0.583841
epoch:3 - step:29 - loss: 0.558054
epoch:3 - step:30 - loss: 0.515275
epoch:3 - step:31 - loss: 0.496650
epoch:3 - step:32 - loss: 0.458862
eval precision: 0.906199 - recall: 0.934399 - f1: 0.920083
epoch:4 - step:33 - loss: 0.439503
epoch:4 - step:34 - loss: 0.402498
epoch:4 - step:35 - loss: 0.380200
epoch:4 - step:36 - loss: 0.345838
epoch:4 - step:37 - loss: 0.332623
epoch:4 - step:38 - loss: 0.300654
epoch:4 - step:39 - loss: 0.280774
epoch:4 - step:40 - loss: 0.254305
eval precision: 0.940213 - recall: 0.965517 - f1: 0.952697
epoch:5 - step:41 - loss: 0.242192
epoch:5 - step:42 - loss: 0.216375
epoch:5 - step:43 - loss: 0.211035
epoch:5 - step:44 - loss: 0.185776
epoch:5 - step:45 - loss: 0.183688
epoch:5 - step:46 - loss: 0.161605
epoch:5 - step:47 - loss: 0.150093
epoch:5 - step:48 - loss: 0.135249
eval precision: 0.944901 - recall: 0.966358 - f1: 0.955509
epoch:6 - step:49 - loss: 0.131125
epoch:6 - step:50 - loss: 0.115732
epoch:6 - step:51 - loss: 0.113865
epoch:6 - step:52 - loss: 0.100134
epoch:6 - step:53 - loss: 0.105101
epoch:6 - step:54 - loss: 0.087678
epoch:6 - step:55 - loss: 0.080681
epoch:6 - step:56 - loss: 0.071670
eval precision: 0.959471 - recall: 0.975610 - f1: 0.967473
epoch:7 - step:57 - loss: 0.068680
epoch:7 - step:58 - loss: 0.064690
epoch:7 - step:59 - loss: 0.065727
epoch:7 - step:60 - loss: 0.063814
epoch:7 - step:61 - loss: 0.062155
epoch:7 - step:62 - loss: 0.049901
epoch:7 - step:63 - loss: 0.048644
epoch:7 - step:64 - loss: 0.048384
eval precision: 0.972523 - recall: 0.982338 - f1: 0.977406
epoch:8 - step:65 - loss: 0.041815
epoch:8 - step:66 - loss: 0.039087
epoch:8 - step:67 - loss: 0.040078
epoch:8 - step:68 - loss: 0.044142
epoch:8 - step:69 - loss: 0.045110
epoch:8 - step:70 - loss: 0.038769
epoch:8 - step:71 - loss: 0.031942
epoch:8 - step:72 - loss: 0.034537
eval precision: 0.974188 - recall: 0.984020 - f1: 0.979079
epoch:9 - step:73 - loss: 0.026968
epoch:9 - step:74 - loss: 0.028109
epoch:9 - step:75 - loss: 0.030617
epoch:9 - step:76 - loss: 0.033234
epoch:9 - step:77 - loss: 0.029045
epoch:9 - step:78 - loss: 0.025437
epoch:9 - step:79 - loss: 0.025940
epoch:9 - step:80 - loss: 0.026143
eval precision: 0.980769 - recall: 0.986543 - f1: 0.983648

C.5 模型预测

训练保存好的训练，即可用于预测。如以下示例代码自定义预测数据，调用predict()函数即可一键预测。

preds = predict(model, test_loader, test_ds, label_vocab)
file_path = "ernie_results.txt"
with open(file_path, "w", encoding="utf8") as fout:
    fout.write("\n".join(preds))
# Print some examples
print(
    "The results have been saved in the file: %s, some examples are shown below: "
    % file_path)
print("\n".join(preds[:10]))

The results have been saved in the file: ernie_results.txt, some examples are shown below: 
('黑龙江省', 'A1')('双鸭山市', 'A2')('尖山区', 'A3')('八马路与东平行路交叉口北40米', 'A4')('韦业涛', 'P')('18600009172', 'T')
('广西壮族自治区', 'A1')('桂林市', 'A2')('雁山区', 'A3')('雁山镇西龙村老年活动中心', 'A4')('17610348888', 'T')('羊卓卫', 'P')
('15652864561', 'T')('河南省', 'A1')('开封市', 'A2')('顺河回族区', 'A3')('顺河区', 'A4')('公园路32号', 'A4')('赵本山', 'P')
('河北省', 'A1')('唐山市', 'A2')('玉田县', 'A3')('无终大街159号', 'A4')('18614253058', 'T')('尚汉生', 'P')
('台湾', 'A1')('台中市', 'A2')('北区', 'A3')('北区', 'A4')('锦新街18号', 'A4')('18511226708', 'T')('蓟丽', 'P')
('廖梓琪', 'P')('18514743222', 'T')('湖北省', 'A1')('宜昌市', 'A2')('长阳土家族自治县', 'A3')('贺家坪镇贺家坪村一组临河1号', 'A4')
('江苏省', 'A1')('南通市', 'A2')('海门市', 'A3')('孝威村孝威路88号', 'A4')('18611840623', 'T')('计星仪', 'P')
('17601674746', 'T')('赵春丽', 'P')('内蒙古自治区', 'A1')('乌兰察布市', 'A2')('凉城县', 'A3')('新建街', 'A4')
('云南省', 'A1')('临沧市', 'A2')('耿马傣族佤族自治县', 'A3')('鑫源路法院对面', 'A4')('许贞爱', 'P')('18510566685', 'T')
('四川省', 'A1')('成都市', 'A2')('双流区', 'A3')('东升镇北仓路196号', 'A4')('耿丕岭', 'P')('18513466161', 'T')