最近在磕一人之力，刷爆三路榜单！信息抽取竞赛夺冠经验分享这篇文章，文章对关系抽取任务的解码方式做了简单的概述，在之前的文章中本人已经实现了指针标注网络，并对其进了优化（详情见改良后的层叠式指针网络，让我的模型F1提升近4%)，因此这次把文中提到的多头选择和Biaffine关系矩阵构建的原论文拿出来研究了一下，并根据实际的关系抽取任务做了复现和改良。
本文主要涉及以下论文：
多头选择与关系抽取：
Joint entity recognition and relation extraction as a multi-head selection problem
Bert版多头选择：
BERT-Based Multi-Head Selection for Joint Entity-Relation Extraction
双仿射注意力机制：
Deep Biaffine Attention for Neural Dependency Parsing（基于深层双仿射注意力的神经网络依存解析）
新论文，采取Biaffine机制构造Span矩阵：
Named Entity Recognition as Dependency Parsing
本文只是记录自己的思考和实现，只对每篇论文核心部分做简单理解，可能有错误，感兴趣的同学建议直接看原文。
该网络结构将实体识别和关系抽取 joint 在一起，先通过在隐藏层上连接CRF，来抽取实体标签，并将实体标签信息embedding后与隐藏层一起传递给sigmoid_layer，来与其他实体特征进行交互抽取关系。
实体抽取部分比较好理解，对于多头选择部分，以下原文的几条核心公式：
理解如下：
当Token(j)为Subject的End 且 Token(i)为Object的End的概率分数为
非常简明的意思是：将Token(j)和Token(i)的Z(隐藏层➕label embedding)分别经过U,W线性变换后相加再加上偏置b，最后再进行一次整体线性变换V，得到的值经过sigmoid函数后即转换为对应的概率分数。
别急！后文会讨论多类别关系时，各个矩阵的维度关系。
Bert + Multi-head Selection，除了引入了Bert作为编码层外，其他创新点如下：
以三元关系抽取任务为例，我们多头选择该如何更好的理解和应用？功夫不负有心人我找大了夕大姐文章里一张图虽然和多头选择没多少关系，但能比较形象的展示Multi-head Selection的流程：
对于一个句子中的所有的token形成的SO组合，一共有N2种。假设我们的Token都已经经过了线性变化或者全连接层的洗礼，如图中对于每一个City，我们将其作为S，我们应该考虑其他所有token是否能和它形成SO关系，所以我们要计算每一个token和city经过V变换后的分数。
具体实现上也非常简单，我们可以构建一个NNHidden_size的token组合矩阵，经过一个P_num（关系类别总数）的Dense层后即可得到各个token之间在各个关系上的分值。
Subject = tf.keras.layers.Dense(hidden_size)(Encode)
Object = tf.keras.layers.Dense(hidden_size)(Encode)
'''
将原token的encode经过两个不同的全连接层后，得到Subject，Object两个token序列
对应公式中的 U*zj 和 W*zi
'''
Subject = tf.expand_dims(Subject,1)
#TensorShape([batch_size, 1, MAX_LEN, hidden_size])
Object = tf.expand_dims(Object,2)
#TensorShape([batch_size, MAX_LEN, 1, hidden_size])
Subject = tf.tile(Subject,multiples=(1,MAX_LEN,1,1))
#TensorShape([batch_size, MAX_LEN, MAX_LEN, hidden_size])
Object = tf.tile(Object,multiples=(1,1,MAX_LEN,1))
#TensorShape([batch_size, MAX_LEN, MAX_LEN, hidden_size])
concat_SO = tf.keras.layers.Concatenate(axis=-1)([Subject,Object])
#TensorShape([batch_size, MAX_LEN, MAX_LEN, 2*hidden_size])
output_logist = tf.keras.layers.Dense(P_num,activation='sigmoid')(concat_SO)
#TensorShape([batch_size, MAX_LEN, MAX_LEN, P_num])
'''
将组合后的 U*zj 与 W*zi 经过一个V全连接层，V.shape = (2*hidden_size,P_num)
对应公式中的 V*U*zj + V*W*zi = V(U*zj + W*zj + b)
'''
样本构建部分： 我们需要将一个标注好的[ MAX_LEN, MAX_LEN, P_num ]的矩阵作为Multi-Head Selection 结果的 Y值。
关于样本标注问题：
一个实体包含多个字符且可能存在实体嵌套的问题，如“我是歌手的主演是阿瓜”，需要抽取的关系为“我是歌手的主演是阿瓜”、“阿瓜是歌手”。
我们并不需要将“我是歌手”的四个token和“阿瓜”的两个token在P=主演的得分上全都标注为1，因为在实体抽取部分我们对实体的头和尾进行了识别，我们仅需要将 S“手”和O“瓜”所对应的P=主演的分值标注为1即可。本例中即 [3,9,indenx of 主演] = 1即可。如果阿瓜还是个歌手，则 [9,3,indenx of 职业] = 1即可，因为对于不同类型的嵌套的实体，可能存在尾字符相同的情况极少，因此我们标注尾字符而不是首字符。
以上就是Multi-head Selection Model部分的核心思路和代码。
完整模型代码如下：
def build_model(pretrained_path,config,MAX_LEN,Cs_num,cs_em_size,R_num):
ids = tf.keras.layers.Input((MAX_LEN,), dtype=tf.int32)
att = tf.keras.layers.Input((MAX_LEN,), dtype=tf.int32)
cs = tf.keras.layers.Input((MAX_LEN,), dtype=tf.int32)
config.output_hidden_states = True
bert_model = TFBertModel.from_pretrained(pretrained_path,config=config,from_pt=True)
x, _, hidden_states = bert_model(ids,attention_mask=att)
layer_1 = hidden_states[-1]
start_logits = tf.keras.layers.Dense(Cs_num,activation = 'sigmoid')(layer_1)
start_logits = tf.keras.layers.Lambda(lambda x: x**2,name='s_start')(start_logits)
end_logits = tf.keras.layers.Dense(Cs_num,activation = 'sigmoid')(layer_1)
end_logits = tf.keras.layers.Lambda(lambda x: x**2,name='s_end')(end_logits)
cs_emb = tf.keras.layers.Embedding(Cs_num,cs_em_size)(cs)
concat_cs = tf.keras.layers.Concatenate(axis=-1)([layer_1,cs_emb])
f1 = tf.keras.layers.Dense(128)(concat_cs)
f2 = tf.keras.layers.Dense(128)(concat_cs)
f1 = tf.expand_dims(f1,1)
f2 = tf.expand_dims(f2,2)
f1 = tf.tile(f1,multiples=(1,MAX_LEN,1,1))
f2 = tf.tile(f2,multiples=(1,1,MAX_LEN,1))
concat_f = tf.keras.layers.Concatenate(axis=-1)([f1,f2])
output_logist = tf.keras.layers.Dense(128,activation='relu')(concat_f)
output_logist = tf.keras.layers.Dense(R_num,activation='sigmoid')(output_logist)
output_logist = tf.keras.layers.Lambda(lambda x: x**4,name='relation')(output_logist)
model = tf.keras.models.Model(inputs=[ids,att,cs], outputs=[start_logits,end_logits,output_logist])
model_2 = tf.keras.models.Model(inputs=[ids,att], outputs=[start_logits,end_logits])
model_3 = tf.keras.models.Model(inputs=[ids,att,cs], outputs=[output_logist])
return model,model_2,model_3
模型示意图之丑陋手稿：看个乐哈～：
模型效果：
没有做其他任何的处理，在2019百度三元抽取数据集上F1就达到了 79.157，而且模型结构相比于层叠序列标注简单了许多，理解起来也更加到胃～
这篇文章主要通过Biaffine来应用于依存关系分析上，但这也正好和关系抽取共通，只是依存关系中的关系类别只有一种，而在关系抽取中存在多种关系分类。
文章使用了双仿射注意力机制，而不是使用传统基于MLP注意力机制的单仿射分类器，或双线性分类器；上文提到的Multi-Head Selection正是由多个线性分类器构成的关系分类器。而现在我们希望能通过构建一个Biaffine Attention矩阵直接计算各个token之间在某个关系分类上的attention。
（这里直接将关系依存中的head 和 dep 称为 关系抽取中的S和O
Biaffine实现代码：
class Biaffine(tf.keras.layers.Layer):
def __init__(self, in_size, out_size, bias_x=False, bias_y=False):
super(Biaffine, self).__init__()
self.bias_x = bias_x
self.bias_y = bias_y
self.U = self.add_weight(
name='weight1', shape=(in_size + int(bias_x),
out_size, in_size + int(bias_y)),trainable=True)
#U.shape = [in_size,out_size,in_size]
def call(self, input1, input2):
if self.bias_x:
input1 = tf.concat((input1, tf.ones_like(input1[..., :1])), axis=-1)
if self.bias_y:
input2 = tf.concat((input2, tf.ones_like(input2[..., :1])), axis=-1)
# bxi,oij,byj->boxy
logits_1 = tf.einsum('bxi,ioj,byj->bxyo', input1, self.U, input2)
return logits_1
完整模型代码：
def build_model(pretrained_path,config,MAX_LEN,Cs_num,cs_em_size,R_num):
ids = tf.keras.layers.Input((MAX_LEN,), dtype=tf.int32)
att = tf.keras.layers.Input((MAX_LEN,), dtype=tf.int32)
cs = tf.keras.layers.Input((MAX_LEN,), dtype=tf.int32)
config.output_hidden_states = True
bert_model = TFBertModel.from_pretrained(pretrained_path,config=config,from_pt=True)
x, _, hidden_states = bert_model(ids,attention_mask=att)
layer_1 = hidden_states[-1]
start_logits = tf.keras.layers.Dense(Cs_num,activation = 'sigmoid')(layer_1)
start_logits = tf.keras.layers.Lambda(lambda x: x**2,name='s_start')(start_logits)
end_logits = tf.keras.layers.Dense(Cs_num,activation = 'sigmoid')(layer_1)
end_logits = tf.keras.layers.Lambda(lambda x: x**2,name='s_end')(end_logits)
cs_emb = tf.keras.layers.Embedding(Cs_num,cs_em_size)(cs)
concat_cs = tf.keras.layers.Concatenate(axis=-1)([layer_1,cs_emb])
f1 = tf.keras.layers.Dense(128,activation='relu')(concat_cs)
f2 = tf.keras.layers.Dense(128,activation='relu')(concat_cs)
Biaffine_layer = Biaffine(128,R_num,bias_y=True)
output_logist = Biaffine_layer(f1,f2)
output_logist = tf.keras.layers.Activation('sigmoid')(output_logist)
output_logist = tf.keras.layers.Lambda(lambda x: x**4,name='relation')(output_logist)
model = tf.keras.models.Model(inputs=[ids,att,cs], outputs=[start_logits,end_logits,output_logist])
model_2 = tf.keras.models.Model(inputs=[ids,att], outputs=[start_logits,end_logits])
model_3 = tf.keras.models.Model(inputs=[ids,att,cs], outputs=[output_logist])
return model,model_2,model_3
模型效果：
F1 = 0.7964 相比Multi-head Selection F1提高了0.05左右
class Biaffine_2(tf.keras.layers.Layer):
def __init__(self, in_size, out_size,MAX_LEN):
super(Biaffine_2, self).__init__()
self.w1 = self.add_weight(
name='weight1',
shape=(in_size, out_size, in_size),trainable=True)
self.w2 = self.add_weight(
name='weight2',
shape=(2*in_size + 1, out_size),trainable=True)
self.MAX_LEN = MAX_LEN
def call(self, input1, input2):
f1 = tf.expand_dims(input1,2)
f2 = tf.expand_dims(input2,1)
f1 = tf.tile(f1,multiples=(1,1,self.MAX_LEN,1))
f2 = tf.tile(f2,multiples=(1,self.MAX_LEN,1,1))
concat_f1f2 = tf.concat((f1,f2),axis=-1)
concat_f1f2 = tf.concat((concat_f1f2,tf.ones_like(concat_f1f2[..., :1])), axis=-1)
logits_1 = tf.einsum('bxi,ioj,byj->bxyo', input1, self.w1, input2)
logits_2 = tf.einsum('bijy,yo->bijo',concat_f1f2,self.w2)
return logits_1+logits_2
目前尝试中能拿到最好效果的模型方案（持续更新中）：
def build_model_3(pretrained_path,config,MAX_LEN,Cs_num,cs_em_size,R_num):
ids = tf.keras.layers.Input((MAX_LEN,), dtype=tf.int32)
att = tf.keras.layers.Input((MAX_LEN,), dtype=tf.int32)
cs = tf.keras.layers.Input((MAX_LEN,), dtype=tf.int32)
config.output_hidden_states = True
bert_model = TFBertModel.from_pretrained(pretrained_path,config=config,from_pt=True)
x, _, hidden_states = bert_model(ids,attention_mask=att)
layer_1 = hidden_states[-1]
layer_2 = hidden_states[-2]
start_logits = tf.keras.layers.Dense(256,activation = 'relu')(layer_1)
start_logits = tf.keras.layers.Dense(Cs_num,activation = 'sigmoid')(start_logits)
start_logits = tf.keras.layers.Lambda(lambda x: x**2,name='s_start')(start_logits)
end_logits = tf.keras.layers.Dense(256,activation = 'relu')(layer_1)
end_logits = tf.keras.layers.Dense(Cs_num,activation = 'sigmoid')(end_logits)
end_logits = tf.keras.layers.Lambda(lambda x: x**2,name='s_end')(end_logits)
cs_emb = tf.keras.layers.Embedding(Cs_num,cs_em_size)(cs)
concat_cs = tf.keras.layers.Concatenate(axis=-1)([layer_1,layer_2])
f1 = tf.keras.layers.Dropout(0.2)(concat_cs)
f1 = tf.keras.layers.Dense(256,activation='relu')(f1)
f1 = tf.keras.layers.Dense(128,activation='relu')(f1)
f1 = tf.keras.layers.Concatenate(axis=-1)([f1,cs_emb])
f2 = tf.keras.layers.Dropout(0.2)(concat_cs)
f2 = tf.keras.layers.Dense(256,activation='relu')(f2)
f2 = tf.keras.layers.Dense(128,activation='relu')(f2)
f2 = tf.keras.layers.Concatenate(axis=-1)([f2,cs_emb])
Biaffine_layer = Biaffine_2(128+cs_em_size,R_num,MAX_LEN)
output_logist = Biaffine_layer(f1,f2)
output_logist = tf.keras.layers.Activation('sigmoid')(output_logist)
output_logist = tf.keras.layers.Lambda(lambda x: x**4,name='relation')(output_logist)
model = tf.keras.models.Model(inputs=[ids,att,cs], outputs=[start_logits,end_logits,output_logist])
model_2 = tf.keras.models.Model(inputs=[ids,att], outputs=[start_logits,end_logits])
model_3 = tf.keras.models.Model(inputs=[ids,att,cs], outputs=[output_logist])
return model,model_2,model_3
F1 = 0.7986 比baseline提高了 0.022
def build_model(pretrained_path,config,MAX_LEN,Cs_num,cs_em_size,R_num):
ids = tf.keras.layers.Input((MAX_LEN,), dtype=tf.int32)
att = tf.keras.layers.Input((MAX_LEN,), dtype=tf.int32)
cs = tf.keras.layers.Input((MAX_LEN,), dtype=tf.int32)
config.output_hidden_states = True
bert_model = TFBertModel.from_pretrained(pretrained_path,config=config,from_pt=True)
x, pooling, hidden_states = bert_model(ids,attention_mask=att)
layer_1 = hidden_states[-1]
layer_2 = hidden_states[-2]
concat_cs = tf.keras.layers.Concatenate(axis=-1)([layer_1,layer_2])
start_logits = tf.keras.layers.Dense(128,activation = 'relu')(concat_cs)
end_logits = tf.keras.layers.Dense(128,activation = 'relu')(concat_cs)
S_Biaffine_layer = Biaffine_2(128,Cs_num,MAX_LEN)
S_logits = S_Biaffine_layer(start_logits,end_logits)
S_output_logist = tf.keras.layers.Activation('softmax',name='s_token')(S_logits)
S_logits = tf.keras.layers.Dense(256,activation = 'relu')(concat_cs)
S_logits = tf.keras.layers.Dropout(0.2)(S_logits)
S_logits = tf.keras.layers.Dense(128,activation = 'relu')(S_logits)
O_logits = tf.keras.layers.Dense(256,activation = 'relu')(concat_cs)
O_logits = tf.keras.layers.Dropout(0.2)(O_logits)
O_logits = tf.keras.layers.Dense(128,activation = 'relu')(O_logits)
cs_emb = tf.keras.layers.Embedding(Cs_num,cs_em_size)(cs)
f1 = tf.keras.layers.Concatenate(axis=-1)([S_logits,cs_emb])
f2 = tf.keras.layers.Concatenate(axis=-1)([O_logits,cs_emb])
Biaffine_layer = Biaffine_2(128+cs_em_size,R_num,MAX_LEN)
output_logist = Biaffine_layer(f1,f2)
output_logist = tf.keras.layers.Activation('sigmoid')(output_logist)
output_logist = tf.keras.layers.Lambda(lambda x: x**4,name='relation')(output_logist)
model = tf.keras.models.Model(inputs=[ids,att,cs], outputs=[S_output_logist,output_logist])
model_2 = tf.keras.models.Model(inputs=[ids,att], outputs=[S_output_logist])
model_3 = tf.keras.models.Model(inputs=[ids,att,cs], outputs=[output_logist])
return model,model_2,model_3
F1值：0.8016
在关系抽取的任务中，baseline选择 Biaffine 会优于 基本的Multi-head，在这个基础上模型还有很多可以优化的地方。比如 如何更好的构造Biaffine矩阵，如何产生更有效的信息，但不至于过拟合。在我的实验过程中，Biaffine方法一直无法超越之前改良后的层叠式指针网络，这让我非常郁闷（主要是和别人实验结果不同），排除batch_size太小，模型收敛性较差的原因之外，根据模型的训练情况判断可能原因是在抽取实体时要求模型辨别实体的类别，导致该任务收敛性较差，试了多种网络较难拟合，也可能和数据集相关。使用上还存在一定的问题，会持续关注。
其实学术界已经对这种共享编码的效果提出了质疑，也有不少实验证明，实体抽取和关系抽取这两个任务在独立编码的情况下效果要好于共享编码。Two are Better than One: Joint Entity and Relation Extraction with Table-Sequence Encoders
本文并没有尝试用CRF来抽取实体，而是直接使用了指针标注的方法，只是收到了大部分实体抽取文章的影响（默认指针标注优于CRF）之后会对这两种方法进行对比。
关系抽取的系列文章可能要到此告一段落，之后看到这方面重要的论文也会第一时间和大家分享～