命名实体识别（NER）算法

之前做了NER的相关工作，现在想加深一下对NER的认知，便于在以后的工作中能做的更好。

在论文A Survey on Deep Learning for Named Entity Recognition 中对NER工作进行了详尽的介绍。本文根据综述的行文顺序，快速的介绍NER使用的技术，并在最后一小节中附上bert+softmax与bert+crf的相关代码。

标注方案

• BIO
• BIOES

B，开始位置
I，中间位置
E，结束位置
O，other
S，single

这种序列标注框架，每个Token只能属于一种，不能解决重叠实体问题。比如「《叶圣陶散文选集》」中会出现两个实体「叶圣陶」和「叶圣陶散文选集」分别代表「作者」和「作品」两个实体。对于这种嵌套的NER我们需要对其进行分层标注。

问题建模

给定一个符号（Token）序列 $s=(w_1,w_2,...,w_N)$， NER的任务就是要输出一个元组序列 $(I_s,I_e,t)$, 其中每一个元组表示序列s中出现的一个命名实体。 其中，$I_s\in [1,N],I_e\in [1,N]$, 分别代表实体在符号序列中的位置，$t$表示该实体的类别。比如：

评价指标

• 宽松匹配评估（Relaxed-match Evaluation）：当实体位置区间部分重叠,或位置正确类别错误的,都记为正确或部分正确。但因为这样的评估方案不够直观，对于错误分析很不友好，所以并没有被广泛采用。
• 严格匹配评估（Exact-match Evaluation）：当且仅当实体位置区间和类别都正确时判定其为正确。其中F1值又可以分为macro-averaged（宏平均）和micro-averaged（微平均），前者是按照不同实体类别计算F1，然后取平均；后者是把所有识别结果合在一起，再计算F1。 这两者的区别在于实体类别数目不均衡，因为通常语料集中类别数量分布不均衡，模型往往对于大类别的实体学习较好。

宏平均：
$$\begin{gathered} macro\_P=\frac{1}{n}\sum _{i=1}^n{P}_i \\ maco\_R=\frac{1}{n}\sum _{i=1}^n{R}_i \\ macro\_F=\frac{1}{n}\sum _{i=1}^n{F}_i \end{gathered}$$

微平均：
$$\begin{gathered} micro\_P=\frac{{\sum }_{i}T{P}_i}{{\sum }_{i}T{P}_i+{\sum }_{i}F{P}_i} \\ micro\_R=\frac{{\sum }_{i}T{P}_i}{{\sum }_{i}T{P}_i+{\sum }_{i}F{N}_i} \\ micro\_F=\frac{2\times micro\_P\times micro\_R}{micro\_P+micro\_R} \end{gathered}$$

常用的NER方法

如上图所示，常用的NER方法主要分为四个大类：

• 基于规则
• 无监督学习
• 基于人工特征的监督学习方法
• 深度学习方法

目前，深度学习方法是NER常用的方法，本文具体介绍深度学习方法。

深度学习方法（in survey）

本小结按照 综述 的顺序简要介绍 NER中常用的深度学习方法。

输入的分布式表示

输入的分布式可以分为：词语级别表示、字符级别表示和混合表示。

• 词语级别表示： (word2vec/fasttest/glove等)，对于英文而言就是单词，比如 hello。而对中文而言，可能字符级别的表示要更好一些，这是因为基于此的中文NER会受分词效果的影响，切词错误会传递到NER中，会造成累计误差。 但是也有的论文利用了中文词级别的信息来做的，比如：Lattice LSTM。

• 字符级别的表示：（CNN/RNN）。字符级别的表示方法可以比较有效地挖掘如前缀、后缀等sub-word级别的信息，另一方面的优势在于其天然地可以解决OOV问题。
  
  对于中文而言，字符级别是比较常用的表示，但是每个字通常具有多重含义，比如说：“花哨”、“花茶”中的“花”显然含义不同；因此，想要捕捉语义层面的信息的话，就需要对上下文语义进行建模从而充分表达字的含义，常见的就是用CNN来做，RNN也可以。

  比如，18年的一项工作《Contextual String Embeddings for Sequence Labeling》，使用字符级别的神经语言模型产生上下文相关的文本嵌入。大致思路为使用双向RNN编码字符级别嵌入，将一个词的前向和后向隐层状态与词嵌入拼接作为最终词嵌入向量，如下图所示。源码位置
  

• 混合表示：部分研究在词语级别和字符级别外还引入了其他额外信息，如词语相似度、语义依存关系、视觉特征、知识图谱等。某种程度上而言，使用Token Embedding、Position Embedding等预训练得到的类BERT模型也可以划分到混合表示方法中。

