SCRM智能对话场景之命名实体识别算法方案

背景

命名实体识别的概念

命名实体识别（英语：Named Entity Recognition），简称NER，是指识别文本中具有特定意义的实体，主要包括人名、地名、机构名、专有名词等，以及时间、数量、货币、比例数值等文字。

举个例子，假如有这么一句话：

ACM宣布，深度学习的三位创造者Yoshua Bengio， Yann LeCun， 以及Geoffrey Hinton获得了2019年的图灵奖。

那么NER的任务就是从这句话中提取出：

机构名：ACM
人名：Yoshua Bengio， Yann LeCun，Geoffrey Hinton
时间：2019年
专有名词：图灵奖

NER系统就是从非结构化的输入文本中抽取出上述实体，并且可以按照业务需求识别出更多类别的实体。

比如产品名称、型号、价格等。因此实体这个概念可以很广，只要是业务需要的特殊文本片段都可以称为实体。

学术上NER所涉及的命名实体一般包括3大类（实体类，时间类，数字类）和7小类（人名、地名、组织机构名、时间、日期、货币、百分比）。

实际应用中，NER模型通常只要识别出人名、地名、组织机构名、日期时间即可，一些系统还会给出专有名词结果（比如缩写、会议名、产品名等）。货币、百分比等数字类实体可通过正则搞定。另外，在一些应用场景下会给出特定领域内的实体，如书名、歌曲名、期刊名等。

NER当前并不算是一个大热的研究课题，因为学术界部分学者认为这是一个已经解决的问题。当然也有学者认为这个问题还没有得到很好地解决。与其他信息检索领域相比，实体命名评测语料较小，容易产生过拟合。

NER算法

NER一直是NLP领域中的研究热点，从早期基于词典和规则的方法，到传统机器学习的方法，到近年来基于深度学习的方法，NER研究进展的大概趋势大致如下图所示。

绝大多数的NER任务需要识别多种实体类别,需要对所有的实体类别评估NER的效 果。基于这个思路，有两类评估指标：

这个方法是认为NER就是一个序列的多分类问题,使用最多的机器学习算法就是HMM、CRF和ME算法,当然SVM算法也可以,只不过SVM不考虑上下文,其中CRF的效果最好,将在深度学习算法中详细讲解,

常用的数据集是CoNLLo3和 OneNotes,分别表示粗粒度任务和细粒度任务。主要的数据标注体系是:IO,BIO,BMEWO和BMEWO+

其中以下BIO更常见：

• BIO：B标记实体的开始，I标记其余部分，非实体是O
• BMOES：B标记开始，E标记结束，中间是M，单字实体是S，非实体是O

NER可以视为一种多分类的任务，NER任务的示意图如下：

NER算法分类，基于学习方式的可以分为：

1.监督学习方法：隐马尔可夫模型、语言模型、最大熵模型、支持向量机(分类)、决策树和条件随机场等

2.半监督学习方法：这一类方法利用标注的小数据集（种子数据）自举学习 (bootstrap)。

3.无监督学习方法：这一类方法利用词汇资源（如WordNet）等进行上下文聚类。

4.混合方法：几种模型相结合或利用统计方法和人工总结的知识库。

基于方式的可以分为：

1.基于规则和词典的方法

2.基于统计的方法

3.基于深度学习的方法

NER算法思想：命名实体识别通常是先进行实体标注，然后识别单个实体，最后再识别复合实体。

NER一般采用准确率 P(Precision)、召回率 (Recall) 以及 F1 值对模型的性能进行评价。3 个评价指标的定义如下：

CRF算法

CRF，英文全称为Conditional Random Field即条件随机场，是典型的基于统计概率学的方法。

随机场是由若干个位置组成的整体，当给每一个位置中按照某种分布随机赋予一个值之后，其全体就叫做随机场(假如我们有一个十个词形成的句子需要做词性标注,这十个词每个词的词性可以在我们已知的词性集合（名词，动词…)中去选择,当我们为每个词选择完词性后，这就形成了一个随机场)。

马尔科夫随机场是随机场的特例，它假设随机场中某一个位置的赋值仅仅与和它相邻的位置的赋值有关，与其不相邻的位置的赋值无关。比如第三个词的词性除了与自己本身的位置有关外，只与第二个词和第四个词的词性有关。

假设马尔科夫随机场中只有X和Y两种变量，X一般是给定的，而Y一般是在给定X的条件下我们的输出。这样马尔科夫随机场就特化成了条件随机场。在十个词的句子词性标注的例子中，X是词，Y是词性，X与Y是随机变量，P(Y|X)是给定X时Y的条件概率分布，若随机变量Y构成的是一个马尔科夫随机场，则称条件概率分布P(Y|X)是条件随机场。

