Event Detection Using a Self-Constructed Dependency and Graph Convolution Network

Abstract

The extant event detection models, which rely on dependency parsing, have exhibited commendable efficacy. However, for some long sentences with more words, the results of dependency parsing are more complex, because each word corresponds to a directed edge with a dependency parsing label. These edges do not all provide guidance for the event detection model, and the accuracy of dependency parsing tools decreases with the increase in sentence length, resulting in error propagation. To solve these problems, we developed an event detection model that uses a self-constructed dependency and graph convolution network. First, we statistically analyzed the ACE2005 corpus to prune the dependency parsing tree, and combined the named entity features in the sentence to generate an undirected graph. Second, we implemented an enhanced graph convolution network using the multi-head attention mechanism to understand the representation of nodes in the graph. Finally, a gating mechanism combined the semantic and structural dependency information of the sentence, enabling us to accomplish the event detection task. A series of experiments conducted on the ACE2005 corpus demonstrates that the proposed method enhances the performance of the event detection model.

1. Introduction

Event detection is important because it helps with quickly obtaining structured event information from lengthy text [1]. Event detection involves two different subtasks: event detection and event argument extraction. The event detection task first identifies the trigger words in a sentence, and then classify them into predefined event categories. The event argument extraction task extracts the parameters of the sentence according to the event type and then performs classification.

Event detection is different from other information extraction tasks. To obtain the best results, the model must understand not only the semantics of a sentence, but also the structural information in a sentence [2]. For this, the fusion of dependent syntactic information for event detection has become one of the current mainstream methods. Dependency parsing [3] outputs a directed graph G = (N, E), where N represents a node and E represents a directed edge, corresponding to the words in the sentence and the directed edge in the graph, respectively. Figure 1 shows the dependency syntax analysis result of the sentence “During a meeting, the team owner told Jordan that his services were no longer necessary tomorrow”. The verb is selected as the core word of dependency parsing; in the above sentence, “told” is the core word, so it is directly connected to the “root” node. Dependency parsing results reflect the collocation relationship between words in sentences, and can provide key clues for event detection. Dependency information includes syntactic structure information and relation label information. The former shows the semantic relevance of words in the dependency relationship, whereas the latter describes the specific type of dependency relationship between two words, reflecting the differences in the syntactic characteristics between different words.

Graph Convolution Network (GCN) [4] is a deep-learning method used for processing and analyzing graph data, which can learn the results of dependency parsing. By employing a convolution operation on graph data, a fresh representation of nodes is produced by consolidating the features of both nodes and their neighbors. To date, researchers have shown a keen interest in GCNs, and methods grounded in GCN have become some of the leading approaches in event detection tasks.

However, Liu et al. [5] and Song et al. [6] found that using a large number of edge types derived from dependency parsing substantially increase the number of model parameters and requires many training calculations. Cui et al. [7] stated that “nsubj” (nominal subject), “dobj” (direct object) and “nmod” (noun compound modifier) constituted 32.2% of the dependency labels related to trigger words in the ACE2005 dataset (each relationship accounted for 2.5% of an average total of 40 dependencies). Although dependency parsing can provide useful structural information for event detection tasks, large amounts of redundant information are introduced and the effect of event detection is reduced.

To solve the above problems, we developed an event detection model using a self-constructed dependency and graph convolution network. First, we calculated the data statistics on the dependency parsing of the ACE2005 dataset; based on the results, we pruned the dependency parsing tree of a sentence and combined the named entity features to build an undirected graph. Second, we used the improved graph convolution network based on the multi-head attention mechanism to capture graph nodes. The representation of nodes in the graph was dynamically updated during the whole training process. The importance of dependency was distinguished through the multi-head attention mechanism. Finally, we used a gating mechanism to dynamically combine the semantic information of the sentence with the structural dependency information of the event.

The main contributions of this study are as follows:

• We designed a novel graph construction method by pruning the dependency parsing tree and combining the named entity features.
• We used the multi-head attention mechanism to improve the GCN model, and we dynamically fused the semantic representation of the sentence and structural dependency information through a gating mechanism.
• The experiments conducted on the ACE2005 benchmark verified that our proposed method can improve the event detection effect of the model and has certain rationality.