上下文编码

• CNN： 如下图所示，主要用于捕捉局部依赖特征。虽然可以通过多层CNN的叠加加大感受野而得到全局特征，但是，对于NER来说，这种长程依赖性还是不足。因此，CNN大多后面可以接LSTM或者attention来强化长程依赖能力。
  

• RNN，常用的有LSTM和GRU，可以获得较好的长程依赖能力。而且由于门机制的存在，也能获得较好的局部依赖性。在NLP中常用BILSTM获得上下文特征。
  
  这里介绍一下Lattice LSTM的工作，该工作主要思想是：根据大量语料构建词典，若当前字符与之前字符构成词汇，则从这些词汇中提取信息，联合更新记忆状态。该论文中的解码层用的是CRF，这里只介绍编码层。
  下图是Lattice LSTM 的结构图：
  
  假设句子$s$由字符$c_1,c_2,\cdots ,c_m$构成，且这些字符可以构成词：$w_1,w_2,\cdots ,w_n$。首先来看对字符的处理，第一步，字符embedding: $x_j^c=e^c(c_j)$。在embedding上有一个BILSTM层，生成$h_j^c$:
  
  生成$x_j^c$和$h_j^c$后，有一个基础的LSTM架构，其中i, o, f分别为输入门，输出门和遗忘门：
  
  那么如何将word的信息加入进去呢？首先对句子中的词汇加embedding层，得到：$w_{b,e}^w=e^w(w_{b,e}^d)$，同样的，对其也增加一个LSTM层，有：
  
  那么字符和词汇的表征都算出来了，接下来就是将他们融合在一起：
  
  这里的$\alpha$可以看成是每个词的权重，计算方式是：
  
  其中，$i_{b,j}^c$由$c_{b,e}^w$去控制权重：
  

• 递归神经网络。把句子当作树状结构而非序列进行处理，从理论上而言具有更强的表示能力，但其存在样本标注难度大（需标注语法解析树）、深层易梯度消失、难以并行计算等弱点，因此在实际应用中使用较少。
  

• Transformer：是近年来使用广泛的网络，transformer在长距离文本依赖上相较RNN有更好的效果。

但是将transformer直接应用于NER任务时，可能效果不那么理想，原因可能是对于NER而言，它需要的是：（1）局部依赖的捕捉；（2）位置信息；（3）更 sharp 的attention 分布（NER不需要太多的全局信息）。有论文表明，这些问题解决后，呈现出比CNN+BiLSTM+CRF更好的效果。

有关transformer的更多内容，会在后续的博客中更新。

• 语言模型：大规模预训练语言模型近年来在各种NLP任务中取得巨大成功，如GPT（Generative Pre-trained Transformer）、ELMo、BERT等。这些预训练语言模型不但有效地捕捉了文本中的上下文关系，且不需要如Word2Vec、GloVe等传统词向量进行分布式表示。

有关语言模型的更多内容，会在后续的博客中更新。这里就不详细展开了

解码器

标注解码器是NER模型的最后一部分，其将经过上下文编码器得到的表征作为输入，常用的解码器组合有：MLP+Softmax，CRF，RNN，Pointer Networks等。

一般来说，对于嵌套NER的处理一般都是在解码器部分实现的。对于flat NER 而言，我们的目标可以看成是单标签的分类问题（即对于每个word选择一个标签）；但是对于嵌套NER而言，我们的目标应该是多标签的分类问题（即对于每个word可能有多个标签，比如说「《叶圣陶散文选集》」中的「叶」标签为B-人物，B-作品）。所以在本节中，还会简单描述一下嵌套类NER的解码器。

先说MLP+softmax和CRF

CRF有一系列特征函数，相当于增加了一系列约束条件。比如说：E 后面跟 B的可能性比E后面跟I的可能性（这个几乎不可能）要大得多。但是softmax就不存在这样的约束，这样的话就相当于这一部分需要在放在前面的模型去学习。这也就是为什么CRF解码器如此常见的原因。

但是，为什么Bert+CRF相对于Bert+softmax性能没什么提升呢？甚至有的时候会带来一些负面影响？

可以参考 你的 CRF 层的学习率可能不够大 这篇文章。

简单来说就是，BERT 的拟合能力太强了，导致不需要转移矩阵效果都很好。而不好的转移矩阵会给结果带来负面的影响。

softmax 延伸至多标签解码

对应softmax，一个简单的想法就是，对sentence中的每个字进行N（标签数目）次二分类。但是，我们知道每个字属于的标签数目的最大值（K）远小于N，这会造成严重的类别不均衡问题。可以采用一些平衡策略，比如focal loss、调整负样本的权重等。