条件随机场定义如下：

现实中一般X和Y有相同的图结构，即：X=(X1,X2,…Xn)，Y=(Y1,Y2,…Yn)。

设P(Y|X)为线性链条件随机场，在随机变量 X 取值为 x 的条件下，随机变量 Y 取值为 y 的条件概率具有如下形式：

要使用条件随机场，就需要定义合适的特征函数，以刻画数据的一些很可能成立或期望成立的经验特性。

训练过程：一套CRF由一套参数λ唯一确定（先定义好各种特征函数）。给定训练集，估计条件随机场模型参数，学习方法主要包括极大似然估计或正则化的极大似然估计等方法求解参数。

预测过程：给定条件随机场P(Y|X)和输入序列x，求条件概率最大输出序列

以词性标注问题为例，给一个句子中的每个单词注明词性。比如“Bob drank coffee at Starbucks”，注明每个单词的词性后是这样的：“Bob (名词) drank(动词) coffee(名词) at(介词) Starbucks(名词)”

用条件随机场来解决这个问题：

以上面的话为例，有5个单词，我们将：(名词，动词，名词，介词，名词)作为一个标注序列，称为l，可选的标注序列有很多种，比如l还可以是这样：（名词，动词，动词，介词，名词），我们要在这么多的可选标注序列中，挑选出一个最靠谱的作为我们对这句话的标注。

怎么判断一个标注序列靠谱不靠谱呢？

就上面展示的两个标注序列来说，第二个显然不如第一个靠谱，因为它把第二、第三个单词都标注成了动词，动词后面接动词，这在一个句子中通常是说不通的。

假如给每一个标注序列打分，打分越高代表这个标注序列越靠谱，至少可以说，凡是标注中出现了动词后面还是动词的标注序列，要给它负分！！

上面所说的动词后面还是动词就是一个特征函数，可以定义一个特征函数集合，用这个特征函数集合来为一个标注序列打分，并据此选出最靠谱的标注序列。也就是说，每一个特征函数都可以用来为一个标注序列评分，把集合中所有特征函数对同一个标注序列的评分综合起来，就是这个标注序列最终的评分值。

CRF中的特征函数，四个参数：

• 句子s（就是要标注词性的句子）
• i，用来表示句子s中第i个单词
• l_i，表示要评分的标注序列给第i个单词标注的词性
• l_i-1，表示要评分的标注序列给第i-1个单词标注的词性

特征函数仅仅依靠当前单词的标签和它前面的单词的标签对标注序列进行评判，这样建立的CRF也叫作线性链CRF，这是CRF中的一种简单情况

特征函数举例：

当l_i是“副词”并且第i个单词以“ly”结尾时，我们就让f1 = 1，其他情况f1为0。

f1特征函数的权重λ1应当是正的。而且λ1越大，表示越倾向于采用那些把以“ly”结尾的单词标注为“副词”的标注序列

如果i=1，l_i=动词，并且句子s是以“？”结尾时，f2=1，其他情况f2=0。同样，λ2应当是正的，并且λ2越大，表示越倾向于采用那些把问句的第一个单词标注为“动词”的标注序列。

如果l_i和l_i-1都是介词，那么f4等于1，其他情况f4=0。这里，我们应当可以想到λ4是负的，并且λ4的绝对值越大，表示越不认可介词后面还是介词的标注序列。

定义好一组特征函数后，我们要给每个特征函数f_j赋予一个权重λ_j。现在，只要有一个句子s，有一个标注序列l，就可以利用前面定义的特征函数集来对l评分

上式中有两个求和，外面的求和用来求每一个特征函数f_j评分值的和，里面的求和用来求句子中每个位置的单词的特征值的和。 进而求解最优的λ1、λ2、λ3等参数。

CRF算法实现

采用CoNLL 2002数据集作为CRF算法的训练数据，依赖sklearn-crfsuite模块实现。标注数据如下所示：

实现如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2022/07/14 6:32 下午
# @Author  : wangpf@neocrm.com
# @File    : sklearn_crf.py

import warnings

import sklearn_crfsuite
from sklearn_crfsuite import metrics

warnings.filterwarnings('ignore')


def load_data(data_path):
    data = list()
    data_sent_with_label = list()
    with open(data_path, mode='r', encoding="latin-1") as f:
        for line in f:
            if line.strip() == "":
                data.append(data_sent_with_label.copy())
                data_sent_with_label.clear()
            else:
                data_sent_with_label.append(tuple(line.strip().split(" ")))
    return data