This paper is organized as follows: First, we introduce the definition of the event detection task and some existing problems. Second, we introduce the achievements regarding event detection in recent years. Third, given the shortcomings of existing methods, we introduce the proposed event detection model. Fourth, we describe the proof of the model through comparative experiments, verify the necessity of each part of the model and show that the model achieved the best effect through ablation experiments. Last, we summarize the study and describe directions for improvements to the model in the future.

2. Related Work

Modeling event extraction into classification tasks based on machine learning is the current mainstream research direction; deep learning and neural networks have become the main means of event extraction. Fully connected neural networks and circular neural networks have been successfully applied to event extraction tasks. The attention mechanism and self-attention mechanism have also been introduced to the event extraction task because of their ability to capture links in the text context. In the research on event extraction for English text, Chen et al. [8] proposed a classic model: they used a dynamic multi-pooled convolutional neural network and the location information provided by trigger words to capture the context information of an entity. Nguyen et al. [9] abandoned the pipeline extraction method on the basis of Chen et al., introduced a joint extraction method into event extraction, and extracted the semantic features in sentences using bidirectional LSTM [10], which they fused with the sentence structure features. Liu et al. [11] and Yang et al. [12] introduced many word embedding methods, including word embedding, position embedding, type embedding and dictionary embedding and used sentence semantics. To further integrate syntactic information into the model, Sha et al. [13] introduced a syntactic dependency tree into the model, and feature aggregation was performed by syntactic dependency through RNN [14]. Finally the final extraction result was obtained by aggregating the relationship pairs between entities.

After Google proposed the Transformer architecture [15] in 2019, using the self-attention mechanism to extract context in the word vector, on the basis of Transformer, the Bert architecture was proposed to achieve unsupervised training on massive texts. Yang et al. [16] then introduced the Bert architecture into event extraction, and used it as a generation word vector for the next feature aggregation, and they proposed dataset generation technology based on Bert’s mask mechanism. Ramponi et al. [17] introduced an event extraction mechanism based on the Bert mechanism into the key event extraction for biomedicine and optimized it for relevant fields. To address the challenges posed by complex syntax, many graph-based models have been introduced to the event extraction model. Liu et al. [5] constructed isomorphic graph structures by combining the results of syntactic dependency analysis with words; they used graph attention networks for feature aggregation and also simplified and optimized the complexity of graphs. In addition to sentence-level event extraction, corresponding studies have been conducted on document-level event extraction. Zheng et al. [18] proposed an end-to-end document-level event extraction system in the field of Chinese finance. Yang et al. [19] proposed filtering out key sentences from the document level and then performing the sentence-level event extraction task, to achieve text-level event extraction. Yan et al. [20] proposed the idea of multi-hop dependency parsing, using the graph attention network (GAT) [21] to transform the dependency syntax tree into a multi-level graph structure for modeling, thus enhancing the semantic association between trigger words and related entities. Cui et al. [7] introduced dependency label information into GCN and proposed an edge-enhanced graph neural network model, which achieved better performance than the current benchmark model. However, because the focus of the model is integrating syntactic structure and typed dependency labels, it only uses a simple splicing method to fuse the semantic information and structural dependency information of sentences, without distinguishing the importance of dependency relationships. Effectively using the results of sentence dependency parsing and integrating this structured information into the model without adding redundant information still remain challenging in this context.

3. Methods

The event detection model proposed in this paper is shown in Figure 2. Initially, we acquire the contextual representation of the input sentence, and subsequently formulate a dependency graph to input into the improved GCN layer. Then, through the gating mechanism, we fuse the semantic representation and the dependency structure information, where the classifier is employed for event detection. In this section, we describe the proposed method in five parts: embedding layer, dependency graph construction method, multi-GCN, gating mechanism fusion and event detection.

3.1. Embedding Layer

Let $S=\left\{w_1,w_2,\dots ,w_n\right\}$ denote an n-word sentence. We first use Bert to obtain the context representation of the input sentence. Bert is a coding structure with self-attention mechanism, so it can fully understand sentence context, better solve the problem of polysemy in sentences (for example, “apple” can represent a kind of fruit or a company that produces consumer electronics; the model needs to understand the true meaning of words according to the sentence context), and alleviate the impact of long-distance dependence on the detection effect of the model. The two arguments that belong to the same event may have a considerable distance between their respective positions; the model should try to avoid forgetting previous information in the learning process. For the event detection task, the Bert model inserts a CLS token [22] in front of the sentence: this is a special token used to represent the entire sequence for the purpose of classification tasks. By using the vector representation of the CLS token, the model can capture the overall meaning and context of the input sequence.

