Revisiting Event Argument Extraction: Can EAE Models Learn Better When Being Aware of Event Co-occurrences?
Year: 2023

Abstract:
Event co-occurrences have been proved effective for event extraction (EE) in previous studies, but have not been considered for event argument extraction (EAE) recently. In this paper, we try to fill this gap between EE research and EAE research, by highlighting the question that “Can EAE models learn better when being aware of event co-occurrences?”. To answer this question, we reformulate EAE as a problem of table generation and extend a SOTA prompt-based EAE model into a nonautoregressive generation framework, called TabEAE, which is able to extract the arguments of multiple events in parallel. Under this framework, we experiment with 3 different training-inference schemes on 4 datasets (ACE05, RAMS, WikiEvents and MLEE) and discover that via training the model to extract all events in parallel, it can better distinguish the semantic boundary of each event and its ability to extract single event gets substantially improved. Experimental results show that our method achieves new state-ofthe-art performance on the 4 datasets. Our code is avilable at https://github.com/ Stardust-hyx/TabEAE.

heading: 1 Introduction
text: Event argument extraction (EAE) is an essential subtask of event extraction (EE). Given an input text and trigger(s) of target event(s), the EAE task aims to extract all argument(s) of each target event. Recently, substantial progress has been reported on EAE, thanks to the success of pre-trained language models (PLMs).
Previous studies on EE commonly take event cooccurrences into account. However, recent works on EAE (Ebner et al., 2020; Zhang et al., 2020; Xu et al., 2022; Du and Cardie, 2020; Wei et al., 2021; Liu et al., 2021; Li et al., 2021; Du et al.,
†Corresponding Author.
2021; Lu et al., 2021; Ma et al., 2022) only consider one event at a time and ignore event cooccurrences (as illustrated in Figure 1). In fact, event co-occurrences always exisit in text and they are useful in revealing event correlation and contrasting the semantic structures of different events. For the instance in Figure 1, there exist two events in the same context. The two events are triggered by “leaving”, “become” respectively, and share the same subject “Davies”. It is clear that there exists a strong causal correlation between the two events. However, mainstream works on EAE split the instance into two samples, which conceals this correlation.
In this paper, we try to resolve this divergence between EE research and EAE research, by highlighting the question that “Can EAE models learn better
12542
when being aware of event co-occurrences?”. To address this question, we reformulate EAE as a problem of table generation and extend the SOTA prompt-based EAE model, PAIE (Ma et al., 2022), into a non-autoregressive generation framework to extract the arguments of multiple events concurrently. Our framework, called TabEAE, inherits the encoding, prompt construction and span selection modules from PAIE, but employs a novel non-autoregressive decoder for table generation.
Under this framework, we explore three kinds of training-inference schemes: (1) Single-Single, training model to extract single event at a time and infer in the same way; (2) Multi-Multi, training model to extract all events in parallel and infer in the same way; (3) Multi-Single, training model to extract all events in parallel and let the model extract single event at a time during inference. According to our experiments, the MultiSingle scheme works the best on 3 benchmarks (ACE, RAMS and WikiEvents) and the Multi-Multi scheme works the best on the MLEE benchmark, where the phenomenon of nested events extensively exists. Besides, in-depth analysis reveals that via training TabEAE to extract all events in parallel, it can better capture the semantic boundary of each event and its ability to extract single event at a time gets substantially improved.
To sum up, our contributions include:
• We observe the divergence between EE research and EAE research in terms of the phenomenon of event co-occurrence. To resolve this divergence, we extend the SOTA prompt-based EAE model PAIE into a text-to-table framework, TabEAE, which is able to extract the arguments of multiple events concurrently.
• Under the TabEAE framework, we explore three training-inference schemes, i.e. Single-Single, Multi-Multi, Multi-Single, and verify the significance of event co-occurrence for EAE.
• The proposed method outperforms SOTA EAE methods by 1.1, 0.4, 0.7 and 2.7 in Arg-C F1 respectively on the 4 benchmarks ACE05, RAMS, WikiEvents and MLEE.

heading: 2 Related Work