# 一个单词多个特征函数
def word2features(sent, i):
    word = sent[i][0]

    features = {
        'bias': 1.0,
        'word': word,
        'word.isdigit()': word.isdigit(),
    }
    if i > 0:
        word1 = sent[i - 1][0]
        words = word1 + word
        features.update({
            '-1:word': word1,
            '-1:words': words,
            '-1:word.isdigit()': word1.isdigit(),
        })
    else:
        features['BOS'] = True

    if i > 1:
        word2 = sent[i - 2][0]
        word1 = sent[i - 1][0]
        words = word1 + word2 + word
        features.update({
            '-2:word': word2,
            '-2:words': words,
            '-3:word.isdigit()': word1.isdigit(),
        })

    if i > 2:
        word3 = sent[i - 3][0]
        word2 = sent[i - 2][0]
        word1 = sent[i - 1][0]
        words = word1 + word2 + word3 + word
        features.update({
            '-3:word': word3,
            '-3:words': words,
            '-3:word.isdigit()': word1.isdigit(),
        })

    if i < len(sent) - 1:
        word1 = sent[i + 1][0]
        words = word1 + word
        features.update({
            '+1:word': word1,
            '+1:words': words,
            '+1:word.isdigit()': word1.isdigit(),
        })
    else:
        features['EOS'] = True

    if i < len(sent) - 2:
        word2 = sent[i + 2][0]
        word1 = sent[i + 1][0]
        words = word + word1 + word2
        features.update({
            '+2:word': word2,
            '+2:words': words,
            '+2:word.isdigit()': word2.isdigit(),
        })

    if i < len(sent) - 3:
        word3 = sent[i + 3][0]
        word2 = sent[i + 2][0]
        word1 = sent[i + 1][0]
        words = word + word1 + word2 + word3
        features.update({
            '+3:word': word3,
            '+3:words': words,
            '+3:word.isdigit()': word3.isdigit(),
        })

    return features


# 一个句子多个单词
def sent2features(sent):
    return [word2features(sent, i) for i in range(len(sent))]


def sent2labels(sent):
    return [ele[-1] for ele in sent]


if __name__ == '__main__':

    train = load_data('./data/esp.train')
    valid = load_data('./data/esp.train')
    test = load_data('./data/esp.testa')

    print(len(train), len(valid), len(test))

    sample_text = ''.join([c[0] for c in train[0]])
    sample_tags = [c[1] for c in train[0]]
    print(sample_text)
    print(sample_tags)

    X_train = [sent2features(s) for s in train]
    y_train = [sent2labels(s) for s in train]

    X_dev = [sent2features(s) for s in valid]
    y_dev = [sent2labels(s) for s in valid]
    # **表示该位置接受任意多个关键字（keyword）参数，在函数**位置上转化为词典 [key:value, key:value ]
    crf_model = sklearn_crfsuite.CRF(algorithm='lbfgs', c1=0.25, c2=0.018, max_iterations=100,
                                     all_possible_transitions=True, verbose=True)
    crf_model.fit(X_train, y_train)

    labels = list(crf_model.classes_)
    labels.remove("O")
    y_pred = crf_model.predict(X_dev)
    metrics.flat_f1_score(y_dev, y_pred,
                          average='weighted', labels=labels)
    sorted_labels = sorted(labels, key=lambda name: (name[1:], name[0]))
    print(metrics.flat_classification_report(
        y_dev, y_pred, labels=sorted_labels, digits=3
    ))

CRF参数中的c1、c2分别对应L1和L2正则化的系数，特征处理流程，主要选择处理了如下几个特征：

- 当前词的小写格式
- 当前词的后缀
- 当前词是否全大写 isupper
- 当前词的首字母大写，其他字母小写判断 istitle
- 当前词是否为数字 isdigit
- 当前词的词性
- 当前词的词性前缀
- 还有就是与之前后相关联的词的上述特征（类似于特征模板的定义）

研究人员发现词性特征在实体识别研究中具有较为重要的作用。因此，选择使用 NLTK 对需要识别的句子进行词性标注，然后将词性标注结果作为实体特征进行训练。如下所示特征：

训练集上的效果如下：

在英文场景下，CRF算法取得比较好的效果，特征配置灵活可以达到全局最优，基于统计的命名实体识别的主要方法对比如下：

相比于英文场景，中文场景下NER算法的挑战更大，汉语中NER的难点：

1.汉语文本没有类似英文文本中空格之类的显式标示词的边界标示符。分词会对NER产生影响。

