NLP-信息抽取-关系抽取-2017：LSTM-LSTM-bias实体识别-关系联合抽取【基于一种新的标注策略进行实体和关系的联合抽取】

Dear 丶 2023-10-02 09:06 12阅读 0赞

《原始论文：Joint Extraction of Entities and Relations Based on a Novel Tagging Scheme》

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]

## 一、概述 ##

### 1、关系抽取存在的问题 ###

传统方法以流水线的方式处理这个任务.

*  提取实体(Nadeau和Sekine, 2007),
 *  识别它们之间的关系(Rink, 2010)。

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]

优点：这个分离的框架使得任务易于处理， 并且每个组件可以更灵活。

缺点:但它忽略了这两个子任务之间的相关性， 每个子任务是一个独立的模型。实体识别的 结果可能会影响关系分类的性能并导致错误传播。

### 2、关系抽取现存两种方法 ###

#### 2.1 Pipelined method ####

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 2]

#### 2.2 Typical joint extraction method ####

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 3]

### 3、联合抽取相关研究 ###

#### 3.1 《End-to-End Relation Extraction using LSTMs on Sequences and Tree Structures，ACL 2016》 ####

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 4]

动机：在关系抽取中词序信息和树结构信息是可以互补的。

方法：提出了一种新颖的端到端模型，基于词序信息和依存树结构信息来抽取实体间的关系。该模型使用了双向的LSTM和tree-LSTM结构，同时抽取实体及其关系。 问题：预测实体时忽略了标签之间的长依赖关系，(Y.H.Suncong Zheng n.d.)利用LSTM解码器解决了标签的长依赖问题［；预测好实体后，两两配对后输入到关系分类模块中识别它们之间的关系，因为不存在关系的实体对也输入到关系分类模块中，造成信息冗余，增加了错误率，(SuncongZheng2017)提出了新颖的标注机制解决了信息冗余的问题

#### 3.2 \[《CoType: Joint Extraction of Typed Entities and Relations with Knowledge Bases. WWW 2017》\] ####

动机：目前的远程监控方法侧重于单独解决子任务，在处理联合提取任务时遇到以下限制

*  域限制：它们依赖于预先训练的命名实体识别器（或名词短语块）来检测实体提及。
 *  错误传播：在当前提取管道中，实体识别和键入步骤中生成的不正确的实体类型充当关系提取步骤中的功能。
 *  标签噪音：在远程监督中，上下文无关的映射从关系（实体）提到KB关 系 （实体）可能会带来误正型标签（即标签噪声）到自动标记的训练公司，结果不准确的模型

方法：基于特征工程的结构化系统，提出了一种新的远程监控框架COTYPE,在最小语言假设下提取领  
域特定语料库中的类型化实体和关系

问题：需要设计复杂的特征工程，严重依赖于NLP工具，这可能会导致错误传播问题

#### 3.3 \[《Joint entity and relation extraction based on a hybrid neural network. Neurocomputing 2017》\] ####

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 5]  
动机：(Makoto Miwa 2016)提出了基于神经网络的端到端实体和关系抽取模型。然而，当检测实体时，他们使用一个NN结构来预测实体标签，忽略了实体标签之间的长距离依赖关系。

方法：输入句子通过公用的Embedding层和BiLSTM层， 然后分别使用一个LSTM来进行NER和一个CNN来进行RC。

问题：并不是完全意义上的统一，还是要先NER,然后将预测的实体两两配对再进行RC,这样会产生信息冗余，可以与2017ACL有一篇基于标注策略的联合抽取进行对比。

本文对R(e」,e\_2)和对R(e\_2,e\_l)的分类有点模糊。

#### 3.4 Global Normalization of Convolutional Neural Networks for Joint Entity and Relation Classification.EMNLP2017 ####

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 6]

动机：pipeline方法忽略了两个子任务的相关性 方法：采用不同的CNN分别建模实体和关系表示，利用线性链CRF建模了输出的实体和关系之间的依赖性。

问题：训练集和测试集首先利用候选的实体对将句子拆成不同部分，然后输入到模型中。但事实上，对于测试集，我们是不知道候选的实体对的。

#### 3.5 Going out on a limb: Joint Extraction of Entity Mentions and Relations without Dependency Trees. ACL 2017 ####

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 7]  
动机：（Makoto Miwa 2016）提出的模型主要取决于对依赖 树的访问，将其限制为句子级别提取以及存在（良好）依赖解析器的语言［6］。而且，他们的模型不共同提取实体和关系;他们首先提取所有实体，然后对句子中的所有实体对进行关系分类。

方法：一边识别实体，一边抽取关系，具体来说是当前位置实体识别出来后，通过比较它与之前所有位置实体的相似 度 （attention机制），来识别出当前实体与其他实体的 关系。

#### 3.6 Adversarial training for multi-context joint entity and relation extraction. EMNLP 2018: ####

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 8]  
动机：（Christian Szegedy 2014）观察到对一些模型的输入的有意的小规模扰动（比如对抗样本）可能导致不正确的决定（具有高置信度）［2］。 （Ian Goodfellow 2015）提出了对抗训练（用于图像识别）作为正则化方法，混合原始样本和对抗样本来增强模型的鲁棒性⑸。虽然AT已经被用于NLP任 务 （比如，文本分类），但据作者所知，AT是第一次用于两个相关任务的联合学习中。

方法：在原始样本的Embedding中加入一个小的扰动值，得至I」 对抗样本，然后混合原始样本和对抗样本一起训练模型。

问题：该模型在进行关系分类时，只是简单地将两个单词的隐藏层表示相加得到表示这两个单词的关系向量，这种方法不能很好地表示两个单词的关系。

#### 3.7 Joint entity recognition and relation extraction as a multi head selection problem. Expert Syst. ####

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 9]