$$X=\left\{X_1,X_2,\cdots ,X_n\right\}=Bert\left(w_1,w_2,\dots ,w_n\right)$$

(1)

3.2. Dependency Graph Construction Method

We used the Stanford CoreNLP tool [3] to analyze the dependency syntax of sentences, and we statistically analyzed the processing results of all sentences in the ACE2005 corpus. According to

Table 1. Statistics of dependency parsing tags related to trigger words on ACE2005 dataset.

Dependency Parsing Labels	Percentage of Labels in the Corpus (%)	Probability of Label Associated with Trigger Words (%)	Ranking
nsubj:pass (nominal subject)	1.01	31.66	1
aux:pass (auxiliary)	1.18	27.96	2
obl (oblique nominal)	5.38	27.78	3
advcl (adverbial clause modifier)	1.34	27.76	4
det (determiner)	8.81	8.98	26
case (case marking)	11.11	7.82	31

, the probability of “det” (determiner) and “case” (case marking), which appear most frequently in all dependent syntactic label as the trigger word related label, is lower than 10%. We considered that these types of edges can be classified as redundant information. Therefore, based on the above statistics, we proposed a pruning dependency syntax tree. For each branch, if the current parsing label does not belong to the top 10 as the probability of label associated with trigger words, it is removed. The pruning result is shown in Figure 3.

Because the input of GCN is an undirected graph, the dependency relationship is built based on the following rules:

(1)

Reverse edges ($\mathrm{E}\left(w_j,w_i\right)$): To strengthen the flow of dependency information in the opposite direction on the edge of the graph, and better capture the relationship between entities, we add the corresponding reverse edge $\mathrm{E}\left(w_j,w_i\right)$ for each edge $\mathrm{E}\left(w_j,w_i\right)$ generated by dependency parsing.

(2)

Sequence edges ($\mathrm{E}\left(w_i,w_{i+1}\right)$): To restore the integrity of the sentence and capture the adjacency relationship in time sequence, we add an adjacency edge $\mathrm{E}\left(w_i,w_{i+1}\right)$ to each adjacency word.

(3)

Entity edges ($\mathrm{E}\left(w_{e1},w_{e2}\right)$): To enhance the model’s understanding of the entity features in the sentence, the named entity recognition method is used to extract the entities in the sentence and connect them with each other.

(4)

Self-connected edges ($\mathrm{E}\left(w_i,w_i\right)$): We add self-connected edges to each character to prevent nodes from ignoring their own characteristics.

To extract the entities in the sentence, we use the sequence labeling method based on the Begin, Inside, Other (BIO) pattern; we use conditional random field (CRF) to identify the entities. In the training phase, we minimized the following loss:

$${\mathrm{L}}_{ner}=-\sum _{s\in \mathrm{D}}logP\left(y_s\mid s\right)$$

(2)

where $y_s$ is the golden label of s. For inference, we used the Viterbi algorithm to decode the label sequence with the maximum probability.

The final result of the self-constructed dependency graph is shown in Figure 4 (self-connected edge omitted); the nodes with the darkened background in the figure indicate the entities that we extracted.

3.3. Multi-GCN

To fully use the dependency relationship in $GCN$ to explore the potential relationship between words, we built an L-layer $GCN$ and defined its propagation rules as follows:

$$E^l,N^l=GCN\left(N^{l-1},E^{l-1}\right)$$

(3)

where $N^l$ indicates the vector representation of the node in layer l, and $E^l$ indicates the vector representation of the edge in layer l. At the initial stage of $l-1=0$, $E^0$ indicates the initial adjacency matrix of the graph and $N^0$ indicates the input node vector. In the model training stage, GCN updates the vector representation of the node by aggregating the neighbor information around the current node, and the adjacency tensor is aggregated channel by channel. The calculation formula is as follows:

$$\begin{array}{c}{N}^l=\sigma \left(N_1^l,N_2^l,\dots ,N_Q^l\right)\\ N_i^l=E_{:,:,i}^{l-1}{N}^{l-1}{W}_v,i\in [1,Q]\end{array}$$

(4)