2.现代汉语文本，尤其是网络汉语文本，常出现中英文交替使用，这时汉语命名实体识别的任务还包括识别其中的英文命名实体；

3.在不同领域、场景下,命名实体的外延有差异,存在分类模糊的问题。不同命名实体之间界限不清晰,人名也经常出现在地名和组织名称中,存在大量的交叉和互相包含现象,而且部分命名实体常常容易与普通词混淆,影响识别效率。

4.命名实体构成结构比较复杂,并且某些类型的命名实体词的长度没有一定的限制, 不同的实体有不同的结构,比如组织名存在大量的嵌套、别名、缩略词等问题,没有严格的规律可以遵循;人名中也存在比较长的少数民族人名或翻译过来的外国 人名,没有统一的构词规范。因此,对这类命名实体识别的召回率相对偏低。

Bert-BiLSTM-CRF

中文实体识别任务都是字符级输入，不以中文分词作为输入粒度的原因也很简单，其一分词本身的准确率限制了NER的天花板，其二不同领域NER的词粒度和分词的粒度会存在差异进一步影响模型表现。与此同时，完全采用字符粒度的输入，可能会丢失词边界信息，一般会采用词汇增强的方式，如引入带有词汇和分词信息的Embedding达到词汇增强的目的。

LSTM 一般已经足以用于词性标注、NER等任务，但是再与CRF结合后，能在CRF融合上下文局部特征的优势加持下，使得序列模型对于NER上的性能效果有不错的提升。如下是算法框架图：

输入是wordPiece tokenizer得到的tokenid，进入Bert预训练模型抽取丰富的文本特征得到batch_size * max_seq_len * emb_size的输出向量，输出向量过Bi-LSTM从中提取实体识别所需的特征，得到batch_size * max_seq_len * (2*hidden_size)的向量，最终进入CRF层进行解码，计算最优的标注序列。

第一层 - Bert 解决问题：NER标注数据少，文本信息抽取效果不佳

NER任务需要的文本信息可以大致分成词信息，考虑上下文的词信息，以及信息到实体类型的映射，预训练词向量Word2vec不考虑上下文的词嵌入。Bert强大的信息记忆和抽取能力，可以直接把Bert放在最底层用于抽取考虑上下文的文本信息。

第二层 - BiLSTM 解决问题：抽取用于实体分类的包含上下文的文本信息

在句子中命名实体的正确识别取决于词的上下文，前后两个词对预测标签都很重要，如果能够获取过去和将来的上下文信息对命名实体识别任务很有帮助，BiLSTM的存在是提取双向文本信息，整体上bert把需要的信息都做了提取，BiLSTM只是选择性从中挑选有用的信息做整合。

基本思想是将每个顺序序列和逆序序列呈现到 2个单独的隐藏状态。分别捕获过去和将来的信息然后将连接 2个隐藏状态 作为最终输出，BiLSTM已经被证明在许多机器翻译、问题回答、序列标注等NLP任务中很有用。BiLSTM层的输出是每个标签的分数，在 CRF 层中，选择预测得分最高的标签序列作为最佳答案。

第三层 - CRF 解决问题：实体内标签分类的一致性，T个N分类问题转化为N^T^的分类问题

把实体识别抽象为序列标注问题后，其中一个问题就是label的预测是独立的，但实体识别的准确率是把实体作为整体来计算的，所以需要考虑到实体内label预测的一致性，计算整个标注序列的全局最优，也就是把求解T个N分类问题转化为从N^T^个序列中寻找概率最大的预测序列。

CRF保留马尔可夫状态转移，以及每个状态都依赖完整上下文的优点，直接在全局进行正则化。CRF 层中，选择预测得分最高的标签序列作为最佳答案。

BiLSTM-CRF已经达到或者超过了基于丰富特征的CRF模型，成为目前基于深度学习的NER方法中的最主流模型。在特征方面，该模型继承了深度学习方法的优势，无需特征工程，使用词向量以及字符向量就可以达到很好的效果，如果有高质量的词典特征，能够进一步获得提高。

Bert-BiLSTM-CRF算法实现

中文数据集如下所示：

参考算法框架图，依赖于keras-contrib，数据处理如下：

def load_data():
    train = _parse_data(open('data/train_data.data', 'rb'))
    test = _parse_data(open('data/test_data.data', 'rb'))

    word_counts = Counter(row[0].lower() for sample in train for row in sample)
    vocab = [w for w, f in iter(word_counts.items()) if f >= 2]
    chunk_tags = ['O', 'B-PER', 'I-PER', 'B-LOC', 'I-LOC', "B-ORG", "I-ORG"]

    # save initial config data
    with open('model/config.pkl', 'wb') as outp:
        pickle.dump((vocab, chunk_tags), outp)

    train = _process_data(train, vocab, chunk_tags)
    test = _process_data(test, vocab, chunk_tags)
    return train, test, (vocab, chunk_tags)