动机：以前研究并不是直接对整个句子建模。这意味着不考虑同一句子中其他实体对的关系-这可能有助于确定特定对的关系类型。 (ArzooKatiyar2017)直接对整个句子建模，但是无法处 理多关系问题方法：首先进行命名实体识别，然后对句中的每个单词都与句中的所有单词判断关系。

#### 3.8 Joint entity recognition and relation extraction as a multi head selection problem. Expert Syst. ####

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 10]

#### 3.9 Joint Extraction of Entities and Relations Based on a Novel Graph Scheme. IJCAI 2018 ####

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 11]

动机：大多数联合方法通过参数共享分开抽取实体及其关系，而不是共同decoding。这会导致输出的实体和关系的信息未能 完全利用，因为没有显示的特征来建模输出之间的依赖。 (F.W.Suncong Zheng 2017)是唯一的另外，设计了一个新颖的标注机制将联合抽取任务转换为序列标注问题。但是该方法仅间接捕获输出结构对应关系，并且无法解决关系重叠问题。

方法：作者通过设计一个有向图机制将联合抽取任务转换为一个有向图问题，使用基于转移的解析框架来解决。

问题：关系重叠可以分为两类：第一类是一个实体和多个实体之间存在关系；第二类是同一实体对存在多个关系。从作者介绍的方法看，只解决了第一类关系重叠问题。

### 4、本文idea提出原因 ###

1.  Piplined方法存在错误传播
2.  Typical join产生冗余信息

如何直接对实体和关系直接建模

### 5、研究成果 ###

新的标注方案

end-end mode  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 12]

### 6、本论文历史意义 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 13]

## 二、模型结构 ##

### 1、新的标注策略 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 14]

The special tags consist of three parts:

1.  Word position in the entity \{ B (begin), I (inside), E (end), S (single)\}
2.  Relation type information \{CF, CP, •••・ \}
3.  Relation role information \{1 (entity 1), 2 (entity 2)\}

### 2、端对端的标注模型 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 15]

模型结构：

1.  A Bi-LSTM Encoding Layer.
2.  A LSTM Decoding Layer.
3.  A Biased Objective Function.

### 3、相关方案 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 16]

通过在实体识别和关系抽取任务中共享 Embedding layer 和 Sequence layer参数的方法，加强两个任务之间的相关性，且设计了树结构的LSTM模型用于关系分类任务中

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 17]  
其将关系抽取任务当作一个multi head selection problem 的问题，从而使得每个实体能够与其他所有实体判断关系，此外，不再将关系抽取任务当作一个每个关系互斥的多分类任务，而是看作每个关系独立的多个二分类任务，从而能够判断每一对实体是否可能有多个关系存在  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 18]  
采用BiLSTM+CRF获取实体特征的神经网络模型，通过多层模块的特征共享重用实体特征，通过翻译机制获取复杂关系特征；区分实体是否涉及所需关系的一种三部分标记方案；

一种基于边际的关系排序器，用负样本训练，用于发现实体对之间的适当关系  
Jointly Extracting Multiple Triplets with Multilayer Translation Constraints

## 三、实验结果 ##

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 19]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 20]

## 四、实验分析 ##

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 21]  
1 . 单个的E可能在预测的时候不能构成合适的关系

2 . 有一些错误可能是由于关系预测错误导致的

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 22]  
bias损失函数a 参数调节在10左右最 优

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 23]  
LSTM-LSTM-Bias模型实体对关系识别跟好

## 五、实验总结 ##

### 1、关键点 ###

新的标注方案将联合抽取任务转化为序列抽取任务

提出新的模型

### 2、创新点 ###

Bias损失函数

LSTM的特殊结构

### 3、启发点 ###

思路转换

We propose a novel tagging scheme and an end-to end model with biased objective function to jointly extract entities and their relations…

## 六、论文代码 ##

### model.py ###