heading: 2.1 Event Argument Extraction
text: As a crucial subtask of EE, EAE has long been studied. In the early stages, EAE is only treated
as a component of EE systems (Chen et al., 2015; Nguyen et al., 2016; Yang et al., 2018; Zheng et al., 2019; Lin et al., 2020), where the phenomenon of event co-occurrence is always taken into account.
Recently, more and more works study EAE as a stand-alone problem. We summarize these recent works on EAE into 4 categories: (1) spanbased methods that identify candidate spans and predict the roles of them (Ebner et al., 2020; Zhang et al., 2020; Xu et al., 2022); (2) QA-based methods that query arguments using questions constructed with predefined templates (Du and Cardie, 2020; Wei et al., 2021; Liu et al., 2021); (3) sequence-tosequence methods that leveraging generative PLMs, e.g. BART (Lewis et al., 2020) and T5 (Raffel et al., 2020), to sequentially generate all arguments of the target event (Li et al., 2021; Du et al., 2021; Lu et al., 2021); (4) a prompt-based method by Ma et al. (2022) that leverages slotted prompts to extract arguments in a generative slot-filling manner.
Among them, the prompt-based method, PAIE (Ma et al., 2022), demonstrates SOTA performance. However, all of them only consider one event at a time, diverging from EE research. In this work, we adapt PAIE into a non-autoregressive table generation framework, which is able to extract the arguments of multiple events in parallel.

heading: 2.2 Text-to-Table
text: Although table-to-text (Bao et al., 2018; Chen et al., 2020) is a well-studied problem in the area of controllable natural language generation, Text-toTable, the inverse problem of table-to-text, is just newly introduced by Wu et al. (2022). In Wu et al. (2022), text-to-table is solved with a sequence-tosequence model enhanced with table constraint and table relation embeddings. In contrast, our table generation framework constructs the slotted table input based on given trigger(s) and predefined prompt(s), and generate in a non-autoregressive manner.

heading: 3 Methodology
text: In this section, we will first give an formal definition of EAE and then introduce TabEAE, our solution to the task in detail.

heading: 3.1 Task Definition
text: An instance of EAE has the general form of (x, {ti}Ni=1 , {ei}Ni=1 , {Rei}Ni=1 , {Ai}Ni=1), where x is the text (a sentence or a document), N is the
number of target events, ti is the trigger of i-th event, ei is the type of i-th event, Rei is the set of argument roles associated with the event type ei, Ai is the set of arguments of the i-th event and each a(r) ∈ Ai is a textual span within x that represents the role r ∈ Rei . Different from the formulation by previous research on EAE that only considers one event for an input instance, this formulation takes all events co-occurring in the same context into consideration, providing a more comprehensive view of the problem.

heading: 3.2 TabEAE
text: Our solution to EAE is a non-autoregressive table generation framework, namely TabEAE, which is derived from the SOTA prompt-based EAE model PAIE. Figure 2 gives an overview of the framework. A detailed description of each component comes as follows.

heading: 3.2.1 Trigger-aware Context Encoding
text: Given an input text x = x1, x2, ..., xL with a set of event triggers, we first mark each trigger with a pair of markers (<T-i>,</T-i>), where i counts the order of occurrence. Note that, there may be multiple events sharing the same trigger, in which case the shared trigger will only be marked once. After that, we tokenize the marked text into
x̃ = [
, x1, x2, ...,<T-1>, xt1 ,</T-1>, (1)
...,<T-i>, xti ,</T-i>, ..., xL,
] (2)
where xti is the text fragment of the i-th trigger.
By feeding x̃ into a transformer-based encoder, we can get the encoding of the text:
Ex̃ = Encoder(x̃) (3)
We follow PAIE (Ma et al., 2022), to further decodes Ex̃ with a decoder to obtain the eventoriented context representation:
Hx̃ = Decoder(Ex̃) (4)

heading: 3.2.2 Slotted Table Construction
text: The decoder input is constructed as a slotted table, where the column header is the concatenation of event-schema prompt(s) proposed by PAIE. Considering the example in Figure 2, there are a Life-die event with trigger “kills” and a Life-injure event with trigger “injured”. Then the column header is “Victim (and Victim) died at Place (and Place) killed by Killer (and Killer). Victim (and Victim) injured by Injurer (and Injurer).”, where the first sentence is the prompt for Life-die event, the second sentence is the prompt for Life-injure event, and each underlined part is named after a argument role, acting as the head of a column. There are multiple columns sharing the same argument role for the extraction of multiple arguments playing the same role in an event.
We initialize the representation of column header by feeding each prompt into the encoder in parallel and concatenating the encoding outputs:
EPRj = Encoder(PRj) (5)
ECH = [EPR1 : ... : EPRj : ... : EPRM ] (6)
where PRj is the j-th prompt, M is the number of event type(s).
The i-th row of the table starts with the i-th trigger, followed by a sequence of argument slots Si. The initial representation of the i-th trigger, Eti , is copied from the encoding of the marked text. And the initial representation of argument slots, ESi , is the average of the encoding of corresponding argument roles (in the column header) and the encoding of corresponding trigger markers. We denote all the argument slots as S = {Si}Ni=1.
The initial representations of table components are row-wise concatenated to obtain the initial representation of the table:
ETab = [ECH : Et1 :ES1 : ... :EtN :ESN] (7)