def _parse_data(fh):
    #  in windows the new line is '\r\n\r\n' the space is '\r\n' . so if you use windows system,
    #  you have to use recorsponding instructions

    if platform.system() == 'Windows':
        split_text = '\r\n'
    else:
        split_text = '\n'

    string = fh.read().decode('utf-8')
    data = [[row.split() for row in sample.split(split_text)] for
            sample in
            string.strip().split(split_text + split_text)]
    fh.close()
    return data


def _process_data(data, vocab, chunk_tags, maxlen=None, onehot=False):
    if maxlen is None:
        maxlen = max(len(s) for s in data)
    word2idx = dict((w, i) for i, w in enumerate(vocab))
    x = [[word2idx.get(w[0].lower(), 1) for w in s] for s in data]  # set to <unk> (index 1) if not in vocab

    y_chunk = [[chunk_tags.index(w[1]) for w in s] for s in data]

    x = pad_sequences(x, maxlen)  # left padding

    y_chunk = pad_sequences(y_chunk, maxlen, value=-1)

    if onehot:
        y_chunk = numpy.eye(len(chunk_tags), dtype='float32')[y_chunk]
    else:
        y_chunk = numpy.expand_dims(y_chunk, 2)
    return x, y_chunk


def process_data(data, vocab, maxlen=100):
    word2idx = dict((w, i) for i, w in enumerate(vocab))
    x = [word2idx.get(w[0].lower(), 1) for w in data]
    length = len(x)
    x = pad_sequences([x], maxlen)  # left padding
    return x, length

模型实现如下：

from keras.models import Sequential
from keras.layers import Embedding, Bidirectional, LSTM
from keras_contrib.layers import CRF
import process_data
import pickle

EMBED_DIM = 200
BiRNN_UNITS = 200