import math
    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    import torch.optim as optim
    
    
    class CustomLSTM1(nn.Module):
        def __init__(self, input_sz, hidden_sz):
            super().__init__()
            self.input_sz = input_sz
            self.hidden_size = hidden_sz
            self.W = nn.Parameter(torch.Tensor(input_sz, hidden_sz * 4))
            self.U = nn.Parameter(torch.Tensor(hidden_sz, hidden_sz * 4))
            self.weight_C1 = nn.Parameter(torch.Tensor(hidden_sz, 2 * hidden_sz))
            self.weight_C2 = nn.Parameter(torch.Tensor(hidden_sz, 1 * hidden_sz))
            self.bias = nn.Parameter(torch.Tensor(hidden_sz * 4))
            self.init_weights()
    
        def init_weights(self):
            stdv = 1.0 / math.sqrt(self.hidden_size)
            for weight in self.parameters():
                weight.data.uniform_(-stdv, stdv)
    
        def forward(self, x,
                    init_states=None):
            """Assumes x is of shape (batch, sequence, feature)"""
            bs, seq_sz, _ = x.size()
            hidden_seq = []
            if init_states is None:
                h_t, c_t = (torch.zeros(bs, self.hidden_size).to(x.device),
                            torch.zeros(bs, self.hidden_size).to(x.device))
            else:
                h_t, c_t = init_states
    
            HS = self.hidden_size
            for t in range(seq_sz):
                x_t = x[:, t, :]
                # batch the computations into a single matrix multiplication
                gates = x_t @ self.W + h_t @ self.U + self.bias
                cons = c_t @ self.weight_C1
                i_t, f_t, g_t = (
                    torch.sigmoid(gates[:, :HS] + cons[:, :HS]),  # input
                    torch.sigmoid(gates[:, HS:HS * 2] + cons[:, HS:HS * 2]),  # forget
                    torch.tanh(gates[:, HS * 2:HS * 3])
                )
                c_t = f_t * c_t + i_t * g_t
                cons2 = F.linear(c_t, self.weight_C2)
                o_t = torch.sigmoid(gates[:, HS * 3:] + cons2)  # output
                h_t = o_t * torch.tanh(c_t)
                hidden_seq.append(h_t.unsqueeze(0))
            hidden_seq = torch.cat(hidden_seq, dim=0)
            # reshape from shape (sequence, batch, feature) to (batch, sequence, feature)
            hidden_seq = hidden_seq.transpose(0, 1).contiguous()
            return hidden_seq, (h_t, c_t)
    
    
    class CustomLSTM2(nn.Module):
        def __init__(self, input_sz, hidden_sz):
            super().__init__()
            self.input_sz = input_sz
            self.hidden_size = hidden_sz
            self.W = nn.Parameter(torch.Tensor(input_sz, hidden_sz * 4))
            self.U = nn.Parameter(torch.Tensor(hidden_sz, hidden_sz * 4))
            self.weight_ch = nn.Parameter(torch.Tensor(hidden_sz, 1 * hidden_sz))
            self.weight_th = nn.Parameter(torch.Tensor(hidden_sz, 3 * hidden_sz))
            self.weight_to = nn.Parameter(torch.Tensor(hidden_sz, 1 * hidden_sz))
            self.bias = nn.Parameter(torch.Tensor(hidden_sz * 4))
            self.t_bias = nn.Parameter(torch.Tensor(hidden_sz))
            self.init_weights()
    
        def init_weights(self):
            stdv = 1.0 / math.sqrt(self.hidden_size)
            for weight in self.parameters():
                weight.data.uniform_(-stdv, stdv)
    
        def forward(self, x,
                    init_states=None):
            """Assumes x is of shape (batch, sequence, feature)"""
            bs, seq_sz, _ = x.size()
            hidden_seq = []
            if init_states is None:
                h_t, c_t, t_t = (torch.zeros(bs, self.hidden_size).to(x.device),
                                 torch.zeros(bs, self.hidden_size).to(x.device),
                                 torch.zeros(bs, self.hidden_size).to(x.device))
            else:
                h_t, c_t, t_t = init_states
            HS = self.hidden_size
            for t in range(seq_sz):
                x_t = x[:, t, :]
                # batch the computations into a single matrix multiplication
                gates = x_t @ self.W + h_t @ self.U + self.bias
                sum_t = t_t @ self.weight_th
                i_t, f_t, g_t = (
                    torch.sigmoid(gates[:, :HS] + sum_t[:, :HS]),  # input
                    torch.sigmoid(gates[:, HS:HS * 2] + sum_t[:, HS:HS * 2]),  # forget
                    torch.tanh(gates[:, HS * 2:HS * 3] + sum_t[:, 2 * HS:HS * 3])
                )
                c_t = f_t * c_t + i_t * g_t
                cons = F.linear(c_t, self.weight_ch)
                o_t = torch.sigmoid(gates[:, HS * 3:] + cons)  # output
                h_t = o_t * torch.tanh(c_t)
                t_t = F.linear(c_t, self.weight_ch) + self.t_bias
                hidden_seq.append(t_t.unsqueeze(0))
            hidden_seq = torch.cat(hidden_seq, dim=0)
            # reshape from shape (sequence, batch, feature) to (batch, sequence, feature)
            hidden_seq = hidden_seq.transpose(0, 1).contiguous()
            return hidden_seq, (h_t, c_t)
    
    
    class BidirLSTMLayer(nn.Module):
        def __init__(self, input_sz, hidden_sz):
            super().__init__()
            self.forward_net = CustomLSTM1(input_sz, int(hidden_sz / 2))
            self.back_net = CustomLSTM1(input_sz, int(hidden_sz / 2))
    
        def forward(self, x):
            forward_inputs = x
            forward_ht, _ = self.forward_net(forward_inputs)
            # 对输入进行翻转,假设x是(batch, sequence, feature)
            back_inputs = torch.flip(x, dims=(1,))
            back_ht, _ = self.back_net(back_inputs)
            # 将后向net输出反转进行拼接
            back_ht = torch.flip(back_ht, dims=(1,))
            out = torch.cat([forward_ht, back_ht], dim=2)
            return out
    
    
    class LSTM_bias(nn.Module):
        # word_vec word_size,300
        def __init__(self, word_vec, class_num=10, input_sz=300, blstm_hidden_size=300, decode_lstm_size=600, emb_dropout_value=0.5):
            super().__init__()
            # embeding层
            self.word_vec = word_vec
            self.word_embedding = nn.Embedding.from_pretrained(
                embeddings=self.word_vec,
                freeze=False,
            )
            self.emb_dropout = nn.Dropout(emb_dropout_value)
            # self.lstm_dropout = nn.Dropout(0.3)
            # self.decode_dropout = nn.Dropout(0.3)
            # BidirLSTMLayer
            self.blstm = BidirLSTMLayer(input_sz, blstm_hidden_size)
            # lstm decode
            self.decode_lstm = CustomLSTM2(blstm_hidden_size, decode_lstm_size)
            # softmax
            self.dense = nn.Linear(
                in_features=decode_lstm_size,
                out_features=class_num,
                bias=True
            )
    
        def forward(self, x):
            emb = self.word_embedding(x)  # B*L*word_dim
            emb = self.emb_dropout(emb)
            blstm_out = self.blstm(emb)
            # blstm_out = self.lstm_dropout(blstm_out)
            decode_out, _ = self.decode_lstm(blstm_out)
            # decode_out = self.decode_dropout(decode_out)
            logits = F.log_softmax(self.dense(decode_out), dim=2)
            return logits  # (batch,seq_len,class_num)
    
    
    class custom_loss(nn.Module):
        def __init__(self, alpha=10):
            super().__init__()
            self.alpha = alpha
    
        # 定义标签,为关系标签为1,pading为0,O为2
        def forward(self, scores, labels, lengths=None):
            loss = 0
            # 正样本损失
            for i in range(labels.shape[0]):
                for j in range(labels.shape[1]):
                    if (lengths[i] < j):
                        continue
                    if (labels[i][j] == 0):
                        logit = scores[i][j][1]
                        loss = self.alpha * logit + loss
                    else:
                        logit = scores[i][j][labels[i][j]]
                        loss = logit + loss
            return -loss / (labels.shape[0])
    
    
    class custom_loss2(nn.Module):
        def __init__(self, tag_set, alpha=10.0):
            super().__init__()
            self.alpha = alpha
            weight = [self.alpha] * len(tag_set)
            weight[tag_set["O"]] = 1
            self.weight = torch.tensor(weight)
            self.loss_fn = nn.NLLLoss(self.weight, size_average=False)
    
        # 定义标签,为关系标签为1,pading为0,O为2
        def forward(self, scores, labels, lengths=None):
            return self.loss_fn(scores, labels)
    
    
    if __name__ == '__main__':
        # model=BidirLSTMLayer(10,20)
        # print(model)
        # x=torch.rand(5,3,10)
        # print(model(x))
        # model2=CustomLSTM2(10,20)
        # print(model2)
        # print(model2(x))
        import numpy as np
    
        word_vec = torch.from_numpy(np.random.rand(1000, 300)).float()
        print(word_vec)
        model3 = LSTM_bias(word_vec)
        x = torch.randint(low=0, high=10, size=(30, 20)).long()
        print(model3(x).shape)
        criterion = custom_loss(10)
        optimizer = optim.Adam(model3.parameters(), lr=0.001, weight_decay=0.0001)
        # optimizer = optim.SGD(model3.parameters(), lr=0.01, momentum=0.9)
        print('traning model parameters:')
        for name, param in model3.named_parameters():
            if param.requires_grad:
                print('%s :  %s' % (name, str(param.data.shape)))
        labels = torch.randint(low=0, high=10, size=(30, 20))
        lengths = torch.randint(low=0, high=20, size=(30,))
        for i in range(100):
            optimizer.zero_grad()
            loss = criterion(model3(x), labels, lengths=lengths)
            loss.backward()
            optimizer.step()
            print("loss:", loss)
        model3.eval()
        print(labels[0, :])
        # print(model3(x)[0,:,:])
        print(model3(x)[0, :, :].argmax(dim=1))