heading: 3.2.3 Non-autoregressive Table Decoding
text: The non-autoregressive decoder iteratively updates the representation of input table via structure-aware self-attention inner the table as well as crossattention between the table and the encoder output.
Structure-aware Self-attention We devise a structure-aware self-attention mask, MTab, so that each element of the table can only attend to the region related to it. Our design is as follows:
• All tokens within the column header attend to each other.
• All tokens within the column header attend to the event trigger(s).
• Each role along with corresponding argument slot(s) attend to each other.
• Each event trigger along with corresponding argument slot(s) attend to each other.
Note that this attention mask is only used for the decoding of slotted table. When computing Hx̃ (Equation 4), we employ normal self-attention.
The cross-attention mechanism is the same as the one in Transformer (Vaswani et al., 2017) and it is only employed to decode the table. When computing Hx̃ (Equation 4), it is skipped.

heading: 3.2.4 Span Selection
text: With the output of table decoding, HTab, we can obtain the final representation of the argument slots, HS ⊂ HTab. We transform each representation vector hsk ∈ HS into a span selector {Φstartsk ,Φendsk } (Du and Cardie, 2020; Ma et al., 2022):
Φstartsk = hsk ⊙w start (8)
Φendsk = hsk ⊙w end (9)
where wstart and wend are learnable weights, and ⊙ represents element-wise multiplication.
The span selector {Φstartsk ,Φendsk } is responsible for selecting a span ( ˆstartk, ˆendk) from the text to fill in the argument slot sk:
logitstartk = Hx̃Φ start sk ∈ RL (10) logitendk = Hx̃Φ end sk
∈ RL (11) scorek(l,m) = logitstartk [l] + logit end k [m] (12)
( ˆstartk, ˆendk) = argmax (l,m): 0<m−l<L scorek(l,m)
where l or m represents the index of arbitrary token within the text.
Note that, there can be more than one argument playing the same role in an event, requiring further consideration for the assignment of golden argument spans during training. Hence, we follow (Carion et al., 2020; Yang et al., 2021; Ma et al., 2022) to fine tune our model with the Bipartite Matching Loss. The loss for an training instance is defined as
P startk = Softmax(logit start k ) (13) P endk = Softmax(logit end k ) (14)
L = − N∑
i=1
∑
(startk,endk)∈δ(Ai) (logP startk [startk]
+ logP endk [endk]) (15)
where δ(·) represents the optimal assignment calculated with Hungarian algorithm (Kuhn, 1955) according to the assignment cost devised by (Ma et al., 2022), and (startk, endk) is the golden span optimally assigned to the k-th argument slot. For an argument slot relating to no argument, it is assigned with the empty span (0, 0).

heading: 3.3 Three Training-Inference Schemes
text: Under the TabEAE framework, there exist three possible training-inference schemes: (1) SingleSingle, train TabEAE to extract single event at a time and infer in the same way; (2) Multi-Multi, train TabEAE to extract all events in parallel and infer in the same way; (3) Multi-Single, train TabEAE to extract all events in parallel and let it extract single event at a time during inference. For the Single mode, only one trigger is marked in the input text; for the Multi mode, all the triggers are marked in the text. Note that, when trained to extract all events in parallel, TabEAE also learn to extract single event, since a great portion of training instances has only one event.

heading: 4 Experiments