where $\sigma$ is the ReLU activation function, $N_i^l$ is the vector representation of node i output from layer l, $E_{:,:,i}^{l-1}$ is the i-th channel slice of adjacency tensor $E^{l-1}$, and $W_v$ is the learnable weight parameter.

Then, we update the edge representation through the context of the two nodes connected to the edge; the calculation formula is as follows:

$$E_{i,j,:}^l=\left[E_{i,j,:}^{l-1}∥N_i^l∥N_j^l\right]W_e,i,j\in [1,n]$$

(5)

where ‖ is the splicing operation, and $W_e$ is the learnable weight parameter.

After learning the GCN of layer L, the final node representation is marked as N’, which contains the dependency information in the sentence. However, it still contains some less important information. Therefore, in order to distinguish the importance of dependency, we use the multi-head attention with the number of heads of K, and obtain the representation M of the node by setting the weight of the dependency. The calculation formula is as follows:

$$M=\mathrm{MultiHeadAttention}({\mathrm{N}}^{\prime },{\mathrm{N}}^{\prime },{\mathrm{N}}^{\prime })$$

(6)

3.4. Gating Mechanism Fusion

After obtaining the semantic representation X and dependency representation M of the sentence, we use the gating mechanism to dynamically integrate the semantic representation and dependency representation. Its formula is as follows:

$$\begin{array}{c}G=W_g\times [X\parallel M]+b_g\\ \tilde{G}=\sigma \left(G\right)\odot G\end{array}$$

(7)

where ‖ indicates matrix splicing, $W_g$ is the weight parameter, $b_g$ is the offset, $\sigma$ is the sigmoid activation function, and ⊙ represents the corresponding multiplication of matrix elements.

3.5. Event Detection

Finally, we use a fully connected layer to process the node representation $\tilde{G}$ of the gated mechanism output, calculate the event type score of the words in the sentence, normalize it through the SoftMax function, and output the conditional probability distribution Y. The calculation formula is as follows:

$$Y=SoftMax\left(W_y\tilde{G}+b_y\right)$$

(8)

where $W_y$ is the weight parameter, and $b_y$ is the offset. We take the trigger word label with the largest value in the probability distribution Y as the final event detection result.

4. Experiments

4.1. Datasets

The ACE2005 English dataset was used for the experiment, which contains 599 English documents and is annotated with 8 event types, 33 subtypes and 35 argument roles. In this study, the training, verification and test sets were divided according to the ratio 8:1:1. As ACE2005 contains six types of events, it was also divided according to the ratio of 8:1:1 in each category to ensure relative balance of the training samples. Finally, 479 training corpora, 60 verification corpora and 60 test corpora were obtained. We used the standard evaluation methods for the event detection task, that is, accuracy (P), recall (R) and F1 score as indicators.

4.2. Experiment Setting

In the experiment, the number of GCN layers L was 3, the number of multi-head attention heads K was 3, the learning rate was 1 × 10${}^{-3}$, the model training batch was 42, and the number of training rounds was 50. We set the Adam optimization model to accelerate the convergence rate; the cross entropy loss function was used to ensure that the convergence speed of the model was not affected when the learning rate drops suddenly. L2 regularization and the dropout mechanism were used to prevent the model from over-fitting.

4.3. Comparison Experiment

To verify the effect of our model, several baseline models of event detection were compared. Three event detection models based on feature, sequence and continuous GCN were selected for comparison:

(1)

Feature-based model: Event detection is performed by manually designing features. CrossEntity [23] uses cross-entity information to detect events, and MaxEnt [24] uses lexical and syntactic features to detect events.

(2)

Sequence-based model: Event detection is performed by processing and analyzing word sequences in sentences. DMCNN [8] builds a dynamic multi-pool CNN to learn sentence features, JRNN [9] uses bidirectional RNN to learn dependencies in sequences, and DBRNN [13] uses bidirectional RNN based on a syntax dependency tree to capture the dependencies between words.

(3)

GCN-based model: A graph is built according to the dependency of sentences, syntactic information is extracted through GCN, and events are detected. JMEE [5] combines an attention mechanism with GCN to improve the performance. RGCN [25] uses an adjacency matrix and a convolution filter of a specific relationship to model data to perform tasks. MOGANED [20] updates the node representation by aggregating the attention of each layer on GCN with an attention mechanism; EE-GCN [7] uses GCN to learn semantic information and add dependency information to dynamically update the representation of nodes and edges.

