Document-Level Event Argument Extraction With A Chain Reasoning Paradigm
Year: 2023

Abstract:
Document-level event argument extraction aims to identify event arguments beyond sentence level, where a significant challenge is to model long-range dependencies. Focusing on this challenge, we present a new chain reasoning paradigm for the task, which can generate decomposable first-order logic rules for reasoning. This paradigm naturally captures long-range interdependence due to the chains’ compositional nature, which also improves interpretability by explicitly modeling the reasoning process. We introduce T-norm fuzzy logic for optimization, which permits end-toend learning and shows promise for integrating the expressiveness of logical reasoning with the generalization of neural networks. In experiments, we show that our approach outperforms previous methods by a significant margin on two standard benchmarks (over 6 points in F1). Moreover, it is data-efficient in lowresource scenarios and robust enough to defend against adversarial attacks.

heading: 1 Introduction
text: Identifying event arguments (i.e., participants of an event) is a crucial task for document-level event understanding (Ebner et al., 2020; Li et al., 2021). In this task, the major challenge is to model longrange dependencies between event triggers and arguments, as an event expression can span multiple sentences (Ebner et al., 2020; Liu et al., 2021; Li et al., 2021). Consider the event expressed by a trigger detonated (type=Attack) in Figure 1. To locate its argument Tartus (semantic role=Place), a model should capture a large context window of three sentences and 178 words to support the reasoning process.
Currently, it still remains an open problem for effectively capturing such dependencies (Liu et al., 2021, 2022c). Prior research has proposed to model
∗Equal contribution.
beyond-sentence clues by incorporating hierarchical encoding mechanisms (Du and Cardie, 2020a), generative paradigms (Li et al., 2021; Ma et al., 2022; Du et al., 2022), and document-level inductive bias (Wei et al., 2021; Pouran Ben Veyseh et al., 2022; Liu et al., 2022b). Nevertheless, such methods do not explicitly characterize the reasoning patterns underlying the document context, which potentially suffers sub-optimal performance. In addition, most previous methods are not interpretable because they rely on black-box neural networks.
In this paper, we propose a new chain-ofreasoning paradigm to address document-level event argument extraction (EAE). As indicated at the bottom of Figure 1, our method seeks to describe the global argument-finding process via a chain of local inference steps. For example, we may use the following chain to locate Tartus: detonated
Target−−−−→ Arzunah Bridge LocatedIn−−−−−−→ Tartus. This chain-of-reasoning paradigm has three clear benefits over previous approaches: First, it naturally captures long-distance dependencies owing to the compositional structure of the reasoning chain.
9570
Second, it involves only local reasoning, which is conceptually easier than performing global reasoning directly. Third, it improves interpretability as the reasoning processes are visible.
Our approach formalizes the reasoning chain as first-order logic (FOL) rules (Cresswell and Hughes, 1996). Concretely, let RL(T , ?) be the query for an event argument fulfilling the semantic role RL (e.g., Place) regarding an event trigger T . We formalize the query as the following FOL rule:
RL(T, ?)← r1(T,B1) ∧ ... ∧ rn(Bn−1, ?)
where the body of the rule (on the right) consists of conjunctive propositions with low-level predicates {ri}n1 and intermediary clue entities {Bi}n−11 . We build a model to automatically generate the rule based on the document context, and then transform the rule into a reasoning chain to locate the event argument. Nevertheless, it is generally challenging to optimize with FOL rules owing to their discrete nature (Qu et al., 2021a). Inspired by work that augments neural networks with FOLs (Li and Srikumar, 2019; Ahmed et al., 2022), we present T-Norm fuzzy logic for relaxation (Hajek, 1998), which leads to an end-to-end training regime.
We verify the effectiveness of our method on two benchmarks (Ebner et al., 2020; Li et al., 2021). According to the results, our approach delivers promising results with this chain reasoning paradigm, such as yielding a 6-point improvement in F1 over models trained using large-scale external resources (§ 6.1). Interestingly, in addition to the performance boost, our approach demonstrates decent robustness, particularly in low-resource scenarios and defending against adversarial noises (§ 7.2). Lastly, we evaluate the interpretability of our methodology using a thorough case study (§ 7.3).
In conclusion, our contributions are three-fold:
• We introduce a new chain-of-reasoning paradigm for document-level EAE, demonstrating clear advantages in capturing longrange dependencies and enhancing interpretability. As a seminal study, our work may motivate more studies in this research line.
• We introduce T-Norm fuzzy logic, which relaxes discrete FOL rules for document-level EAE into differentiable forms; it also demonstrates the prospect of combining the expressiveness of logical reasoning with the generalization capabilities of neural networks.
• We report state-of-the-art performance on two benchmarks, and we have made our code available1 for future exploration.