heading: 4.1 Implementation Details
text: We implement TabEAE with Pytorch and run the experiments with a Nvidia Tesla A100 GPU. We instantiate the encoder with the first 17 layers of RoBERTa-large (Liu et al., 2019).1 The weight of the self-attention layers and feedforward layers of the decoder is initialized with the weight of the remaining 7 layers of RoBERTa-large. The setting of 17-layer encoder + 7-layer decoder is found to be optimal by our experiment (See Appendix C). Note that the cross-attention part of the decoder is newly initialized in random and we set its learning rate to be 1.5 times the learning rate of other parameters. We leverage the AdamW optimizer (Loshchilov and Hutter, 2017) equipped with a linear learning rate scheduler to tune our model. See Appendix B for details of hyperparameter tuning.

heading: 4.2 Experiment Setups
text: Datasets We experiment with 4 datasets, including ACE05 (Doddington et al., 2004), RAMS (Ebner et al., 2020), WikiEvents (Li et al., 2021) and MLEE (Pyysalo et al., 2012). ACE05 is a sentence-level dataset, while the others are in document-level. The corpora of ACE05, RAMS and WikiEvents mainly consist of news, while the corpus of MLEE lies in the biomedical domain. Besides, the phenomenon of nested event is com-
1We choose RoBERTa-large for a fair comparison with EAE methods based on BART-large, as the two PLMs adopt the same tokenizer and are pre-trained on the same corpus.
monly observed in MLEE, but rare in the other 3 datasets. See Appendix A for a detailed description of the datasets.
Evaluation Metrics Following previous works (Li et al., 2021; Ma et al., 2022), we measure the performance with two metrics: (1) strict argument identification F1 (Arg-I), where a predicted argument of an event is correct if its boundary matches any golden arguments of the event; (2) strict argument classification F1 (Arg-C), where a predicted argument of an event is correct only if its boundary and role type are both correct. All the reported results are averaged over 5 runs with different random seeds.

heading: 4.3 Compared Methods
text: We compare TabEAE with several SOTA methods: • EEQA (Du and Cardie, 2020), a QA-based
EAE model that treats EAE as a machine reading comprehension problem;
• BART-Gen (Li et al., 2021), a seq-to-seq EAE model that generates predicted arguments conditioned on event template and context;
• TSAR (Xu et al., 2022), a two-stream AMRenhanced span-based EAE model;
• PAIE (Ma et al., 2022), a prompt-based EAE model that leverages slotted prompts to obtain argument span selectors;
• DEGREE (Hsu et al., 2022), a data-efficient model that formulates EAE as a conditional generation problem.

heading: 4.4 Main Results
text: The overall performances of compared baselines and TabEAE are illustrated in Table 1. We find that TabEAE (Single-Single) is competitive to previous SOTA models (TSAR, DEGREE and PAIE) on the four benchmarks. This is expected since these models follow the same training-inference scheme and leverage PLMs of the same scale.
In the mean time, TabEAE (Multi-Single) outperforms the SOTA model by 0.6 Arg-I F1 and 1.1 Arg-C F1 on ACE05, by 0.2 Arg-I F1 and 0.4 ArgC F1 on RAMS, by 0.3 Arg-I F1 and 0.7 Arg-C F1 WikiEvents.
As for the MLEE dataset, TabEAE (Multi-Multi) performs better than TabEAE (Multi-Single) and yields 2.5 Arg-I F1 gain, 2.7 Arg-C F1 gain compared to SOTA models.
We analyze the reason behind the results in §5.1.

heading: 5 Analysis

heading: 5.1 The Effect of Training-inference Scheme
text: To analyze the influence of the training-inference scheme, we measure the performances of EAE models with different training-inference schemes on handling instances with different numbers of events. The results are shown in Table 2. We can see that PAIE (Single-Single) and TabEAE (Singlesingle) have similar capacity in extracting standalone events and co-occurring events.
When trained to extract all the events in parallel, the Arg-C F1 of TabEAE on instances with single event increases by 2.17, 0.05, 2.03 and 1.87 on the 4 datasets respectively. However, by letting TabEAE extract all the events in parallel during inference, the Arg-C F1 on instances with multiple events drops by 0.38, 0.79, 0.14 on ACE, RAMS and WikiEvents respectively, while increasing by 3.28 on MLEE. We believe this phenomenon is the result of two factors:
1. The distribution of the number of events per instance. As plotted in Figure 3, there are much more instances with multiple events on WikiEvents and MLEE than on ACE05 and RAMS. Hence, the model is better trained to extract multiple events concurrently on WikiEvents and MLEE.
2. Difficulty. Generally, it is more difficult for a model to extract all the events in one pass. But it is not the case for the MLEE dataset, since there are around 32.9% of the arguments acting as triggers of other events in MLEE, and when all triggers are provided (as in the Multi-Multi scheme), it become easier for the model to extract all the arguments.
When training TabEAE to extract all events in parallel and letting it extract one event at a time during inference, the Arg-C F1 of TabEAE on instances with multiple events increases by 2.3, 0.88,
0.73 on ACE, RAMS and WikiEvents respectively. This is reasonable, since there is a large portion of instances having only one event, which means the model is also well-trained to extract one event at a time under the Multi-Single scheme.