### process.py ###

import json
    from utils import *
    from torch.utils.data.sampler import *
    from torch.nn.utils.rnn import *
    import bisect
    from torch.utils.data.dataset import *
    
    MAX_SENT_LENGTH = 70
    MAX_TOKEN_LENGTH = 20
    
    
    def search(pat, txt):  # 找到pat在txt子串的第一次出现位置
        i, N = 0, len(txt)
        j, M = 0, len(pat)
        while i < N and j < M:
            if txt[i] == pat[j]:
                j = j + 1
            else:
                i -= j
                j = 0
            i = i + 1
        if j == M:
            return i - M
        else:
            return -1
    
    
    def make_tag_set(tag_set, relation_label):
        if relation_label == "None":
            return
        for pos in "BIES":
            for role in "12":
                tag_set.add("-".join([pos, relation_label, role]))  # pos-relation_label-role
    
    
    def update_tag_seq(em_text, sentence_text, relation_label, role, tag_set, tags_idx):
        overlap = False
        start = search(em_text, sentence_text)
        tag = "-".join(["S", relation_label, str(role)])
        if len(em_text) == 1:
            if tags_idx[start] != tag_set["O"]:
                overlap = True
            tags_idx[start] = tag_set[tag]
        else:
            tag = "B" + tag[1:]
            if tags_idx[start] != tag_set["O"]:
                overlap = True
            tags_idx[start] = tag_set[tag]
            tag = "E" + tag[1:]
            end = start + len(em_text) - 1
            if tags_idx[end] != tag_set["O"]:
                overlap = True
            tags_idx[end] = tag_set[tag]
            tag = "I" + tag[1:]
            for index in range(start + 1, end):
                if tags_idx[index] != tag_set["O"]:
                    overlap = True
                tags_idx[index] = tag_set[tag]
        return overlap
    
        # prepare_data_set(fin, charset, vocab, relation_labels, entity_labels, tag_set, train, fout)
    
    
    def prepare_data_set(fin, charset, vocab, relation_labels, entity_labels, tag_set, dataset, fout):
        num_overlap = 0
        for line in fin:
            overlap = False
            line = line.strip()
            if not line:
                continue
            sentence = json.loads(line)
    
            for relation_mention in sentence["relationMentions"]:
                relation_labels.add(relation_mention["label"])
                make_tag_set(tag_set, relation_mention["label"])
            for entity_mention in sentence["entityMentions"]:
                entity_labels.add(entity_mention["label"])
    
            sentence_text = sentence["sentText"].strip().strip('"').split()
            length_sent = len(sentence_text)
            if length_sent > MAX_SENT_LENGTH:
                continue
    
            lower_sentence_text = [token.lower() for token in sentence_text]
            sentence_idx = prepare_sequence(lower_sentence_text, vocab)
    
            tokens_idx = []
            for token in sentence_text:
                if len(token) <= MAX_TOKEN_LENGTH:
                    tokens_idx.append(prepare_sequence(token, charset) + [charset["<pad>"]] * (MAX_TOKEN_LENGTH - len(token)))
                else:
                    tokens_idx.append(prepare_sequence(token[0:13] + token[-7:], charset))
    
            tags_idx = [tag_set["O"]] * length_sent
            for relation_mention in sentence["relationMentions"]:
                if relation_mention["label"] == "None":
                    continue
                em1_text = relation_mention["em1Text"].split()
                res1 = update_tag_seq(em1_text, sentence_text, relation_mention["label"], 1, tag_set, tags_idx)
                em2_text = relation_mention["em2Text"].split()
                res2 = update_tag_seq(em2_text, sentence_text, relation_mention["label"], 2, tag_set, tags_idx)
                if res1 or res2:
                    num_overlap += 1
                    overlap = True
            dataset.append((sentence_idx, tokens_idx, tags_idx))
            if overlap:
                fout.write(line + "\n")
        return num_overlap
    
    
    def group(data, breakpoints):
        groups = [[] for _ in range(len(breakpoints) + 1)]
        for idx, item in enumerate(data):
            i = bisect.bisect_left(breakpoints, len(item[0]))
            groups[i].append(idx)
        data_groups = [Subset(data, g) for g in groups]
        return data_groups
    
    
    class GroupBatchRandomSampler(object):
        def __init__(self, data_groups, batch_size, drop_last):
            self.batch_indices = []
            for data_group in data_groups:
                self.batch_indices.extend(list(BatchSampler(SubsetRandomSampler(data_group.indices),
                                                            batch_size, drop_last=drop_last)))
    
        def __iter__(self):
            return (self.batch_indices[i] for i in torch.randperm(len(self.batch_indices)))
    
        def __len__(self):
            return len(self.batch_indices)
    
    
    def get_batch(batch_indices, data, vocab, tag_set):
        batch = [data[idx] for idx in batch_indices]
        sorted_batch = sorted(batch, key=lambda x: len(x[0]), reverse=True)
        sentences, tokens, tags = zip(*sorted_batch)
    
        padded_sentences, lengths = pad_packed_sequence(pack_sequence([torch.LongTensor(_) for _ in sentences]),
                                                        batch_first=True, padding_value=vocab["<pad>"])
        padded_tags, _ = pad_packed_sequence(pack_sequence([torch.LongTensor(_) for _ in tags]),
                                             batch_first=True, padding_value=tag_set["O"])
    
        return padded_sentences, padded_tags, lengths
    
    
    def measure(output, targets, lengths, tag_set):
        assert output.size(0) == targets.size(0) and targets.size(0) == lengths.size(0)
        tp = 0
        tp_fp = 0
        tp_fn = 0
        batch_size = output.size(0)
        output = torch.argmax(output, dim=-1)
        for i in range(batch_size):
            length = lengths[i]
            out = output[i][:length].tolist()
            target = targets[i][:length].tolist()
            out_triplets = get_triplets(out, tag_set)
            tp_fp += len(out_triplets)
            target_triplets = get_triplets(target, tag_set)
            tp_fn += len(target_triplets)
            for target_triplet in target_triplets:
                for out_triplet in out_triplets:
                    if out_triplet == target_triplet:
                        tp += 1
        return tp, tp_fp, tp_fn
    
    
    def get_triplets(tags, tag_set):
        temp = {
        }
        triplets = []
        for idx, tag in enumerate(tags):
            if tag == tag_set["O"]:
                continue
            pos, relation_label, role = tag_set[tag].split("-")
            if pos == "B" or pos == "S":
                if relation_label not in temp:
                    temp[relation_label] = [[], []]
                temp[relation_label][int(role) - 1].append(idx)
        for relation_label in temp:
            role1, role2 = temp[relation_label]
            if role1 and role2:
                len1, len2 = len(role1), len(role2)
                if len1 > len2:
                    for e2 in role2:
                        idx = np.argmin([abs(e2 - e1) for e1 in role1])
                        e1 = role1[idx]
                        triplets.append((e1, relation_label, e2))
                        del role1[idx]
                else:
                    for e1 in role1:
                        idx = np.argmin([abs(e2 - e1) for e2 in role2])
                        e2 = role2[idx]
                        triplets.append((e1, relation_label, e2))
                        del role2[idx]
        return triplets
    
    
    if __name__ == "__main__":
        charset = Charset()
        vocab = Vocabulary()
        vocab.load("data/NYT_CoType/vocab.txt")
        relation_labels = Index()
        entity_labels = Index()
        tag_set = Index()
        tag_set.add("O")
        print(vocab)
        # vocab.save("data/vocab.txt")
        # print(vocab.key2idx)
        # print(vocab.get_word2vec())
        with open("overlap.txt", "wt", encoding="utf-8") as fout:
            train = []
            with open('data/NYT_CoType/train.json', 'rt', encoding='utf-8') as fin:
                res = prepare_data_set(fin, charset, vocab, relation_labels, entity_labels, tag_set, train, fout)
                print("# of overlaps in train data: {}".format(res))
            save(train, 'data/NYT_CoType/train.pk')
    
            test = []
            with open('data/NYT_CoType/test.json', 'rt', encoding='utf-8') as fin:
                res = prepare_data_set(fin, charset, vocab, relation_labels, entity_labels, tag_set, test, fout)
                print("# of overlaps in test data: {}".format(res))
            save(test, 'data/NYT_CoType/test.pk')
    
        relation_labels.save('data/NYT_CoType/relation_labels.txt')
        entity_labels.save('data/NYT_CoType/entity_labels.txt')
        tag_set.save("data/NYT_CoType/tag2id.txt")