苏神在将“softmax+交叉熵”推广到多标签分类问题里面介绍了一种将softmax推广到多标签分类问题的loss。如果是多标签解码的话，可以将MLP+softmax改为这个loss试试。下面对其进行简要介绍：

首先，我们将softmax进行如下变换：

这里的logsumexp是max的光滑近似，所以我们有：

所以这个loss可以看成，所有的非目标类得分的最大值都要尽可能的小于目标类得分。因此，对于多分类的场景，我们也可以让所有非目标类的得分都要小于目标类的得分，于是有：

对于k不固定的多标签分类（NER任务的k多为不固定的），此时引入一个额外的0类，使得所有的非目标类的得分小于0类，目标类的得分大于0类，我们有：

其loss代码为：

def multilabel_categorical_crossentropy(y_true, y_pred):
    """多标签分类的交叉熵
    说明：y_true和y_pred的shape一致，y_true的元素非0即1，
         1表示对应的类为目标类，0表示对应的类为非目标类。
    警告：请保证y_pred的值域是全体实数，换言之一般情况下y_pred
         不用加激活函数，尤其是不能加sigmoid或者softmax！预测
         阶段则输出y_pred大于0的类。如有疑问，请仔细阅读并理解
         本文。
    """
    y_pred = (1 - 2 * y_true) * y_pred
    y_pred_neg = y_pred - y_true * 1e12
    y_pred_pos = y_pred - (1 - y_true) * 1e12
    zeros = K.zeros_like(y_pred[..., :1])
    y_pred_neg = K.concatenate([y_pred_neg, zeros], axis=-1)
    y_pred_pos = K.concatenate([y_pred_pos, zeros], axis=-1)
    neg_loss = K.logsumexp(y_pred_neg, axis=-1)
    pos_loss = K.logsumexp(y_pred_pos, axis=-1)
    return neg_loss + pos_loss

RNN

Pointer Networks

使用指针网络解码，是将NER任务当作先识别“块”即实体范围，然后再对其进行分类。指针网络通常是在Seq2seq框架中

关于编码与解码的更多内容在下一篇文章中介绍。

---

实践

Bert + Softmax

class BertSoftmax(BertPreTrainedModel): # 大部分与transformer 提供的BertForTokenClassification相同，这里只是改了点loss
  # config 来自bertconfig,其实本质是一个分类问题。即每个token属于什么类别
  def __init__(self,config):
    super(BertSoftmax, self).__init__(config)
    self.num_labels = config.num_labels
    self.bert = BertModel(config)
    self.dropout = nn.Dropout(config.hidden_dropout_prob)
    self.classifier=nn.Linear(config.hidden_size,config.num_labels)
    self.loss_type=config.loss_type
    self.init_weights()

  def forward(self, input_ids, attention_mask=None, token_type_ids=None, labels=None):
    # last hidden state,pooler output, past_key_values, hidden_states,attentions,cross_attentions
    outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids)
    sequence_output = outputs[0]
    sequence_output = self.dropout(sequence_output)
    logits = self.classifier(sequence_output)
    outputs = (logits,) + outputs[2:]  # add hidden states and attention if they are here
    if labels is not None:
      loss_fct = CrossEntropyLoss(ignore_index=0)
      if attention_mask is not None:
        active_loss = attention_mask.view(-1) == 1
        active_logits = logits.contiguous().view(-1, self.num_labels)[active_loss]
        active_labels = labels.contiguous().view(-1)[active_loss]
        loss = loss_fct(active_logits, active_labels)
      else:
        loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
      outputs = (loss,) + outputs
      return outputs  # (loss), scores, (hidden_states), (attentions)

Bert + CRF

CRF: 这里展示的代码没展示解码（也就是维特比算法）：

