讯飞2020年事件提取比赛第一名-触发词提取

2022-07-29

引言

讯飞之前发布了一个事件抽取挑战赛，这个比赛分成两个任务：

1、任务一：事件触发词及论元抽取
2、任务二：事件属性抽取

搜了下github，发现第一名的解决方案。

看readme介绍主要思路，作者将任务分割为触发词抽取，论元抽取，属性抽取。

那本篇即讲述触发词(trigger提取器)的实现方式。

1. 跑通代码

修改train.py，增加下面这些：

args = TrainArgs().get_parser()
args.gpu_ids = '0'
args.mode = "train"
args.raw_data_dir = './data/final/raw_data'
args.mid_data_dir = './data/final/mid_data'
args.aux_data_dir = "./data/final/preliminary_clean"
args.bert_dir = '/home/yuzhang/PycharmProjects/xf_event_extraction2020Top1/bert/torch_roberta_wwm'
args.output_dir = './out'
args.bert_type = 'roberta_wwm'
args.task_type = 'trigger'
args.max_seq_len = 320
args.train_epochs = 6
args.train_batch_size = 16
args.lr = 2e-5
args.other_lr = 2e-4
args.attack_train = "pgd"
args.swa_start = 4
args.eval_model = True
args.enhance_data = True
args.use_trigger_distance = True

2. 模型结构

3. 数据处理

主要代码看这里。

将raw_text分成token，空格之类的作者换成了[BLANK]，没有tokenize的换成了[INV]。虽然他这种做法我勉强能接受，但是还是理解不了。。。因为tokenizer该做的都做了，做这一步不就多此一举么。。。（除非有其他理由）
核心的地方在于label的构造方式。举个例子：


raw_text = "学校公布成绩。"
trigger_word = "公布"
tokens = ['学', '校', '公', '布', '成', '绩', '。']
labels = [
    [0, 0], 
    [0, 0], 
    [1, 0], 
    [0, 1], 
    [0, 0], 
    [0, 0], 
    [0, 0]
]

看到有意思的地方了么，以char level进行分割raw_text，然后找到公布对应的start_index和end_index置为1。

4.模型结构

TriggerExtractor(
  (bert_module): BertModel()
  (dropout_layer): Dropout(p=0.1, inplace=False)
  (mid_linear): Sequential(
    (0): Linear(in_features=768, out_features=128, bias=True)
    (1): ReLU()
    (2): Dropout(p=0.1, inplace=False)
  )
  (classifier): Linear(in_features=128, out_features=2, bias=True)
  (activation): Sigmoid()
  (criterion): BCELoss()
)

5. 训练

输入input_ids, attention_mask, token_type_ids获取bert output，然后mid_linear，最后classifier，shape变成比如32,128,2，核心地方在计算了loss和解码部分。

举个例子计算loss：

# -*- coding: utf8 -*-
#
# -*- coding: utf8 -*-
#
import torch
from torch import nn

# shape = (3,5,2)
target = torch.tensor([
    [
        [0, 0],
        [0, 0],
        [1, 0],
        [0, 1],
        [0, 0],
    ],
    [
        [0, 0],
        [0, 0],
        [1, 0],
        [0, 1],
        [0, 0],
    ],
    [
        [0, 0],
        [0, 0],
        [1, 0],
        [0, 1],
        [0, 0],
    ],
], dtype=torch.float32)
pred = torch.randn(target.shape)

pred = nn.Sigmoid()(pred)

loss = nn.BCELoss()
print(loss(pred, target))

6. 解码

代码。

7. 总结

1. 作者为什么没有使用bert+crf？

1	缺点：存在5%的句子会出现解码为空的现象，导致误差传播极大；

这个在作者的ppt里面提到了。

2. 优点

作者舍弃CRF结构，采用指针式解码的方案。这个地方是我觉得最有意思的地方。

我为什么任务这个地方是优点呢，初看网络结构，我以为的网络结构类似下面这样：

                bert
--------|-------------------|----
        |                   |  
 start_index_layer  end_index_layer
        |                   |
        ----------|-----------
                  |
                解  码

也就是说bert后面有两个linear，一个是start_index的，一个是end_index的，然后分别预测开始和结束index。

但是这么做有几个坏处：
1、start_index和end_index没有任何交互
2、解码的时候，会解码出很多的结果

那作者的优势就很明显了，start_index和end_index用一个linear表示。

但是即使这样，都绕不开一个地方，就是解码出多个结果和长度的问题。

3. 缺点

解码的长度是不确定的，只要start_logits > 0.5,end_logits>0.5，就认为是合理的。那么这两者之间组合，就会有许多的结果。这个是绕不开的。

作者这里做了一个限制，看代码：

candidate_entities = []

start_ids = np.argwhere(logits[:, 0] > start_threshold)[:, 0]
end_ids = np.argwhere(logits[:, 1] > end_threshold)[:, 0]

# 选最短的
for _start in start_ids:
    for _end in end_ids:
        # 限定 trigger 长度不能超过 3
        if _end >= _start and _end - _start <= 2:
            # (start, end, start_logits + end_logits)
            candidate_entities.append((raw_text[_start: _end + 1], _start, logits[_start][0] + logits[_end][1]))
            break

即限制了触发词的长度。

第二，在这个比赛里，绝大多数的样本的触发词就为1个。

如果解码为空的话，作者采用start_logits和end_logits最大的作为输出。代码。

8. 思考

本质来讲，我没太看得出来和crf相对比的优劣。作者也没有公开每个任务分别的score。
但是从模型结构上来讲，这种方式有个好处，就是可以解决嵌套的问题。第二就是速度的好处。

备注

1. 忽略的点

1、没有考虑数据增强
2、没有use_distant_trigger，即将构造的trigger输入ebedding作为extra feature(即将句子中所有可能的触发词都列出来然后输入到embeddings和bert output concat到一起)。

2. 使用roberta-www-ext

1 2	tokenizer = BertTokenizer.from_pretrained(bert_dir) bert = BertModel.from_pretrained(bert_dir)