### stats.py ###

import os
    import pickle
    import json
    
    
    def triplet_stats(fin):
        valid = 0
        total = 0
        for line in fin:
            line = line.strip()
            if not line:
                continue
            sentence = json.loads(line)
            total += len(sentence["relationMentions"])
            for relationMention in sentence["relationMentions"]:
                if relationMention["label"] != "None":
                    valid += 1
        return valid, total
    
    
    def sentence_length_stats():
        length_dict = {
        }
        with open('data/NYT_CoType/corpus.txt', 'rt', encoding='utf-8') as fin:
            for line in fin:
                sentence = line.strip().split()
                length = len(sentence)
                if length not in length_dict:
                    length_dict[length] = 1
                else:
                    length_dict[length] = length_dict[length] + 1
        with open('data/NYT_CoType/sentence_length_stats.pk', 'wb') as f:
            pickle.dump(length_dict, f)
    
    
    def token_length_stats():
        length_dict = {
        }
        with open('data/NYT_CoType/corpus.txt', 'rt', encoding='utf-8') as fin:
            for line in fin:
                sentence = line.strip().split()
                for word in sentence:
                    length = len(word)
                    if length not in length_dict:
                        length_dict[length] = 1
                    else:
                        length_dict[length] = length_dict[length] + 1
        with open('data/NYT_CoType/token_length_stats.pk', 'wb') as f:
            pickle.dump(length_dict, f)
    
    
    def show_length(length_dict, groups):
        max_length = max(length_dict.keys())
        total = sum(length_dict.values())
        length_list = list(length_dict.items())
        length_list.sort(key=lambda tup: tup[0])
        length_groups = [0] * len(groups)
        for length_tuple in length_list:
            for index, group in enumerate(groups):
                if length_tuple[0] <= group:
                    length_groups[index] = length_groups[index] + length_tuple[1]
                    break
    
        print("-" * 36)
        print("| (  0, {:3d}] | {:8d} | {:7.3f}% |".format(groups[0], length_groups[0], length_groups[0]/total*100))
        for i in range(1, len(length_groups)):
            print("| ({:3d}, {:3d}] | {:8d} | {:7.3f}% |"
                  .format(groups[i-1], groups[i], length_groups[i], length_groups[i]/total*100))
        print("-" * 36)
        print("|    Total   | {:8d} | {:7.3f}% |"
              .format(sum(length_groups), sum(length_groups) / total * 100))
        print("-" * 36)
        print("Max Length: {:d}".format(max_length))
    
    
    if __name__ == "__main__":
        if not os.path.exists('data/NYT_CoType/sentence_length_stats.pk'):
            sentence_length_stats()
        with open('data/NYT_CoType/sentence_length_stats.pk', 'rb') as f:
            length_dict = pickle.load(f)
        groups = list(range(10, 110, 10))
        show_length(length_dict, groups)
    
        if not os.path.exists('data/NYT_CoType/token_length_stats.pk'):
            token_length_stats()
        with open('data/NYT_CoType/token_length_stats.pk', 'rb') as f:
            length_dict = pickle.load(f)
        groups = list(range(5, 25, 3))
        show_length(length_dict, groups)
    
        print()
        with open('data/NYT_CoType/train.json', 'rt', encoding='utf-8') as fin:
            valid, total = triplet_stats(fin)
            print("Train\n\tValid Triplets: {}\n\tTotal Triplets: {}".format(valid, total))
        with open('data/NYT_CoType/test.json', 'rt', encoding='utf-8') as fin:
            valid, total = triplet_stats(fin)
            print("Test\n\tValid Triplets: {}\n\tTotal Triplets: {}".format(valid, total))
    
    # ------------------------------------
    # | (  0,  10] |     2251 |   0.952% |
    # | ( 10,  20] |    22997 |   9.729% |
    # | ( 20,  30] |    55208 |  23.356% |
    # | ( 30,  40] |    65138 |  27.557% |
    # | ( 40,  50] |    48907 |  20.690% |
    # | ( 50,  60] |    24943 |  10.552% |
    # | ( 60,  70] |    10123 |   4.283% |
    # | ( 70,  80] |     3848 |   1.628% |
    # | ( 80,  90] |     1619 |   0.685% |
    # | ( 90, 100] |      664 |   0.281% |
    # ------------------------------------
    # |    Total   |   235698 |  99.713% |
    # ------------------------------------
    # Max Length: 9621
    # ------------------------------------
    # | (  0,   5] |  6119176 |  68.385% |
    # | (  5,   8] |  2008222 |  22.443% |
    # | (  8,  11] |   682932 |   7.632% |
    # | ( 11,  14] |   120471 |   1.346% |
    # | ( 14,  17] |    12470 |   0.139% |
    # | ( 17,  20] |     3492 |   0.039% |
    # | ( 20,  23] |      807 |   0.009% |
    # ------------------------------------
    # |    Total   |  8947570 |  99.994% |
    # ------------------------------------
    # Max Length: 107
    #
    # Train
    # 	Valid Triplets: 111610
    # 	Total Triplets: 372853
    # Test
    # 	Valid Triplets: 410
    # 	Total Triplets: 3880