heading: 2 Related Work
text: Document-Level EAE. Extracting event arguments in a document context is a vital step in document-level event extraction (Grishman, 2019; Ebner et al., 2020). Earlier efforts on this problem explore the MUC-4 benchmark (Chinchor, 1991; Huang and Riloff, 2012), also known as “template filling” because the entire document is about one event. Recent research has focused on events with lexical triggers, intending to extract all arguments for a trigger-indicated event (Ebner et al., 2020; Li and Srikumar, 2019). For capturing the document context effectively, prior studies have explored hierarchical encoding mechanisms, generative perspectives (Li et al., 2021; Du et al., 2022; Ma et al., 2022), document-level inductive biases (Wei et al., 2021; Pouran Ben Veyseh et al., 2022), and external resources (Du and Cardie, 2020b; Liu et al., 2020; Xu et al., 2022; Liu et al., 2022a). Nonetheless, such methods do not explicitly model the underlying reasoning process for capturing long-range dependencies, which therefore risks achieving suboptimal performance. In addition, these methods are not interpretable because they employ neural networks with black-box architectures. In contrast to the previous study, we investigate employing a chain-of-reasoning paradigm to explain the reasoning process, which can effectively model longrange context while retaining interpretability.
Reasoning with FOL Rules. First-order logic (FOL) rules can encode declarative knowledge and play a crucial role in symbolic reasoning (Cresswell and Hughes, 1996). In the era of deep learning, several studies have examined the integration of FOL rules with neural networks for reasoning (termed neural-symbolic approaches), with applications in knowledge base inference (Qu et al., 2021b), text entailment (Li and Srikumar, 2019), question answering (Wang and Pan, 2022), and others (Medina et al., 2021; Ahmed et al., 2022). Our approach is inspired by the work on knowledge base inference, which, to the best of our knowledge, is the first attempt to incorporate FOL rules for reasoning in the context of document-level EAE. Compared to other methods, we investigate the prospect of
1https://github.com/jianliu-ml/ logicEAE
generating rules using neural networks automatically instead of employing expert-written rules as in (Li and Srikumar, 2019; Wang and Pan, 2022). Additionally, unlike those based on reinforcement learning (Qu et al., 2021b), we use T-norms for rule relaxation, resulting in an end-to-end training paradigm with a more stable learning procedure.

heading: 3 Approach
text: Figure 2 presents the overview of our approach, with an example for extracting the argument of a Place role for the event detonated. Let D = {w1, · · · , T, · · · , wN} be a document with N words and an event trigger T , and let RL(T , ?) be a query for the event argument of a semantic role RL. Instead of directly performing the reasoning that may involve high-level processes, our approach represents the query as a FOL rule with conjunctive propositions and low-level predicates {ri}n1 :
RL(T, ?)← r1(T,B1) ∧ ... ∧ rn(Bn−1, ?)
In this way, the body of the rule suggests a reasoning chain: T r1−→ B1 r2−→ · · ·Bn−1 rn−→ ?. We utilize a two-predicate formulation, specifically RL(T, ?) ← r1(T,B) ∧ r2(B, ?), to explain our method, and we describe general cases in § 4.

heading: 3.1 Clue Entity Set Generation
text: In the first step of our method, we create a set of entities from which one may be chosen as an intermediary clue entity to form the reasoning chain (regarding our two-predicate structure). We broaden the notion of “entity” to include any single word in the document for incorporating verb-based cues. To limit the size of the set, we give each word a
score derived from BERT representations (Devlin et al., 2019). For example, the score for wi is:
swi = exp(wTs hwi + bs)∑ j exp(w T s hwj + bs)
(1)
where hwi is the representation of wi, and ws and bs are model parameters. We rank all words based on the sores and select K with the highest sores to form the set, denoted by B = {bi}Ki=1.
To facilitate training and testing, we additionally generate an argument candidate set. In this case, we do not utilize the broad definition of entity because an event argument is defined to be a noun entity (Walker and Consortium, 2005; Ahn, 2006). When ground-truth entities are available (such as in WikiEvents (Li et al., 2021)), we consider the candidate set to be the ground-truth entity set; otherwise, we use external toolkits2 to recognize entities. We denote the argument candidate set by A = {ai}Li=1.