heading: 5.2 Capturing the Event Semantic Boundary
text: We hypothesize that the performance gains yielded by the Multi-Multi and Multi-Single schemes rooted in the stronger ability of TabEAE to capture the event semantic boundary. To verify this, we further measure the model’s ability to capture the event semantic boundary from two points of view: (1) Inter-event Semantic; (2) Inner-event Semantic.
From the view of inter-event semantic, we compare the performance of TabEAE with different training-inference schemes in terms of their ability to extract the arguments of overlapping events (i.e., events with shared arguments). As illustrated in Table 3, when trained to extract all events concurrently, the model’s performance gains of extracting the arguments of overlapping events are much higher than that of extracting the arguments of nonoverlapping events. Specifically, the differences of performance gains are 0.5 Arg-C F1 on ACE05, 0.4 Arg-C F1 on RMAS, 1.8 Arg-C F1 on WikiEvents and 0.9 Arg-C F1 on MLEE. This suggests that TabEAE can better distinguish the semantic boundary between overlapping events.
From the view of inner-event semantic, we compare the performance of TabEAE with different training-inference schemes in terms of their ability to extract arguments of different distances to the triggers. We define the distance here as the head word index of an argument minus the head word index of its corresponding trigger. The experiments are conducted on the document-level datasets WikiEvents and MLEE, where the distance distribution of event arguments is more disperse. The results are plotted in Figure 4. We can observe that, when equipped with the Multi-Multi/Multi-
Single schemes the model’s performance gains of extracting remote arguments are higher than the performance gains of extracting nearby arguments. This means TabEAE gets better at extracting arguments around the event boundary.

heading: 5.3 Ablation Study
text: To verify the effectiveness of different components of TabEAE, we conduct ablation study on the 4 datasets. The results are illustrated in Table 4.
After removing the structure-aware attention mask, the Arg-C F1 scores drop by 1.9, 1.5, 1.1, 1.5 on ACE05, RAMS, WikiEvents and MLEE respectively. This demonstrates the benefit of letting
each table token only paying attention to the table region related to it.
After replacing the pre-computed encodings of the input table with RoBERTa token embeddings, the Arg-C F1 scores drop by 4.2, 3.4, 4.6, 3.9 on the 4 datasets. This proves the necessity of initializing the embeddings of input table with the encodings computed by the encoder.
When constructing the table column header with the concatenation of argument roles instead of
prompts, the Arg-C F1 scores drop by 2.5, 1.8, 1.7 and 2.9 on the 4 datasets respectively. This coincides with the finding by (Ma et al., 2022) that hand-crafted prompts can be of great help to the task of EAE.
When replacing the encoder/decoder of TabEAE with BART encoder/decoder, the model performance degrades by 2.3, 1.7, 1.1, 1.8 on the 4 datasets respectively. The reason behind this degradation should be the uni-directional self-attention employed by BART decoder is not suitable for the decoding of table.

heading: 5.4 Case Study
text: Figure 5 illustrates 2 test cases from ACE05 and MLEE respectively. In the first test case, there exist 2 events triggered by “leaving” and “become”, with a shared argument “Davies”. PAIE incorrectly predicts “London School of Economics” as an argument of the event triggered by “leaving”, which is essentially an argument of the event triggered by “become”. In contrast, TabEAE is able to avoid this mistake, demonstrating a stronger capacity to capture the event semantic boundary.
In the second test case, there exist 3 events triggered by “regulator”, “regulates” and “angiogenesis” respectively. Among them, the event triggered by “angiogenesis” has no argument. For the event triggered by “regulates”, PAIE fails to extract the remote argument “Vascular endothelial growth factor”, while TabEAE correctly extracts it by being aware of the co-occurring event that shares this argument.