### train\_or\_test.py ###

from model import *
    import torch.nn as nn
    import torch.optim as optim
    import time
    from process import *
    
    vocab = Vocabulary()
    vocab.load("data/NYT_CoType/vocab.txt")  # ("data/NYT_CoType/vocab.txt")
    tag_set = Index()
    tag_set.load("data/NYT_CoType/tag2id.txt")
    # relation_labels = Index()
    # relation_labels.load('data/NYT_CoType/relation_labels.txt')
    
    train_data = load('data/NYT_CoType/train.pk')
    test_data = load('data/NYT_CoType/test.pk')
    val_size = int(0.01 * len(train_data))
    train_data, val_data = random_split(train_data, [len(train_data) - val_size, val_size])
    train_data_groups = group(train_data, [10, 20, 30, 40, 50, 60])
    val_data_groups = group(val_data, [10, 20, 30, 40, 50, 60])
    test_data_groups = group(test_data, [10, 20, 30, 40, 50, 60])
    
    word_embeddings = torch.tensor(np.load("data/NYT_CoType/word2vec.vectors.npy"))
    word_embedding_size = word_embeddings.size(1)
    pad_embedding = torch.empty(1, word_embedding_size).uniform_(-0.5, 0.5)
    unk_embedding = torch.empty(1, word_embedding_size).uniform_(-0.5, 0.5)
    word_embeddings = torch.cat([pad_embedding, unk_embedding, word_embeddings])
    
    model = LSTM_bias(word_embeddings, class_num=193)
    criterion = custom_loss2(tag_set)
    
    optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=0.0001)
    
    
    # sampler = GroupBatchRandomSampler(train_data_groups, 128, drop_last=False)
    def train():
        model.train()
        total_loss = 0
        count = 0
        sampler = GroupBatchRandomSampler(train_data_groups, 128, drop_last=False)
        for idx, batch_indices in enumerate(sampler):
            sentences, targets, lengths = get_batch(batch_indices, train_data, vocab, tag_set)
            optimizer.zero_grad()
            output = model(sentences)
            output = pack_padded_sequence(output, lengths, batch_first=True).data
            targets = pack_padded_sequence(targets, lengths, batch_first=True).data
            loss = criterion(output, targets, lengths)
            loss.backward()
            nn.utils.clip_grad_norm(model.parameters(), 5)
            optimizer.step()
            # print("inx:%d loss:%6f,"%(idx,loss))
            total_loss += loss.item()
            count += len(targets)
            if (idx + 1) % 10 == 0:
                val_loss, precision, recall, f1 = evaluate(test_data_groups, test_data)
                print("| Validation Loss {:5.3f} | Precision {:5.3f} | Recall {:5.3f} | F1 {:5.3f} |".format(val_loss, precision, recall, f1))
                cur_loss = total_loss / count
                elapsed = time.time() - start_time
                percent = ((epoch - 1) * len(sampler) + (idx + 1)) / (10 * len(sampler))
                remaining = elapsed / percent - elapsed
                print("| Epoch {:2d}/{:2d} | Batch {:5d}/{:5d} | Elapsed Time {:s} | Remaining Time {:s} | "
                      "lr {:4.2e} | Loss {:5.3f} |".format(epoch, 10, idx + 1, len(sampler), time_display(elapsed),
                                                           time_display(remaining), lr, cur_loss))
                total_loss = 0
                count = 0
    
    
    def evaluate(data_groups, new_data):
        model.eval()
        total_loss = 0
        count = 0
        TP = 0
        TP_FP = 0
        TP_FN = 0
        with torch.no_grad():
            for batch_indices in GroupBatchRandomSampler(data_groups, 128, drop_last=False):
                sentences, targets, lengths = get_batch(batch_indices, new_data, vocab, tag_set)
                output = model(sentences)
                tp, tp_fp, tp_fn = measure(output, targets, lengths, tag_set)
                TP += tp
                TP_FP += tp_fp
                TP_FN += tp_fn
                # print(output.shape, targets.shape)
                # print(lengths)
                # print(sentences)
                output = pack_padded_sequence(output, lengths, batch_first=True).data
                targets = pack_padded_sequence(targets, lengths, batch_first=True).data
                loss = criterion(output, targets, lengths)
                total_loss += loss.item()
                count += len(targets)
        model.train()
        return total_loss / count, TP / (TP_FP + 1), TP / (TP_FN + 1), 2 * TP / (TP_FP + TP_FN + 1)
    
    
    if __name__ == '__main__':
        best_val_loss = None
        all_val_loss = []
        all_precision = []
        all_recall = []
        all_f1 = []
        print("start:")
        lr = 0.001
        try:
            start_time = time.time()
            print("-" * 118)
            for epoch in range(1, 11):
                train()
                val_loss, precision, recall, f1 = evaluate(val_data_groups, val_data)
                elapsed = time.time() - start_time
                print("-" * 118)
                print("| End of Epoch {:2d} | Elapsed Time {:s} | Validation Loss {:5.3f} | Precision {:5.3f} "
                      "| Recall {:5.3f} | F1 {:5.3f} |".format(epoch, time_display(elapsed),
                                                               val_loss, precision, recall, f1))
                print("-" * 118)
                # Save the model if the validation loss is the best we've seen so far.
                if not best_val_loss or val_loss < best_val_loss:
                    with open("model/model.pk", 'wb') as f:
                        torch.save(model, f)
                    best_val_loss = val_loss
                else:
                    # Anneal the learning rate if no improvement has been seen in the validation dataset.
                    lr = lr / 4.0
                    for param_group in optimizer.param_groups:
                        param_group['lr'] = lr
                all_val_loss.append(val_loss)
                all_precision.append(precision)
                all_recall.append(recall)
                all_f1.append(f1)
        except KeyboardInterrupt:
            print('-' * 118)
            print('Exiting from training early')
        with open("model/model.pk", 'rb') as f:
            model = torch.load(f)
        # Run on test data
        print(len(test_data))
        test_loss, precision, recall, f1 = evaluate(test_data_groups, test_data)
        print("=" * 118)
        print("| End of Training | Test Loss {:5.3f} | Precision {:5.3f} "
              "| Recall {:5.3f} | F1 {:5.3f} |".format(test_loss, precision, recall, f1))
        print("=" * 118)
        with open("record.tsv", "wt", encoding="utf-8") as f:
            for idx in range(len(all_val_loss)):
                f.write("{:d}\t{:5.3f}\t{:5.3f}\t{:5.3f}\t{:5.3f}\n"
                        .format(idx + 1, all_val_loss[idx], all_precision[idx], all_recall[idx], all_f1[idx]))
            f.write("\n{:5.3f}\t{:5.3f}\t{:5.3f}\t{:5.3f}\n".format(test_loss, precision, recall, f1))