heading: 3.2 FOL Rule Generation
text: Given the entity candidate set B and the argument candidate set A, the next step is to generate two predicates and select related candidates in the sets to form the rule. Here we explain our method for generating predicates regarding a particular entityargument pair (B ∈ B, A ∈ A), and we show metrics for ranking the rules generated by different candidate pairs in § 4. Predicate Representations. In our approach, we assume that there are M atomic predicates with
2We use spacy (https://github.com/ explosion/spaCy) with default settings as entity recognizer.
indecomposable semantics, represented by a predicate set R = {Ri}Mi=1. We give each predicate a d-dimensional vectorized representation and derive a matrix representation U ∈ RM×d forR. For the semantic role RL, we also give it a d-dimensional representation, indicated by rRL ∈ Rd.
Learning Role-Predicate Associations. Given the representations, we first learn a role-topredicate association that indicates which predicates are likely to be generated based on the role solely and disregarding context. We employ autoregressive learning and generate a probability vector a(1)RL ∈ RM indicating the distribution of the first predicate r1 over the predicate setR:
a (1) RL = softmax(UW (1) s rRL) (2)
where W (1)s ∈ Rd×d is a parameter. To learn the distribution of the second predicate r2, we first update the role’s representation by integrating the impact of the first predicate:
r (1) RL = rRL + a (1) RL W (1) a U (3)
and then compute a probability vector a(2)RL ∈ RM :
a (2) RL = softmax(UW (2) s r (1) RL ) (4)
where W (1)a ∈ RM×d and W (2)s ∈ Rd×d are parameters to learn. We can set r1 and r2 as predicates with the highest probability in a(1)RL and a (2) RL , respectively. However, such an approach always generates the same predicates for a semantic role and has a pretty poor performance (7.1). As a solution, we introduce a mechanism for re-ranking the predicates based on contexts.
Context-Dependent Predicate Generation. Let X and Y be two entities. We first compute a probability vector v(X,Y ) ∈ RM denoting the compatibility of (X ,Y ) with each predicate R ∈ R to form a proposition R(X,Y ):
v(X,Y ) = softmax(W (hX ⊕ hY )) (5)
where hX and hY are representations of X and Y , ⊕ is a concatenation operator, and W ∈ Rm×2d is a model parameter. We combine integrate the compatibility probabilities with the role-predicate association probabilities for final predicate generation. Specifically, for an event trigger T , a certain
entity B ∈ B and argument candidate A ∈ A, we generate the following two predicates:
r1 = arg maxR∈R(a (1) RL v(T,B) · sT · sB) (6) r2 = arg maxR∈R(a (2) RL v(B,A) · sB · sA) (7)
where is an element-wise multiplication operator and sX indicates the score3 of an entity X selected to be in the candidate clue entity set B (Eq. (1)). In this way, the generated FOL rule is RL(T,A)← r1(T,B) ∧ r2(B,A), suggesting a reasoning path to reach the event argument A: T r1−→ B r2−→ A.

heading: 4 Optimization and Generalization
text: Optimization with FOL rules is typically challenging due to their discrete nature (Qu et al., 2021a). Here we present T-Norm fuzzy logic for relaxation, which yields an end-to-end learning process.
T-Norm Fuzzy Logic for Relaxation. T-Norm fuzzy logic generalizes classical two-valued logic by admitting intermediary truth values between 1 (truth) and 0 (falsity). For our generated FOL rule RL(T,A)← r1(T,B)∧ r2(B,A), we set the truth values of r1(T,B) and r2(B,A) to be the corresponding scores in Equation (6) and (7), denoted by p1 and p2 respectively. Then, following the Łukasiewicz T-Norm logic, the conjunction of two propositions corresponds to:
p(r1(T,B) ∧ r2(B,A)) = min(p1,p2) (8)
where we re-write it as a metric4: M(T,B,A) = p(r1(T,B) ∧ r2(B,A)) and use it for rule ranking and optimization. Particularly, we enumerate each entity-argument pair (B, A) ∈ B ×A, and denote the one with the highest score by (B̂, Â). We then derive the following loss for optimization:
J (Θ)=− log exp(M(T, B̂, Â))∑ B∈B,A∈A exp(M(T,B,A))
(9)
where Θ indicates the overall parameter set (In the training time, the ground-truth argument is known, and we can directly set the optimal argument to the ground-truth). Even though our method considers each candidate entity and argument, we show with parallel tensor operations, our method runs rivalry as effectively as prior methods (see Appendix A.1).
3We set the scores of sT and sA as 1 as the trigger T and the argument A has no relation with the clue entity set.
4Since r1 and r2 are completely dependent on T , B and A, we do not consider them as arguments of the metric.
Generalization to General Cases. We explain our method using a structure two-predicate structure, but it is easy to adapt it for general cases with any number of predicates. Now assume a n-predicate structure. We first learn a sequence of role-predict association vectors a(1)RL ,a (2) RL , · · · ,a (n) RL using an auto-regressive regime similar to E.q. (3) and (4). Then, we re-rank and generate predicates r1, r2, · · · , rn to form the logic rule. For optimization, we drive the following metric, p(r1∧r2∧· · ·∧rn) = min(p1,p2, · · · , pn), which is similar to E.q. (8) to perform rule ranking and model training.

heading: 5 Experimental Setups
text: Benchmarks and Evaluations. We conduct experiments using two document-level EAE benchmarks: RAMS (Ebner et al., 2020) and WikiEvents (Li et al., 2021). The RAMS benchmark defines 139 event types and 59 semantic roles and gives 7,329 annotated documents; The WikiEvents benchmark defines 50 event types and 59 semantic roles and provides 246 annotated documents. The detailed data statistics are shown in Table 1. Following (Ebner et al., 2020; Liu et al., 2021), we adopt the type constrained decoding (TCD) setup for evaluation, which assumes the events triggers and their types are known. We employ Span-F1 on RAMS and Head-F1 and Coref-F1 on WikiEvents as evaluation metrics, where Head-F1 only examines the head word in an argument and Coref-F1 also takes co-reference linkages between arguments into account (Du and Cardie, 2020a; Li et al., 2021; Wei et al., 2021; Ma et al., 2022).
Implementations. In our approach, we use BERTbase to learn the contextualized word representations (Devlin et al., 2019). The hyperparameters are tuned using the development set. Finally, the size of the entity candidate set K is set to 40, selected from the range [20, 30, 40, 50], whereas the size of the argument candidate set is determined automatically by the external entity recognizer. The number of predicates M is set to 20 out of [10, 15, 20, 25] options. For optimization, we use the Adam optimizer (Kingma and Ba, 2015) with a batch size of 10 from [5, 10, 15, 20] and a learning rate of 1e-4 from [1e-3, 1e-4, 1e-5].
Baselines. For comparison, we consider the following four categories of methods: 1) Traditional approaches, such as BIOLabel (Shi and Lin, 2019),
Dataset Split # Trigger # Arg. # Entity
which views the task as a sequential labeling problem. 2) Global encoding methods, such as QAEE (Du and Cardie, 2020b) and DocMRC (Liu et al., 2021), which form the task as a document-based question-answering problem, and MemNet (Du et al., 2022), which uses a memory to store global event information. 3) Generative methods, such as BART-Gen (Li et al., 2021), which proposes a sequence-to-sequence paradigm for argument extraction, and PAIE (Ma et al., 2022), which employs a set generation formulation. 4) Methods using extra supervisions, for example, FEAE (Wei et al., 2021), which adopts frame-related knowledge, and TSAR (Xu et al., 2022), which utilizes abstract meaning representation (AMR) resources.