heading: 6 Conclusion
text: In this paper, we point out that recent studies on EAE ignore event co-occurrences, resulting in a divergence from main-stream EE research. To remedy this, we highlight the question that “Can EAE models learn better when being aware of event co-occurrences” and explore it with a novel text-totable framework, TabEAE, that can extract multiple event in parallel. By experimenting with 3 traininginference schemes on 4 datasets, we find that when trained to extract all event concurrently, TabEAE can better capture the event semantic boundary and its ability to extract single event gets greatly improved. Our work demonstrates the significance of event co-occurrence for EAE and establishes a new foundation for future EAE research.

heading: 7 Limitations
text: In this section, we summarize the limitations of our work as follows:
• There is still a lot more to explore in terms of event co-occurrence for EAE (e.g., iterative extraction, course learning, etc.). We are unable to cover all in this work and will explore further in the future.
• As demonstrated by our ablation study, the high performance of our model greatly relies on the manual prompts. This limits the application of our model to the scenes where high-quality prompts are unavailable and difficult to construct. To address this, we should look into the area of automatic prompt construction.
• Our work ignores the phenomenon of entity coreference commonly existing in narrative documents. This limits the model’s ability to figure out the underlying relation between entities, which is crucial for the task of EAE. And we will take entity co-references into account in our future works.

heading: Acknowledgments
text: We thank the reviewers for their insightful comments and valuable suggestions. This study is partially supported by National Key R&D Program of China (2021ZD0113402), National Natural Science Foundations of China (62276082, U1813215 and 61876052), National Natural Science Foundation of Guangdong, China (2019A1515011158), Major Key Project of PCL (PCL2021A06), Strategic Emerging Industry Development Special Fund of Shenzhen (20200821174109001) and Pilot Project in 5G + Health Application of Ministry of Industry and Information Technology & National Health Commission (5G + Luohu Hospital Group: an Attempt to New Health Management Styles of Residents).

heading: A Profile of Datasets
text: ACE05 (Doddington et al., 2004)2 is an annotated information extraction corpus of newswire, broadcast news and telephone conversations. We
2https://catalog.ldc.upenn.edu/LDC2006T06
utilize its English event annotation for sentencelevel EAE. We preprocess the data in the same way as Wadden et al. (2019) do.
RAMS (Ebner et al., 2020)3 is a documentlevel EAE dataset, which contains 9,124 annotated events from English online news. Since it is annotated event-wise (each event occupies one instance), we have to aggregate events occurring in the same context into one instance with multiple events. We follow the original train/dev/test data split.
WikiEvents (Li et al., 2021)4 is a document-level EAE dataset, consisting of events recorded in English Wikipedia along with the linking news articles that mention these events. The dataset is also annotated with the co-reference links of arguments, but we only use the exact argument annotations in our experiments.
MLEE (Pyysalo et al., 2012)5 is a documentlevel event extraction dataset with manually annotated abstracts of bio-medical publications written in English. We follow the preprocessing procedure of (Trieu et al., 2020). Since there is only train/test data split for the preprocessed dataset, we employ the training set as the development set.
Statistics Detailed statistics of the datasets are listed in Table 5.

heading: B hyperparameter Settings
text: Most of the hyperparameters follow the same configuration of (Ma et al., 2022). We only tune a few hyperparameters manually for each dataset by trying different values of each hyperparameter within an interval and choosing the value that results in the highest Arg-C F1 on the development set. The trial-intervals and the final hyperparameter configuration are shown in Table 6.

heading: C Number of Encoder/Decoder Layers
text: We have employed the bottom layers of RoBERTalarge as our encoder and the top layers of RoBERTalarge as our decoder. To find the optimal layer allocation, we have tried different settings and recorded the corresponding model performance. This experiment is conduct on ACE and MLEE. The results are plotted in Figure 6. We can observe that the overall performance on the two datasets reaches
3https://nlp.jhu.edu/rams/ 4https://github.com/raspberryice/gen-arg 5http://www.nactem.ac.uk/MLEE/
the peak when there are 17 encoder layers and 7 decoder layers in the model. This observation coincides with recent findings on the areas of machine translation and spell checking that “deep encoder + shallow decoder” is superior to the conventional architecture with balanced encoder-decoder depth (Kasai et al., 2020; Sun et al., 2021).