Table 2. Exploring the effect of different compatibility functions on the overall performance of the model.

Methods	Precision (%)	Recall (%)	F1 (%)
MaxEnt	74.5	59.1	65.9
CrossEntity	68.7	68.9	68.8
DMCNN	75.6	63.6	69.1
JRNN	66.0	73.0	69.3
DBRNN	74.1	69.8	71.9
RGCN	68.4	79.3	73.4
JMEE	76.3	71.3	73.7
MOGANED	79.5	72.3	75.7
EEGCN	76.7	78.6	77.6
Ours	79.7	77.2	78.4

shows that our model can effectively improve the performance of event detection tasks. Of all considered models, the precision value and F1 score of our method are the highest, at 79.2% and 78.0%, respectively. We attribute the performance gain to two aspects: (1) Compared with the other dependency-parsing-based event detection models, we do not use a full range of parsing labels, which reduces not only the training parameters of the model but also the introduction of redundant information and avoids the propagated error from the dependency parsing tool. (2) We use the multi-head attention mechanism to improve the GCN model to select important dependencies; finally, semantic representation and dependencies are dynamically fused through a gating mechanism. Although the EEGCN model also integrates this information, it does not distinguish the importance of dependencies, and does not use dynamic fusion mechanism, but simply splices.

4.4. Ablation Experiments

4.4.1. Analysis of Impact of Different Graph Structures on the Model

The above-described experiments have shown that the proposed model can effectively improve event detection performance compared with existing methods. To further verify the impact of different graph structures on the model, ablation was conducted for several edge types introduced in the graph.

Table 3. Influence of different graph structures on the model.

Methods	Precision (%)	Pecall (%)	F1 (%)
-	78.3	76.8	77.5
Pruning	78.9	76.5	77.7
Entity Edges	78.1	76.2	77.1
Pruning + Entity Edges	79.7	77.2	78.4

shows the event detection performance of using a dependency parsing tree, a pruning dependency parsing tree, entity feature edge, and combining entity feature and pruning dependency parsing tree to build a graph. Among them, the result of introducing the edge of entity features only was the worst. A possible reason is that this method helps the model recognize the entity features in the event mention but also increases the complexity of the edge in the graph, leading to the decline in experimental results. Our proposed method of dependency parsing tree pruning combined with entity feature edge construction produced the best result because it can not only reduce unnecessary parameters in the model, but also help the model to identify important entity feature information in the event detection task.

4.4.2. Analysis of Influence of GCN Layers L and Attention Heads K on Model Effect

In this study, we built an L-layer GCN model and used the multi-head attention mechanism to improve the GCN model. To achieve the best performance, we explored the impact of the numbers of GCN layers and attention heads K on the performance of the model. While other parameters remained constant in the experiment, we increased the number of hidden layers and attention heads from one to five for the experiment; the event detection results are shown in

Table 4. Analysis of influence of GCN layers L and Attention heads K on model effect.

GCN Layers	F1-Score (%)	Attention Heads	F1-Score (%)
1	75.8	1	76.1
2	77.4	2	77.6
3	78.4	3	78.4
4	77.8	4	78.0
5	76.7	5	76.9

. Here, we only focus on the F1 score. From the results in the table, we can see that the efficacy of the model first increased but subsequently declined, as the numerical values of the two parameters increased. The best result was obtained when both values were three, so we finally determined that three GCN layers and attention heads should be used.

5. Conclusions and Future Work

We developed an event detection model using a self-constructed dependency and graph convolution network as a novel method to identify important words and dependencies in sentences; our model effectively increases the performance of event detection. In the event detection model, the dependency parsing tree is pruned to reduce the redundant information introduced by dependency parsing; an improved GCN model is used to learn the dependency representation of sentences, and the multi-head attention mechanism is used to extract important dependency features. Finally, a gating mechanism is used to dynamically fuse the semantic and dependency features of the context for event detection. We conducted a series of comparative experiments on a public event detection dataset, compared the performance of our method with that of several benchmark models of current event detection, and analyzed the impact of various experimental parameters on the model’s efficacy. The final experimental results fully verified the effectiveness of the proposed event detection model. In the future, we will continue to optimize the graph structure or further improve the graph convolution network layer. More effective features can be integrated to improve the model.