heading: 6 Experimental Results
text: In this section, we present the key results, separated by the overall performance and results of capturing long-range dependencies.

heading: 6.1 Overall Performance
text: Table 2 and 3 display the performance of different models on RAMS and WikiEvents, respectively. By adopting the chain-of-reasoning paradigm, our approach outperforms previous methods by significant margins and achieves state-of-the-art performance — 56.1% in F1 on RAMS and 72.3% in Head-F1 and Coref-F1 on WikiEvents. Notably, our model uses no external resources for training, yet it outperforms previous models trained with extensive external resources by over 6% in F1 on RAMS and 4% in Head-F1 (7% in Coref-F1) on WikiEvents. In addition, we discover that the main improvement derives from improved recall, suggesting that learning the reasoning logic rule facilitates locating arguments that were difficult for previous global reasoning methods.

heading: 6.2 Addressing Long-Range Dependencies
text: We then assess the ability of different models to handle long-range dependencies, which is crucial for the document-level task. Table 4 and 5 show results on different argument-trigger distance d — accordingly, our model achieves remarkable performance for addressing long-range dependencies, for example, yielding 10.9%, 15.7%, and 6.7% absolute improvement in F1 for d=-1, d=1, and d=2 on RAMS, respectively. The insight behind the effectiveness is that by adopting the chain-of-reasoning paradigm, our method can utilize clue entities to reduce the distance between triggers and arguments, which therefore facilitates learning with long context. Nevertheless, we also note that our method yields relatively poor performance when the argument is two sentences prior to the trigger (d=-2). One possible reason is that our reasoning chain always starts with the trigger and we do not define
reverse predicates5, which may limit its flexibility. We leave addressing these issues for further work.