# CRF class
class CRF(nn.Module):
  """
  发射矩阵（来自于bert层），其shape为(seq_length,batch_size,num_tags)，如果batch_first=true,那么应该是(batch_size,seq_length,num_tags)
  转移矩阵：shape是(num_tags,num_tags)
  训练： 主要是计算max的正确路径/总路径的大小
  预测： 维特比算法
  """
  def __init__(self,num_tags,batch_first=False):
    super().__init__()
    self.num_tags=num_tags
    self.batch_first=batch_first
    # 转移矩阵
    self.transitions=nn.Parameter(torch.empty(num_tags, num_tags))
    # 初始化
    self.init_parameter()

  def init_parameter(self):
    nn.init.uniform_(self.transitions, -0.1, 0.1)

  def forward(self, emissions,tags,mask):
    """
    batch_first表征batch是不是在头部
    emissions: 从bert层传过来的发射矩阵。
    tags: seq labels, shape:(seq_length, batch_size)
    mask: mask tensor, shape:(seq_length,batch_size)
    返回值： log likelihood, shape: (batch_size,)
    """
    # 处理mask的格式
    if mask is None:
      # 如果mask是None,那么所有的分数都是有效的
      mask = torch.ones_like(tags, dtype=torch.uint8, device=tags.device)
    if mask.dtype != torch.uint8:
      mask = mask.byte()
    # 处理batch first
    if self.batch_first:
      emissions = emissions.transpose(0, 1)
      tags = tags.transpose(0, 1)
      mask = mask.transpose(0, 1)
    
    # 计算正确的label的分数
    # shape: (batch_size,)
    numerator = self._compute_score(emissions, tags, mask)
    # 计算归一化因子
    denominator = self._compute_normalizer(emissions, mask)
    # shape: (batch_size,)
    llh = numerator - denominator
    return llh.sum() / mask.float().sum()


  def _compute_score(self,emissions,tags,mask):
    # 需要计算point label 和 trans_label
    seq_length, batch_size = tags.shape
    mask = mask.float()

    score = torch.zeros(batch_size)
    # shape:(batch_size,)
    # 第一步，加的是所有batch的seq第0个位置的point score
    # tags[0]:(batch_size,)
    # emissions (seq_len,batch_size,num_tags)
    score += emissions[0, torch.arange(batch_size),tags[0]]

    # 开始计算转移分数 与 余下的point分数
    for i in range(1,seq_length):
      # 如果这个分数是有效的，则加入（mask=1）
      score += emissions[0, torch.arange(batch_size),tags[i]] * mask[i]
      # 开始计算转移分数
      score += self.transitions[tags[i - 1], tags[i]] * mask[i]
    
    return score
  
  def _compute_normalizer(self,emissions,mask):
    # 计算归一化因子，逐标签得分 + 转移概率得分（考虑的是全状态）
    # return：归一化分数，shape:(batch_size,)
    # emissions (seq_len,batch_size,num_tags)
    seq_length = emissions.size(0)
    # 考虑某一个batch，每一个num_tags可以作为一个hidden state(考虑rnn的图，所以一开始应该是 batch_size, num_tags)
    score = emissions[0]  # shape:(batch_size,num_tags) 这个是在位置0每个num_tags的标签得分
    for i in range(1,seq_length):
      # shape : (batch_size, num_tags, 1)
      # 之前的state h_t
      broadcast_score = score.unsqueeze(2)
      # shape: (batch_size, 1, num_tags)
      # x_t+1
      broadcast_emissions = emissions[i].unsqueeze(1)
      # h_t+1 = f(h_t,x_t+1),  h_t+1=h_t*x_t+1*g
      next_score = broadcast_score + self.transitions + broadcast_emissions
      # (batch_size,num_tags,num_tags)
      next_score = torch.logsumexp(next_score, dim=1)
      # Set score to the next score if this timestep is valid (mask == 1)
      # (seq_length,1, batch_size)
      score = torch.where(mask[i].unsqueeze(1), next_score, score)
    # (batch_size,)
    return torch.logsumexp(score, dim=1)

Bert+CRF:

class BertCRF(BertPreTrainedModel):
  def __init__(self,config):
    super(BertCRF, self).__init__(config)
    self.bert=BertModel(config)
    self.dropout=nn.Dropout(config.hidden_dropout_prob)
    # 这是crf的发射概率
    self.classifier=nn.Linear(config.hidden_size,config.num_labels)
    self.crf = CRF(num_tags=config.num_labels, batch_first=True)
    self.init_weights()
  
  def forward(self, input_ids, token_type_ids=None, attention_mask=None,labels=None):
    # last hidden state,pooler output, past_key_values, hidden_states,attentions,cross_attentions
    outputs =self.bert(input_ids = input_ids,attention_mask=attention_mask,token_type_ids=token_type_ids)
    sequence_output = outputs[0]
    sequence_output = self.dropout(sequence_output)
    logits = self.classifier(sequence_output)
    outputs = (logits,)
    if labels is not None:
        loss = self.crf(emissions = logits, tags=labels, mask=attention_mask)
        outputs =(-1*loss,)+outputs
    return outputs # (loss), scores

参考

A Survey on Deep Learning for Named Entity Recognition
最通俗易懂的BILSTM-CRF的CRF层介绍
简明条件随机场CRF介绍 | 附带纯Keras实现
keras实现源码
BERT标注为何不使用CRF
NER综述
命名实体识别NER
NER论文大礼包
nlp中的实体关系抽取方法总结
将“softmax+交叉熵”推广到多标签分类问题
GlobalPointer：用统一的方式处理嵌套和非嵌套NER