def create_model(train=True):
    if train:
        (train_x, train_y), (test_x, test_y), (vocab, chunk_tags) = process_data.load_data()
    else:
        with open('model/config.pkl', 'rb') as inp:
            (vocab, chunk_tags) = pickle.load(inp)
    model = Sequential()
    model.add(Embedding(len(vocab), EMBED_DIM, mask_zero=True))  # Random embedding
    model.add(Bidirectional(LSTM(BiRNN_UNITS // 2, return_sequences=True)))
    crf = CRF(len(chunk_tags), sparse_target=True)
    model.add(crf)
    model.summary()
    model.compile('adam', loss=crf.loss_function, metrics=[crf.accuracy])
    if train:
        return model, (train_x, train_y), (test_x, test_y)
    else:
        return model, (vocab, chunk_tags)

完整模型训练及预测代码如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2022/07/14 6:32 下午
# @Author  : wangpf@neocrm.com
# @File    : bilstm_crf_model.py
import pickle
import platform
from collections import Counter
import numpy as np
import numpy
from keras.layers import Embedding, Bidirectional, LSTM
from keras.models import Sequential
from keras.preprocessing.sequence import pad_sequences
from keras_contrib.layers import CRF


def load_data():
    train = _parse_data(open('data/train_data.data', 'rb'))
    test = _parse_data(open('data/test_data.data', 'rb'))

    word_counts = Counter(row[0].lower() for sample in train for row in sample)
    vocab = [w for w, f in iter(word_counts.items()) if f >= 2]
    chunk_tags = ['O', 'B-PER', 'I-PER', 'B-LOC', 'I-LOC', "B-ORG", "I-ORG"]

    # save initial config data
    with open('model/config.pkl', 'wb') as outp:
        pickle.dump((vocab, chunk_tags), outp)

    train = _process_data(train, vocab, chunk_tags)
    test = _process_data(test, vocab, chunk_tags)
    return train, test, (vocab, chunk_tags)


def _parse_data(fh):
    #  in windows the new line is '\r\n\r\n' the space is '\r\n' . so if you use windows system,
    #  you have to use recorsponding instructions

    if platform.system() == 'Windows':
        split_text = '\r\n'
    else:
        split_text = '\n'

    string = fh.read().decode('utf-8')
    data = [[row.split() for row in sample.split(split_text)] for
            sample in
            string.strip().split(split_text + split_text)]
    fh.close()
    return data


def _process_data(data, vocab, chunk_tags, maxlen=None, onehot=False):
    if maxlen is None:
        maxlen = max(len(s) for s in data)
    word2idx = dict((w, i) for i, w in enumerate(vocab))
    x = [[word2idx.get(w[0].lower(), 1) for w in s] for s in data]  # set to <unk> (index 1) if not in vocab

    y_chunk = [[chunk_tags.index(w[1]) for w in s] for s in data]

    x = pad_sequences(x, maxlen)  # left padding

    y_chunk = pad_sequences(y_chunk, maxlen, value=-1)

    if onehot:
        y_chunk = numpy.eye(len(chunk_tags), dtype='float32')[y_chunk]
    else:
        y_chunk = numpy.expand_dims(y_chunk, 2)
    return x, y_chunk


def process_data(data, vocab, maxlen=100):
    word2idx = dict((w, i) for i, w in enumerate(vocab))
    x = [word2idx.get(w[0].lower(), 1) for w in data]
    length = len(x)
    x = pad_sequences([x], maxlen)  # left padding
    return x, length


EMBED_DIM = 200
BiRNN_UNITS = 200


def create_model(train=True):
    if train:
        (train_x, train_y), (test_x, test_y), (vocab, chunk_tags) = load_data()
    else:
        with open('model/config.pkl', 'rb') as inp:
            (vocab, chunk_tags) = pickle.load(inp)
    model = Sequential()
    model.add(Embedding(len(vocab), EMBED_DIM, mask_zero=False))  # Random embedding
    model.add(Bidirectional(LSTM(BiRNN_UNITS // 2, return_sequences=True)))
    crf = CRF(len(chunk_tags), sparse_target=True)
    model.add(crf)
    model.summary()
    model.compile('adam', loss=crf.loss_function, metrics=[crf.accuracy])
    if train:
        return model, (train_x, train_y), (test_x, test_y)
    else:
        return model, (vocab, chunk_tags)


if __name__ == "__main__":
    EPOCHS = 10
    model, (train_x, train_y), (test_x, test_y) = create_model()
    # train model
    model.fit(train_x, train_y, batch_size=16, epochs=EPOCHS, validation_data=[test_x, test_y])
    model.save('model/crf.h5')

    model, (vocab, chunk_tags) = create_model(train=False)
    predict_text = '中华人民共和国国务院总理周恩来在外交部长陈毅的陪同下，连续访问了埃塞俄比亚等非洲10国以及阿尔巴尼亚'
    str, length = process_data.process_data(predict_text, vocab)
    model.load_weights('model/crf.h5')
    raw = model.predict(str)[0][-length:]
    result = [np.argmax(row) for row in raw]
    result_tags = [chunk_tags[i] for i in result]

    per, loc, org = '', '', ''

    for s, t in zip(predict_text, result_tags):
        if t in ('B-PER', 'I-PER'):
            per += ' ' + s if (t == 'B-PER') else s
        if t in ('B-ORG', 'I-ORG'):
            org += ' ' + s if (t == 'B-ORG') else s
        if t in ('B-LOC', 'I-LOC'):
            loc += ' ' + s if (t == 'B-LOC') else s

    print(['person:' + per, 'location:' + loc, 'organzation:' + org])

模型训练过程如下：

预测结果：

模型在数据集上看起来已经很不错，但是在实际应用中还有许多需要解决的问题。例如NER标注样本太少如何解决，垂直领域迁移问题，中文词边界问题和词汇信息增强问题等等。

落地方案

结合CRF的深度的神经网络模型能取得较好的识别效果，但算法依赖海量的业务数据标注样本，离线训练受限于运算力。工业界NER的技术选型一般是“实体词典匹配+模型预测”的框架，实体匹配字典能够很好地覆盖头部流量。实体匹配的优势：

1、聊天文本通常较短、表达形式简单，存在大量重复的描述，即使简单的词典匹配准确率也能达到90%以上

2、NER与具体的业务领域相关，通过挖掘业务数据获取业务实体词典，这样在线匹配的结果也是领域适配的

3、方便不同行业CRM客户接入，只需提供相关实体词典即可

4、词典匹配速度快，几乎不存在性能问题

模型预测的必要性如下：

1、数据流量上涨，复杂的长尾表述，实体词典无法满足日益多样化的用户，而模型预测具备较强的泛化能力

2、词典匹配无法解决歧义问题，如“黄鹤楼美食”，“黄鹤楼”在实体词典中同时是武汉的景点、北京的商家、香烟产品，词典匹配不具备消歧能力，而模型预测则可结合上下文，不会输出“黄鹤楼”是香烟产品

参考美团NER技术落地方案，如下所示：

实体词典匹配、模型预测两路结果合并输出：

采用训练好的CRF权重网络作为打分器，来对实体词典匹配、模型预测两路输出的NER路径进行打分。在词典匹配无结果或是其路径打分值明显低于模型预测时，采用模型识别的结果，其他情况仍然采用词典匹配结果。

实体词典匹配采用基于 Trie 词典的前向最大匹配算法，实现如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2022/07/21 6:32 下午
# @Author  : wangpf@neocrm.com
# @File    : nlp_tag.py
import jionlp as jio
import hanlp

if __name__ == '__main__':
    # 地址解析
    text = '我家在北京市朝阳区朝阳路69号一期4单元1203室，直接给我发快递吧'
    location = jio.parse_location(text)
    print(location)
    # {'province': '北京市', 'city': '北京市', 'county': '朝阳区'}
    # 电话号码提取
    text = '我家在北京市朝阳区朝阳路69号一期4单元1203室，18790288731 0728-5253523'
    phone = jio.extract_phone_number(text)
    print(phone)
    # ['18790288731', '0728-5253523']
    ner = hanlp.load(hanlp.pretrained.ner.MSRA_NER_ELECTRA_SMALL_ZH)
    print(ner([["2021年", "算法", "工程师", "为", "生产", "环境", "带来", "次", "世代", "最", "先进", "的", "多", "语种", "NLP", "技术", "。"], ["阿婆主", "来到", "北京", "立方庭", "参观", "自然", "语义", "科技", "公司", "。"]], tasks='ner*'))
    # 黑名单词典
    ner.dict_blacklist = {'金华'}
    print(ner(['他', '在', '浙江', '金华', '出生', '，', '他', '的', '名字', '叫', '金华', '。']))

    # 需要充足的实体字典
    entity_dicts = {
        'Person': ['张大山', '岳灵珊', '岳不群'],
        'Organization': ['成都市第一人民医院', '四川省水利局']}

    lexicon_ner = jio.ner.LexiconNER(entity_dicts)
    text = '岳不群在四川省水利局上班。'
    result = lexicon_ner(text)
    print(result)

    # 身份证号码解析
    text = '612730199511023659'
    res = jio.parse_id_card(text)
    print(res)

结果如下：

那么问题转换为：

1、维护一套离线词典挖掘算法，动态发掘新词，不断丰富完善词典

2、维护CRF模型

考虑到不同租户的业务场景不一样，依赖标注数据集微调，维护CRF模型的成本相对较高，目前产品可以采用以下两种策略：

1、暂不考虑上下文信息，仅采用基于 Trie 词典的匹配算法，结合正则表达式提取聊天文本中的实体信息；

2、采用部分开源工具接口，内置泛化模型和词典，针对通用场景并兼容业务词典，可以取得较好的效果

上面代码已经提供了词典匹配算法的实现，开源工具主要包括百度Paddle Lac、斯坦福大学Stanza和哈工大的LTP。

百度Paddle Lac标注集主要是以人民日报标注语料，Stanza有一套自己标注语料，LTP则使用的是863标注集，Lac通过深度学习模型联合学习分词、词性标注、专名识别任务，词语重要性，整体效果F1值超过0.91，且可以通过用户词典对模型进行干预：

from LAC import LAC

if __name__ == '__main__':
    # 百度Lac实现
    # 装载LAC模型
    lac = LAC(mode='lac')
    # 装载干预词典, sep参数表示词典文件采用的分隔符，为None时默认使用空格或制表符'\t'
    lac.load_customization('./data/custom.txt', sep=None)
    # 单个样本输入，输入为Unicode编码的字符串
    text = u"马云在1996年11月29日来到杭州的阿里巴巴公司"
    lac_result = lac.run(text)
    print(lac_result)
    # 批量样本输入, 输入为多个句子组成的list，平均速率更快
    texts = [u"马云在1996年11月29日来到杭州的阿里巴巴公司", u"春天的花开秋天的风以及冬天的落阳"]
    lac_result = lac.run(texts)
    print(lac_result)

词典数据custom.txt如下：

输出结果如下，在自定义词典的调整下，效果改善明显，如果对接业务还需要结合正则表达式做第二次过滤：

[['马云', '在', '1996年11月29日', '来到', '杭州', '的', '阿里巴巴公司', '。'], ['PER', 'p', 'TIME', 'v', 'LOC', 'u', 'ORG', 'w']]
[[['马云', '在', '1996年11月29日', '来到', '杭州', '的', '阿里巴巴公司', '。'], ['PER', 'p', 'TIME', 'v', 'LOC', 'u', 'ORG', 'w']], [['春天', '的', '花', '开', '秋天的风', '以及', '冬天', '的', '落', '阳'], ['SEASON', 'u', 'n', 'v', 'n', 'c', 'TIME', 'u', 'vn', 'vn']]]

标签含义如下，LAC中文标签丰富，时间和数量词均能很好识别。

LAC同时支持增量训练，用户可以使用自己的数据，进行增量训练，需要将数据转换为模型输入的格式，如下所示：

LAC/nz 是/v 个/q 优秀/a 的/u 分词/n 工具/n 。/w
百度/ORG 是/v 一家/m 高科技/n 公司/n 。/w
春天/TIME 的/u 花开/v 秋天/TIME 的/u 风/n 以及/c 冬天/TIME 的/u 落阳/n 。/w

相比百度LAC，Stanza支持66种（人类）语言的预训练神经模型，采用pipeline的模式同时实现多个任务，如下所示：

接口如下：

import stanza

if __name__ == '__main__':
    
    # 可以通过pipeline预加载不同语言的模型，也可以通过pipeline选择不同的处理模块，还可以选择是否使用GPU：
    zh_nlp = stanza.Pipeline('zh', use_gpu=False)
    text = "马云在1996年11月29日来到杭州的阿里巴巴公司。"

    doc = zh_nlp(text)
    for sent in doc.sentences:
        print("Sentence：" + sent.text)  # 断句
        print("Tokenize：" + ' '.join(token.text for token in sent.tokens))  # 中文分词
        print("UPOS: " + ' '.join(f'{word.text}/{word.upos}' for word in sent.words))  # 词性标注（UPOS）
        print("XPOS: " + ' '.join(f'{word.text}/{word.xpos}' for word in sent.words))  # 词性标注（XPOS）
        print("NER: " + ' '.join(f'{ent.text}/{ent.type}' for ent in sent.ents))  # 命名实体识别

结果如下：

Sentence：马云在1996年11月29日来到杭州的阿里巴巴公司。
Tokenize：马云 在 1996 年 11 月 29 日 来到 杭州 的 阿里巴巴 公司 。
UPOS: 马云/PROPN 在/ADP 1996/NUM 年/NOUN 11/NUM 月/NOUN 29/NUM 日/NOUN 来到/VERB 杭州/PROPN 的/PART 阿里巴巴/PROPN 公司/NOUN 。/PUNCT
XPOS: 马云/NNP 在/IN 1996/CD 年/NNB 11/CD 月/NNB 29/CD 日/NNB 来到/VV 杭州/NNP 的/DEC 阿里巴巴/NNP 公司/NN 。/.
NER: 马云/PERSON 1996年11月29日/DATE 杭州/GPE 阿里巴巴公司/ORG

Stanza对人名人、时间、地点和企业名均很好地识别出来，虽然标签集合没有LAC丰富，但是识别结果比较可靠。

LTP（Language Technology Platform） 提供了一系列中文自然语言处理工具，用户可以使用这些工具对于中文文本进行分词、词性标注、句法分析等等工作。LTP 提供最基本的三种实体类型人名 Nh、地名 Ns、机构名 Ni的识别。

from ltp import LTP
ltp = LTP() # 默认加载 Small 模型
seg, hidden = ltp.seg(["马云在1996年11月29日来到杭州的阿里巴巴公司。"])  # 分词
print(seg)

ner = ltp.ner(hidden)  # 命名实体识别
tag, start, end = ner[0][0]
print(ner)
for tag, start, end in ner[0]:
    print(tag, ":", "".join(seg[0][start:end + 1]))

运行结果如下：

[['马云', '在', '1996年', '11月', '29日', '来到', '杭州', '的', '阿里巴巴', '公司', '。']]
[[('Nh', 0, 0), ('Ns', 6, 6), ('Ns', 8, 8), ('Ni', 9, 9)]]
Nh : 马云
Ns : 杭州
Ns : 阿里巴巴
Ni : 公司

对比三个主流工具，LAC优势是提供丰富的实体标签，LAC针对中文场景，采用的人民日报语料库丰富，结合业务场景采用正则表达式可定制空间大，是目前场景下较好的解决方案。后续需要留意的有：

1、词典生成依赖挖掘算法和部分人工，需要结合业务场景进行扩展；

2、聊天文本随意性较大，存在错别字、简称、网络新词等，必要情况下需要对基础模型进行增量训练，标注成本带来挑战；

3、需要关注NER算法的性能，当数据量增加以后，对模型的计算能力要求较高；

4、NER依赖于分词算法，分词效果限制算法的上限