heading: 7 Discussion
text: We conduct a series of detailed studies to further verify the effectiveness of our model. To ease discussion, we use the RAMS benchmark as a case.

heading: 7.1 Ablation Study
text: We perform an ablation study to analyze the influence of different components.
Impact of Predicate Generation. Table 6 contrasts our method with methods employing various predicate generation strategies: 1) “w/o Predicate Generation”, which generates the reasoning path directly without predicate generation (in other words, it only cares if there is a relationship between two variables or not, but not the specific relationship). 2) “w/o Role Association”, which removes the role-predicate association learning process in which a predicate is determined purely by the two variables. 3) “w/o CTX Re-Rank”, which
5For example, we may define r−1 as the reverse predicate of r if r(T,B) ⇐⇒ r−1(B, T )
omits the context-dependent predicate re-ranking process in which the predicates are completely generated by the role. According to the results, predicate generation is essential for reasoning; without it, performance drops significantly (23.9% in F1). In addition, the semantic of the role is essential for predicate generation; without it, performance falls by 15.7% in F1. Lastly, learning context-dependent predicate re-ranking is advantageous, resulting in a 3.9% absolute improvement in F1.
Ablation on the Rule’s Length. Table 7 examines the effect of predicate count in a LOC rule, where N (Strict) denotes that we adopt a rule with N predicates precisely, N (Adaptive) denotes that we adopt a rule with N predicates at most and consider the prediction with the greatest score adaptively, N (Ensemble) indicates that we ensemble the results by summing the final score of an argument. The results demonstrate that mandating a fixed number of predicates leads to poor performance, whereas providing the option to choose varying numbers of predicates results in excellent performance. This also implies that the argument-finding process does involve different reasoning patterns. In addition, we do not notice an advantage of N (Adaptive) over
N (Ensemble), indicating that FOL rules may not facilitate ensemble.
Ablation on the Amount of Predicates. Figure 3 examines the effect of the number of predicates on the final performance based on the RAMS development set, as well as their joint effect with the length of the rule (we use the Adaptive setting). According to the results, our method is insensitive to the number of predicates and consistently achieves high performance when the number of predicates is more than 15. In addition, we demonstrate that the number of predicates can be lowered when the rule length is increased (e.g., from two to three). This makes sense, as a longer rule implies a longer reasoning chain, which already has a high degree of intrinsic expressivity. In contrast, for a 1-length FOL rule, the performance is always unsatisfactory even if we increase the number of predicates to increase their diversity.