### utils.py ###

import string
    import pickle
    import numpy as np
    import torch
    
    class Index(object):
        def __init__(self):
            self.key2idx = {
        }
            self.idx2key = []
    
        def add(self, key):
            if key not in self.key2idx:
                self.key2idx[key] = len(self.idx2key)
                self.idx2key.append(key)
            return self.key2idx[key]
    
        def __getitem__(self, key):
            if isinstance(key, str):
                return self.key2idx[key]
            if isinstance(key, int):
                return self.idx2key[key]
    
        def __len__(self):
            return len(self.idx2key)
    
        def save(self, f):
            with open(f, 'wt', encoding='utf-8') as fout:
                for index, key in enumerate(self.idx2key):
                    fout.write(key + '\t' + str(index) + '\n')
    
        def load(self, f):
            with open(f, 'rt', encoding='utf-8') as fin:
                for line in fin:
                    line = line.strip()
                    if not line:
                        continue
                    key = line.split()[0]
                    self.add(key)
    
    
    class Charset(Index):
        def __init__(self):
            super().__init__()
            for char in string.printable[0:-6]:  # 所有的字母加符号
                self.add(char)
            self.add("<pad>")
            self.add("<unk>")
    
        @staticmethod
        def type(char):
            if char in string.digits:
                return "Digits"
            if char in string.ascii_lowercase:
                return "Lower Case"
            if char in string.ascii_uppercase:
                return "Upper Case"
            if char in string.punctuation:
                return "Punctuation"
            return "Other"
    
        def __getitem__(self, key):
            if isinstance(key, str) and key not in self.key2idx:
                return self.key2idx["<unk>"]
            return super().__getitem__(key)
    
    
    class Vocabulary(object):
        def __init__(self):
            self.key2idx = {
        }
            self.idx2key = []
            self.word2vec = []
            self.add("<pad>")
            self.add("<unk>")
    
        def add_key_vec(self, key,vec):
            if key not in self.key2idx:
                self.key2idx[key] = len(self.idx2key)
                self.idx2key.append(key)
                self.word2vec.append(vec)
            return self.key2idx[key]
    
        def add(self, key):
            if key not in self.key2idx:
                self.key2idx[key] = len(self.idx2key)
                self.idx2key.append(key)
            return self.key2idx[key]
    
        def __len__(self):
            return len(self.idx2key)
    
        def save(self, f):
            with open(f, 'wt', encoding='utf-8') as fout:
                for index, key in enumerate(self.idx2key):
                    fout.write(key + '\t' + str(index) + '\n')
    
        def load(self, f):
            with open(f, 'rt', encoding='utf-8') as fin:
                for line in fin:
                    line = line.strip()
                    if not line:
                        continue
                    out = line.split()
                    key = out[0]
                    #vec = np.asarray(out[1:], dtype=np.float32)
                    self.add(key)
                    #self.add_key_vec(key,vec)
    
        def __getitem__(self, key):
            if isinstance(key, str) and key not in self.key2idx:
                return self.key2idx["<unk>"]
            if isinstance(key, str):
                return self.key2idx[key]
            if isinstance(key, int):
                return self.idx2key[key]
    
        def get_word2vec(self):
            trim_word_vec = np.array(self.word2vec)
            trim_word_vec = trim_word_vec.astype(np.float32).reshape(-1,300)
            return torch.from_numpy(trim_word_vec)
    
    def prepare_sequence(seq, to_idx):
        return [to_idx[key] for key in seq]
    
    
    def save(obj, path):
        with open(path, 'wb') as f:
            pickle.dump(obj, f)
    
    
    def load(path):
        with open(path, 'rb') as f:
            return pickle.load(f)
    
    
    def time_display(s):
        d = s // (3600 * 24)
        s -= d * (3600 * 24)
        h = s // 3600
        s -= h * 3600
        m = s // 60
        s -= m * 60
        str_time = "{:1d}d ".format(int(d)) if d else "   "
        return str_time + "{:0>2d}:{:0>2d}:{:0>2d}".format(int(h), int(m), int(s))

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]: https://img-blog.csdnimg.cn/02ea24b618f344c38becf3b9d5e78cbf.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]: https://img-blog.csdnimg.cn/8c873c66ef6a4265b901910b291b3b32.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 2]: https://img-blog.csdnimg.cn/f54316454fba48d8bd2671a104a64786.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 3]: https://img-blog.csdnimg.cn/8e2067754d104dd5a12f99c85bcfe406.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 4]: https://img-blog.csdnimg.cn/209df950c30f4ab4a25cee96627d33e7.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 5]: https://img-blog.csdnimg.cn/d79ddc81b6ec4916956d0a44031839a6.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 6]: https://img-blog.csdnimg.cn/23b43c2e4ff74a0e93119fb47fb7e4ae.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 7]: https://img-blog.csdnimg.cn/88e239a219704d07b1a5b9ee4acc7192.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 8]: https://img-blog.csdnimg.cn/fbf2bfd58e8e4c5fa47eb747fc073590.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 9]: https://img-blog.csdnimg.cn/947f9e1a370d4246a70a8909c4eebfc4.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 10]: https://img-blog.csdnimg.cn/a5911aa4a7d54009a6da7b67a62965a2.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 11]: https://img-blog.csdnimg.cn/f850d23b932e48b9b6216cd272f91551.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 12]: https://img-blog.csdnimg.cn/6b8a2dcb7e024288a6544b2139608387.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 13]: https://img-blog.csdnimg.cn/e2fdf6b297e644a6af70fbcb21ebfb8a.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 14]: https://img-blog.csdnimg.cn/6eaed181a53143bd9a50ab49f88f4830.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 15]: https://img-blog.csdnimg.cn/8f25145bb41a4861886b6459763e2903.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 16]: https://img-blog.csdnimg.cn/8e151ec0230b4235bbef8a2a88978873.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 17]: https://img-blog.csdnimg.cn/68aaf5a9a7cc450ebc8a624f7ac88b84.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 18]: https://img-blog.csdnimg.cn/c0c9ce1cbfa74f2198a119985603d183.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 19]: https://img-blog.csdnimg.cn/ab82d42bb5ec43cd89bcf1b53e9e3bf0.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 20]: https://img-blog.csdnimg.cn/bde09a6f4d494c1280b3818532e2e6ec.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 21]: https://img-blog.csdnimg.cn/d7a678c173c944789b4561282214f3cb.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 22]: https://img-blog.csdnimg.cn/d6e0e40f64af42188e34d446f314184f.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 23]: https://img-blog.csdnimg.cn/b200d09b7c7a46908f015085fa3802a1.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center