heading: D Prompt Construction
text: The prompts for ACE05, RAMS and WikiEvents are directly from (Li et al., 2021; Ma et al., 2022), which are manually constructed from the predefined ontology associated with each dataset. For MLEE, we manually construct the prompts in a similar manner, as shown in Table 7.
ACL 2023 Responsible NLP Checklist

heading: A For every submission:

heading: 3 A1. Did you describe the limitations of your work?
text: Section 7.
7 A2. Did you discuss any potential risks of your work? No potential risk is forseen.

heading: 3 A3. Do the abstract and introduction summarize the paper’s main claims?
text: Abstract, Section 1.
7 A4. Have you used AI writing assistants when working on this paper? Left blank.
B 3 Did you use or create scientific artifacts? Section 1, 3, 4.1, 4.2, Software Supplement.

heading: 3 B1. Did you cite the creators of artifacts you used?
text: Section 1, 3, 4.1, 4.2.

heading: 3 B2. Did you discuss the license or terms for use and / or distribution of any artifacts?
text: README (Software Supplement).

heading: 3 B3. Did you discuss if your use of existing artifact(s) was consistent with their intended use, provided
text: that it was specified? For the artifacts you create, do you specify intended use and whether that is compatible with the original access conditions (in particular, derivatives of data accessed for research purposes should not be used outside of research contexts)? README (Software Supplement).
7 B4. Did you discuss the steps taken to check whether the data that was collected / used contains any information that names or uniquely identifies individual people or offensive content, and the steps taken to protect / anonymize it? The datasets that we used are from official and trusted sources.

heading: 3 B5. Did you provide documentation of the artifacts, e.g., coverage of domains, languages, and
text: linguistic phenomena, demographic groups represented, etc.? Section 4.2, Appendix A.
3 B6. Did you report relevant statistics like the number of examples, details of train / test / dev splits, etc. for the data that you used / created? Even for commonly-used benchmark datasets, include the number of examples in train / validation / test splits, as these provide necessary context for a reader to understand experimental results. For example, small differences in accuracy on large test sets may be significant, while on small test sets they may not be. Appendix A.
C 3 Did you run computational experiments? Section 4, 5.
7 C1. Did you report the number of parameters in the models used, the total computational budget (e.g., GPU hours), and computing infrastructure used? The backbone of our model is RoBERTa, which is commonly used and quite familiar to NLP researchers.
The Responsible NLP Checklist used at ACL 2023 is adopted from NAACL 2022, with the addition of a question on AI writing assistance.

heading: 3 C2. Did you discuss the experimental setup, including hyperparameter search and best-found
text: hyperparameter values? Section 4.1, 4.2, Appendix B.

heading: 3 C3. Did you report descriptive statistics about your results (e.g., error bars around results, summary
text: statistics from sets of experiments), and is it transparent whether you are reporting the max, mean, etc. or just a single run? Section 4.2.

heading: 3 C4. If you used existing packages (e.g., for preprocessing, for normalization, or for evaluation), did
text: you report the implementation, model, and parameter settings used (e.g., NLTK, Spacy, ROUGE, etc.)? Section 4.1, Software Supplement.
D 7 Did you use human annotators (e.g., crowdworkers) or research with human participants? Left blank.
D1. Did you report the full text of instructions given to participants, including e.g., screenshots, disclaimers of any risks to participants or annotators, etc.? No response.
D2. Did you report information about how you recruited (e.g., crowdsourcing platform, students) and paid participants, and discuss if such payment is adequate given the participants’ demographic (e.g., country of residence)? No response.
D3. Did you discuss whether and how consent was obtained from people whose data you’re using/curating? For example, if you collected data via crowdsourcing, did your instructions to crowdworkers explain how the data would be used? No response.
D4. Was the data collection protocol approved (or determined exempt) by an ethics review board? No response.
D5. Did you report the basic demographic and geographic characteristics of the annotator population that is the source of the data? No response.

heading: Future Work
text: We are unable to cover all in this work and will explore further in the future. • As demonstrated by our ablation study, the high performance of our model greatly relies on the manual prompts. This limits the application of our model to the scenes where high-quality prompts are unavailable and difficult to construct. To address this, we should look into the area of automatic prompt construction. • Our work ignores the phenomenon of entity coreference commonly existing in narrative documents. This limits the model’s ability to figure out the underlying relation between entities, which is crucial for the task of EAE. And we will take entity co-references into account in our future works