heading: 7.2 Robustness Evaluation
text: Given that our approach uses FOL rules to capture the essential reasoning pattern, it might be more robust than previous methods to perform reasoning. We validate this assumption by analyzing its performance in low-resource scenarios and for defending against adversarial attacks (Jia and Liang, 2017).
Performance in Low-Resource Scenarios. Figure 4 compares different models in low-resource conditions, which show models training on only partial training data (we report 5-run average to against randomness). Clearly, our approach consistently outperforms other methods, and remarkably, in extremely low resource settings (less than 5% training data), it outperforms PAIE based on prompting with large pre-trained language models and TSAR based on external resources, indicating its effectiveness and generalizability in learning FOL rules for reasoning. The performance improves as more training data becomes available.
Defending Against Adversarial Attacks. Figure 5 shows results in defending adversarial attacks by injecting three forms of noises in a testing example. ATK1: we randomly replace a word in the sentence that contains the trigger with the slot symbol [BLANK]; ATK2: we put the corrupted sentence “The answer is [BLANK]" after the sentence that contains the trigger. ATK3: we insert a sentence “The argument of the [ROLE] is [BLANK]“ after the sentence that contains the trigger, where [ROLE] is replaced by the semantic role on which we focus. Two settings are considered: Attack (Random), where the slot is filled with an argument
that fulfills the same role in other instances. Attack (Gold), where the slot is filled with the groundtruth argument, but we consider it an error if the model predicts the argument in the slot to be the answer since the injected sentence is unrelated to the context. The results show that our approach is excelled at defending against adversarial attacks, especially with the Attack (Random) setting (see Figure 5(a)). One reason is that our method forces predicting arguments that have semantic relations with other entities in the document context, so it is less affected by the isolated injected arguments. Defending the attacks with ground-truth arguments is more challenging (Figure 5(b)), but our method still achieves the best overall performance.

heading: 7.3 Interpretability and Case Study
text: Table 8 examines the interpretability of our method using a case study. By analyzing cases 1), 2), and 3), we suggest that our method can generate specific and context-dependent reasoning rules for the same semantic role. In addition, the reasoning patterns for cases 2) and 3) are similar, where r2 may be interpreted as an Attacker predicate and r4 as a LocatedIn predicate. Case 4) generates the same predicate r2 as cases 2) and 3), which may be interpreted as a Committer predicate for the payment event; it shares a similar semantic as Attacker to an Attack event in cases 2) and 3). Case 5) indicates that our method can capture extremely distant dependencies.

heading: 8 Conclusion
text: In conclusion, we present a new chain reasoning paradigm for document-level EAE, demonstrating clear benefits in capturing long-range dependen-
cies and improving interpretability. Our method constructs a first-order logic rule to represent an argument query, with T-Norm fuzzy logic for endto-end learning. With this mechanism, our approach achieves state-of-the-art performance on two benchmarks and demonstrates decent robustness for addressing low-resource scenarios and defending against adversarial attacks. In future work, we seek to extend our methodology to other tasks requiring modeling of long-range dependencies, such as document-level relation extraction.

heading: 9 Limitations
text: One limitation of our method is that when there are rules of different lengths, the final result is decided by ensemble, not by building a model to generate a single rule with the best length. The second way is more natural and important because figuring out the length of the rule is also a key part of symbolic reasoning. However, it requires more parameterization (for example, the length of the rule could be a parameter) and a more advanced way to optimize. The investigation of the above method is left for future works.

heading: Acknowledgments
text: This work is supported by the National Natural Science Foundation of China (No.62106016), the Open Projects Program of the State Key Laboratory of Multimodal Artificial Intelligence Systems, and the Tencent Open Fund.

heading: A Appendix
text: A.1 Parallelization and Training Time We show methods for parallelizing our approach to identify the optimal entity-argument pair and compare our approach to others in real training time. Given an event trigger T with a query RL(T, ?), a
candidate entity set B = {bi}Ki=1 of size K, and an argument candidate set A = {bi}Li=1 of size L, we first compute the predicate comparability for the event trigger T with each candidate entity in B as follows:
V(T,B) = softmax(W (hT ⊕HB)) (10)
where the concatenation operator of the vector hT ∈ Rd and the matrix HB ∈ RM×d is performed by first broadcasting the vector to the same dimension as the matrix, followed by an elementwise concatenation operation. This results in a M by K matrix: V(T,B) ∈ RM×K . To unify illustration, we add an extra dimension to V(T,B) to represent the event trigger, which thus makes it a high-order tensor V(T,B) ∈ RM×1×K . In a similar fashion, we compute the predicate comparability for each entity-argument pair inB andA and obtain a high-order tensor V(B,A) ∈ RM×K×L:
V(B,A) = softmax(W (HB ⊕HA)) (11)
where the concatenation operator of two matrices is implemented by first broadcasting each matrix into a dimension of K by L by d and then concatenating each element individually.
Given V(T,B) and V(B,A), we can apply a softmax operator6 on their first dimension to identify the best-fitting predicates for each trigger-entity and entity-argument pair and only keep the maximum values as their scores. Suppose the results are two matrices O1 ∈ R1×K and O2 ∈ RK×L for V(T,B) and V(B,A) respectively. We then apply the T-Norm relaxation for the conjunction operator as follows:
O = min(Ô1, Ô2) (12) 6We omit the computation produces in E.q. (6) and (7)
because they have no effect on parallelization.
where Ô1 ∈ R1×K×L and Ô2 ∈ R1×K×L, which have the same dimension, are the tensor broadcasting results of O1 and O2 respectively, and min indicates an element-wise minimization operator. Finally, by examining the element with the highest value in O, the optimal entity and argument pair can be determined. For example, if O1,4,2 is the element with the highest values, then (B4, A2) corresponds to the optimal entity-argument pair.
In Table 9, we compare the real training time for each model on the RAMS dataset. All experiments are conducted on a 16G-memory NVIDIA Tesla P100-SXM2 Card to ensure a fair comparison. From the results, we can see that our model maintains a comparable time to earlier methods such as QAEE and is faster than many models such as FEAE and DocMRC, where FEAE has two base models for knowledge distillation and DocMRC uses external data to pretrain the model.
A.2 Cases of Adversarial Examples
In this section, we provide a specific adversarial example to enhance comprehension. Our original document with annotations for the event trigger (which is underlined) and an argument (which is in bold) fulfilling a semantic role of Place is:
“[S1] People we meet who are displaced took shelter in schools, in unfinished buildings and other facilities, some of which are simply skeleton infrastructure. [S2] Most people with whom I spoke
have been displaced for at least two to three years. [S3] Many of them see no prospect of returning home any time soon, either because fighting is still going on, or because for many of them, their homes and land have been damaged, burned or destroyed. [S4] Every single family is affected, and most communities in Aleppo, and beyond, have reached the limit of their endurance. [S5] Aid workers have said there is just enough fuel to keep generators, bakeries, and hospitals running for a month.”
We show the generated noisy examples in Table 10, and note that if the model identifies the noisy arguments presented in the table as the result, it should be counted as an error.
ACL 2023 Responsible NLP Checklist

heading: A For every submission:
text: 3 A1. Did you describe the limitations of your work?
Section 9
3 A2. Did you discuss any potential risks of your work? Section 9
3 A3. Do the abstract and introduction summarize the paper’s main claims? Section 1
7 A4. Have you used AI writing assistants when working on this paper? Left blank.
B 7 Did you use or create scientific artifacts? Left blank.
B1. Did you cite the creators of artifacts you used? No response.
B2. Did you discuss the license or terms for use and / or distribution of any artifacts? No response.
B3. Did you discuss if your use of existing artifact(s) was consistent with their intended use, provided 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)? No response.
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? No response.
B5. Did you provide documentation of the artifacts, e.g., coverage of domains, languages, and linguistic phenomena, demographic groups represented, etc.? No response.
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. No response.
C 3 Did you run computational experiments? Section 6 and 7
3 C1. Did you report the number of parameters in the models used, the total computational budget (e.g., GPU hours), and computing infrastructure used? Section 5
The Responsible NLP Checklist used at ACL 2023 is adopted from NAACL 2022, with the addition of a question on AI writing assistance.
C2. Did you discuss the experimental setup, including hyperparameter search and best-found hyperparameter values? No response.
3 C3. Did you report descriptive statistics about your results (e.g., error bars around results, summary statistics from sets of experiments), and is it transparent whether you are reporting the max, mean, etc. or just a single run? Section 6 and 7
3 C4. If you used existing packages (e.g., for preprocessing, for normalization, or for evaluation), did you report the implementation, model, and parameter settings used (e.g., NLTK, Spacy, ROUGE, etc.)? Section 5
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: The investigation of the above method is left for future works