SEAG: Structure-Aware Event Causality Generation
Year: 2023

Abstract:
Extracting event causality underlies a broad spectrum of natural language processing applications. Cutting-edge methods break this task into Event Detection and Event Causality Identification. Although the pipelined solutions succeed in achieving acceptable results, the inherent nature of separating the task incurs limitations. On the one hand, it suffers from the lack of cross-task dependencies and may cause error propagation. On the other hand, it predicts events and relations separately, undermining the integrity of the event causality graph (ECG). To address such issues, in this paper, we propose an approach for Structure-Aware Event Causality Generation (SEAG). With a graph linearization module, we generate the ECG structure in a way of text2text generation based on a pre-trained language model. To foster the structural representation of the ECG, we introduce the novel Causality Structural Discrimination training paradigm in which we perform structural discriminative training alongside auto-regressive generation enabling the model to distinguish from constructed incorrect ECGs. We conduct experiments on three datasets. The experimental results demonstrate the effectiveness of structural event causality generation and the causality structural discrimination training.

heading: 1 Introduction
text: Event Causality plays an essential role in Natural Language Processing (Girju, 2003). Event Causality Extraction aims to recognize events and their inter-causal relations from text. As shown in Figure 1, given the input text, the model should be able to identify three events, i.e., “suffered”, “invasion” and “destroyed”, and the causal relations in between. Extracting event causality has impactful applications such as question answering (Yang et al., 2022; Ho et al., 2022), event fore-
∗*Corresponding authors.
casting (Hashimoto et al., 2014) and reading comprehension (Berant et al., 2014).
For the purpose of Event Causality Extraction, current methods break down the task into two subtasks, i.e. Event Detection (ED) (Chen et al., 2015; Wang et al., 2019; Lin et al., 2020a) and Event Causality Identification (ECI) (Zuo et al., 2020; Phu and Nguyen, 2021; Chen et al., 2022). Then the solution of Event Causality Extraction is integrating these two sub-tasks. Although such a pipelined method is feasible to a certain extent, two limitations deteriorate the efficacy. First, in the view of task formulation, it over-simplifies the problem as two local extraction processes with ignorance of cross-task dependencies. Such separation hinders feature and knowledge sharing when extracting events and their causal interdependence. It also can result in error propagation. As shown in Figure 1, although the event “abandon” has no causal relations with other events in the context, the
4631
ED model still detects it neglecting the cross-task dependencies with ECI. Second, from the event causality perspective, the events and their causal relations form a global event causality graph (ECG). The pipelined models break the innate structural causality of all events in the context when extracting the events and their inter-relations without capturing the structural interactions within the ECG. For example in Figure 1, events “suffered”, “invasion” and “destroyed” form an ECG. The pipelined models fail to leverage this structural information and then miss the causality between “destroyed” and “suffered” by only counting on these two events themselves. Without such structural understanding, models are likely prone to extract events and causal relations by the perception of superficial linguistic features (Wang et al., 2022a) and make biased predictions.
To bypass the absence of the task dependency brought by pipelining separation, we propose Structure-Aware Event Causality Generation (SEAG), a novel paradigm for Event Causality Extraction. Specifically, SEAG linearizes the ECG with a label semantic enhanced template and then generates the extraction results in a text2text generative format based on a generative pre-trained language model (Raffel et al., 2020). SEAG generates all events and relations in one-pass, avoiding local prediction in either ED or ECI. This end-toend extraction can further mitigate the error propagation. Moreover, regarding the ECG as the output, SEAG enables the reasoning and interactions in the whole structure. Such a structural extraction process maintains the ECG and its semantics intact. To further improve the understanding of the ECG, we adopt Causality Structural Discrimination. We first sample negative events and relations to compose negative ECGs. Then we conduct discriminative learning to foster the model’s awareness of the positive ECG. During this discriminative process, the model can learn to comprehend the in-depth event causality semantic of ECG structures, not learn only on superficial features.
We conduct experiments on three Event Causality Extraction datasets to testify to the effectiveness of SEAG. Evaluation results show that the end-toend extraction of events and their causal relations in a text2text format is effective. Moreover, Causality Structural Discrimination further improves the model’s extraction ability with a better understanding of event structure. We summarize our contribu-
tions as follows: • We propose SEAG for Event Causality Ex-
traction which extracts events and causal relations via end-to-end text2text generation. • We introduce Causality Structural Discrimination to further foster the event structural understanding of our model. • We conduct extensive experiments to test the effectiveness of our model.

heading: 2 Preliminaries
text: Task Formulation. Event Causality Extraction aims to extract events and their inter-causal relations from a text sequence. Formally, given an input text sequence X consisting of n words X = [x1, x2, ..., xn]. Event Ei is represented as multiple consecutive words {xik}. A model should extract all causal triplets (Ei, Ej ,Rij) ∈ S. Ei is the ith event. Rij is the causal relation. The causal triplet (Ei, Ej ,Rij) stands for the existence of a causal relation Rij between Ei and Ej . Conventionally, there are two analogous task settings:
• Directed. The model predicts the directionality of cause and effect events. The type of Rij is binary, i.e. Rij ∈ {CAUSE, EFFECT}1. • Undirected. The model only predicts the existence of causality between events. The type of Rij is unary, i.e. Rij = CAUSAL.
Pipelined Extraction. Pipelined methods break Event Causality Extraction into Event Detection (ED) and Event Causality Identification (ECI). They solve the task as learning the probability P (R|E ,X ) · P (E|X ) which breaks the joint probability of P (E ,R|X ).
Event Causality Graph. An Event Causality Graph (ECG) is a graph G = (E,V). Ei ∈ E is an event and an edge Vij ∈ V denotes there exists a causal relation between Ei and Ej . In the Directed setting, G is a directed acyclic graph while in the Undirected case, G is an undirected graph.
Structural Generation. We model Event Causality Extraction as structural generation. We first compose the causal triplet set S as an ECG. We then learn a model P (G|X ) to identify the ECG in a text2text paradigm given the context X .
1CAUSE and EFFECT are symmetrical. For any Rij , we don’t augment its symmetric relation in Directed setting.

heading: 3 Method
text: Model Overview. Our SEAG first linearizes the ECG G with a label semantic enhanced template. Then it leverages a generative pre-trained language model to predict the results. At last, it improves the ECG structural comprehension via Causality Structural Discrimination. The overview of SEAG is in Figure 2. In the rest of this section, we first detail the graph linearization in Section 3.1. Then we elaborate the generation process in Section 3.2. Finally, we present the Causality Structural Discrimination in Section 3.3.

heading: 3.1 Graph Linearization
text: To extract the ECG G in a generative paradigm, the ECG should be linearized into a sequence Y . This linearization should keep the structural information intact and be as consistent as possible with natural language characteristics.
Considering the appearance order of events in the context is a crucial feature for our task, we infuse the positional information of events in Y . Given an ECG G originating from triplet set S, we sort triplets in S by the head event position in X . If two triplets have the same head event, we arrange them according to the second event.
After obtaining sorted S2, one possible linearization process is to iteratively compose (Ei, Ej ,Rij) into Y , which ends up with Y = [E1, E2,R12, E1, E3,R13, ...]. This template is widely adopted in entity relation extraction (Giorgi et al., 2022; Guo et al., 2022). However, we find
2We only consider annotated relations rather than any relations derived by transitivity.
that this is not suitable for Event Causality Extraction since the relations, often verbs, between events entail dynamic information. The above template violates event causal label semantics and severely deteriorates linguistic structure. In order to inject event causal label semantics and enable making more use of the pre-trained language model, we linearize G as follows: Y = [E1,R12, E2, SEP, E1,R13, E3, SEP, ...] . (1)
SEP is a separator indicator. In this template, relation words act as verbs making the sequence more fluent and close to real natural language sentences.
Modifier Pruning. In the real scenario, an event may consist of a core word and several modifiers (e.g. “magnitude-6.1 earthquake”). These modifiers incur noise when generating the results. Therefore, we prune all events in Y by only keeping the last word to represent the event.
Natural Language Quantifier. Another issue arises when there are events that share the same words, which can be problematic for a generation model as well. We tackle this problem by adding a natural language quantifier to distinguish duplicated event words. Supposing Ei, i = [1, 2, 3] have the same words, we adapt them into “first E1”, “second E2”, “third E3”. In case of more duplicated numbers, the language quantifier goes on.
In sum, we linearize G into Y and denote this linearization process as Y = Linear (G).

heading: 3.2 Structure-Aware Event Causality Generation
text: After obtaining Y , we have adapted this task into a text2text generation P (Y|X ) format. In this sec-
tion, we elaborate on this generation process. Given input X , SEAG outputs Y via the generation process. This generation is modeled by pre-trained generative language model M such as T5 (Raffel et al., 2020) or BART (Lewis et al., 2020), which are pre-trained on large-scale corpus. SEAG first encodes the input X via the encoder Enc of M. The encoding output is H = Enc(X ; θe), which is the encoding hidden states representation. SEAG then generates Y with decoder of M in an auto-regressive process.
P (Y|X ) = ∏
i
Dec(Y<i,H; θd). (2)
We denote the encoder and decoder parameters of M as θM = (θe, θd).
Training and Inference. SEAG is trained on all (X ,Y) pairs by log-likelihood maximization loss:
LG = − ∑
(X ,Y) logP (Y|X ; θM) . (3)
To infer an answer providing input X , SEAG first encodes it with its encoder and then generates Y through the beam search mechanism.
Constraint Decoding. During inference generation, in order to constrain not generating irrelevant words, methods solving entity extraction introduce pointer mechanism (Zeng et al., 2018, 2020), and indices-based generation (Nayak and Ng, 2020). However, to keep the decoding process neat, we only constrain the generated words to be words in X , relation tokens R, and separator SEP. We find this constraint is enough for SEAG to complete Event Causality Extraction.

heading: 3.3 Causality Structural Discrimination
text: Although the above generation process keeps the ECG structural information intact, only trained with generation loss LG (3), the model tends to extract unfaithful ECGs (Zhu et al., 2020). The model is prone to extract events and causal relations on superficial linguistic features. The culprit is the inadequacy of structural event causality comprehension of the model.
One possible solution is to perform contrastive learning which considers a graph as a whole and aims to differentiate positive and negative graphs in a hidden space. However, not all nodes and edges in a negative graph are incorrect.
Therefore, to bypass this dilemma, we introduce Causality Structural Discrimination to improve the model’s understanding of ECG. We first construct
Algorithm 1: Negative ECG Construction. Input :Positive ECG G = (E,V). Input text X .
Hyper-parameters n and L. Output :Constructed negative ECG list G̃.
1 G̃ = [ ] 2 Ẽ = FindNegEvent(X ) 3 N = E ∪ Ẽ 4 for i← 1 to n do 5 l = RandomInt(L) 6 {(Ei, Ej)} = SampleNegPair(N, l) 7 {(Ei, Ej ,Rij)} = AssignRel(N, l) 8 foreach (Ei, Ej ,Rij) do 9 Assert (Ei, Ej ,Rij) /∈ V
10 end foreach 11 G̃ = Compose({(Ei, Ej ,Rij)}) 12 G̃.Append(G̃) 13 end for 14 return G̃
several negative the ECGs. Then we conduct a discrimination process to train the model to be aware of the positive ECG structure.
Negative ECG Construction. Given the positive event node set E in a true G, we first preextract the negative event node set Ẽ via a linguistic toolkit. We denote the total event set as N = E ∪ Ẽ. After that, we sample negative event pairs from N and assign them random relations but guarantee they are not the positive edges in V, i.e. {(Ei, Ej)| (Ei, Ej) /∈ V}. Then we compose these negative edges as a negative ECG G̃.
We repeat the above negative construction process n times, to obtain n negative ECGs. Each time, the number of sampled event pairs is different. We randomize this number between 1 and a maximum threshold of L. Formally, The Negative ECG Construction is shown as Algorithm 1.
Structural Discriminative Training. After acquiring all G̃s, we apply the same linearization process in Section 3.1 to linearize the G̃s. Then we get negative sequences Ỹ = Linear(G̃). We next propose to train the model to be able to distinguish negative ECG G̃ which equals to minimize the probability of Ỹ .
However, adopting structural discriminative training upon a generative model is not simple since not all parts of G̃ are negative. Considering the G̃1 shown in Figure 2, (E1, E6) is a negative edge while E1 is a positive event. One simple solution is to minimize the probability of this edge. Notice SEAG is trained in an auto-regressive way. This solution may confuse the model when adding
probability reduction to E1. The sub-sequence till the step of E1 is the same as that of positive Y since E6 has never shown up yet.
We solve this dilemma by designing the structural discriminative training. For a negative ECG G̃, we assign different optimization objectives to each token after linearization. Considering an edge (Ei, Ej) from G̃, according to the linearization in Section 3.1, it results in a sub-sequence of Ỹ[u:u+4] = [Ei,Rij , Ej , SEP]. If Ei is a negative event, we reduce the probability of both events: if Ei /∈ E :
D(Ei) = − α · log(1− P (Ei|Ỹ<u)) D(Ej) = − α · log(1− P (Ej |Ỹ<u+2)) . (4)
If Ei is a positive event while Ej is a negative event or if Ei and Ej are both positive events but there’s no path between Ei and Ej in G: if Ei ∈ E ∧ (Ej /∈ E ∨ not HasPath(Ei, Ej ,G)) :
D(Ei) = − β · log(P (Ei|Ỹ<u)) D(Ej) = − α · log(1− P (Ej |Ỹ<u+2)) ,
(5) where HasPath(·) is a function to find whether there exists a path between two nodes in a graph3. The motivation here is to train the model to be aware of ECG structural semantics. Firstly, nonconnected events or negative events entail no causality. Secondly, since causality has the property of transitivity, there should exist a causal relation between events linked by a path even if they are not directedly connected. This discriminative learning injects the causality structural knowledge into our model. We treat Rij and SEP tokens as:
D(Rij) = − γ · log(1− P (Rij |Ỹ<u+1)) D(SEP) = − β · log(P (SEP|Ỹ<u+3)) . (6) where α, β and γ are hyper-parameters to control the structural discriminative learning.
We conduct the same optimization for the rest of Ỹ . Therefore, the structural discriminative learning for G̃ is Dis(G̃) = ∑tD(Ỹt). The final structural discriminative training loss is computed over all constructed negative ECGs. Then we conduct multi-task training to train SEAG with LG and LD
L = LG + LD, LD = ∑
i
Dis(G̃i). (7)
3In Undirected setting, deciding whether there’s a path between two nodes equals to determine if these two nodes are in the same component.

heading: 4 Experiments
text: This section first gives the datasets we want to use in Section 4.1. We elaborate on the evaluation metrics for Event Causality Extraction in Section 4.2. The baselines and the implementation details are in Section 4.3 and 4.4 respectively. We finally report the experimental results in Section 4.5.

heading: 4.1 Datasets
text: EventStoryLine. It’s a wildly ECI dataset. It contains 258 documents, 22 topics, 5,334 events, and 1,770, and 3,885 intra- and inter-causal relation pairs (Caselli and Vossen, 2017). Following Gao et al. (2019), we take event pairs annotated with ‘FALLING_ACTION’ as CAUSE relation and ‘PRECONDITION’ as EFFECT. We conduct both Undirected and Directed settings on this dataset. For both settings, we use documents from topics 37 and 41 as the validation set and leave the rest to perform 5-fold cross-validation.
MAVEN-ERE. This is the newest Event Relation Extraction dataset, including causal, temporal, and sub-event relation types (Wang et al., 2022b). It contains 4,480 documents, 103,193 events, and 57,992 causal relation pairs. The causal event pairs are annotated by ‘CAUSE’ or ‘PRECONDITION’, which are both for the CAUSE relation. Therefore, we only conduct the Undirected setting in this dataset and take triplets annotated with ‘CAUSE’ and ‘PRECONDITION’ as gold data. Since this dataset has not published its test set, we conduct in-house validation. We sample 10% of the data from the original training set as the validation set and leave the rest as the training set. We use the original validation set as the test set.
SCITE. This is a CAUSE-EFFECT span detection dataset by extending the annotations of more causal triplets in the SemEval 2010 task 8 dataset (Li et al., 2021). We conduct both Undirected and Directed settings on this dataset.
To handle documents that are longer than the maximum allowed length for T5, we split the documents in both EventStoryLine and MAVEN-ERE via the following method: we identify the two sentences that contain the starting and ending events and gather the sentences in between them. These sentences are all used as the context for the event triplet. All the event triplets of the same sentences are grouped together, and each group is treated as a single data point. So each data point in our dataset
is successive sentences, not the whole document. We testify our method and all baselines under this setting.

heading: 4.2 Evaluation Metrics
text: We use precision (P), recall (R) and F1-score (F1) as the evaluation metrics:
P = TP
TP+ FP ,R =
TP
TP+ FN ,F1 = 2 · P · R P+ R ,
TP, FP and FN are all computed on event triplets. In the Undirected setting, we count an extracted event causal triplet as a True Positive triplet if it has exactly matched two events (regardless of distinguishing cause and effect). In Directed setting, we additionally require the extracted triplet to have the same cause and effect events as the gold triplet.

heading: 4.3 Baselines
text: DB+BERT (Wang et al., 2019; Devlin et al., 2019). This is a typical pipelined event causality extraction baseline. The system first detects events via DMBERT and then identifies the inter causal relations by BERT-base. For Event Causality Identification, we concatenate two event trigger representations from the context encoded by BERT,
then classify the relation type by a MLP layer.
DB+LONG (Wang et al., 2019; Beltagy et al., 2020). This pipelined method is the same as the previous one except we replace the backbone with Longformer-base (Beltagy et al., 2020) for Event Causality Identification.
DB+ERGO (Wang et al., 2019; Chen et al., 2022). The system detects events via DMBERT and then identifies the inter causal relations by the SOTA Event Causality Identification model ERGO. We implement ERGO based on BERT-base.
Seq2Rel (Giorgi et al., 2022) This is a generative entity triplet extraction model. We directly adapt it to Event Causality Extraction and implement it on T5-base for fair comparison.
SCI (Li et al., 2021) This is a joint Cause-Effect extraction model. SCI models Cause-Effect extraction as a BIO tagging task and proposes a multihead self-attention mechanism. Then it aligns the extracted results via a tag2triplet algorithm.

heading: 4.4 Implementation Details
text: We use T5-base (Raffel et al., 2020) as the backbone model. We use AdamW optimizer with 5e-5 learning rate. We apply linear weight decay. The batch size is 8. We train all models until epoch 20 and select the epoch that performs best on the validation set for the test. We don’t use warm-up and label smoothing tricks. We implement all the experiments on Tesla V100 GPU.
For EventStoryLine, we conduct a grid search for threshold hyper-parameters and find n = 10 and L = 2 work the best. In the same way, we find n = 5 and L = 1 in SCITE and n = 3 and L = 1 in MAVEN-ERE are appropriate. We find α = 1, β = γ = 0 suits all three datasets.
We leverage Spacy4 to extract all verbs and nouns which are not the positive events as the negative event set Ẽ. We conduct pilot experiments and find using the word "next" as SEP works well. As well, using relation tokens as Rij ∈ {CAUSE, EFFECT} in directed setting and Rij = CAUSAL in undirected setting effects better.

heading: 4.5 Evaluation Results
text: The results of SEAG on EventStoryLine, MAVENERE, and SCITE are shown in Table 1, Table 2, and Table 4 respectively. SEAG outperforms
4https://spacy.io/
all pipelined models in F1 score on all three datasets of two settings. The superior performance demonstrates extracting event causality by our structure-aware event causality generation effects. SEAG can handle the cross-task dependencies and maintain the ECG structures intact.
Based on the results, we find that SEAG performs better than Seq2Rel. The results first testify the strength of our graph linearization process. This linearization process accounts for event causality semantics and the event dynamic property. Second, the results confirm the benefits of using the suggested Causality Structural Discrimination training. SEAG comprehends the ECG better and can distinguish the positive ECG from negative ones. This ECG semantic understanding of SEAG hinges generates better predictions.
We notice that the gains of SEAG come more from precision scores. That is because SEAG models the cross-task dependencies and filters the events of false causal relations. SEAG maintains the semantic of ECGs and can extract more correct answers which aligns with our intuition.

heading: 4.6 Discussions
text: Ablations. We conduct ablation studies on the EventStoryLine dataset of both Undirected and Directed settings. We list the results in Table 3. SEAG w.o. CSD stands for SEAG without Causality Structural Discrimination. In SEAG w.o. Event Ordering, we shuffle event orders and then compose them into the generative template. SEAG w.o. Modifier Pruning is the model in which we don’t prune event modifiers. The results indicate the effectiveness of Causality Structural Discrimination in both Undirected and Directed settings. SEAG is enhanced by event causality structural knowledge via this discrimination process. Event Ordering is crucial for SEAG especially in the Undirected setting which shows that the generative extraction takes advantage of the ability of sequential ranking
to some extent. Finally, modifier pruning benefits extraction, as training becomes more challenging when events have a large number of words.
Number of Negative ECGs. We conduct experiments on EventStoryLine to inspect the influence of the number of negative ECGs n. The results are given in Figure 3. The performance improves greatly when n increases from 1 to 3 and remains relatively stable until n reaches 10. After that, the performance decreases when n becomes larger. The results provide evidence of the effectiveness of our causality structural discrimination training method. Additionally, the results show that, for most of the datasets, a small number of ECG are sufficient for the Causality Structural Discrimination training. However, there are still some cases where more ECGs are needed.
Low-resource Analysis. To test SEAG’s ability to work with limited resources, we conduct experiments on training models using a subset of the EventStoryLine data. As shown in Figure 4, SEAG performs better in low-resource scenery than other baselines. When there’s only 5% data, Seq2Rel and DB+ERGO fail to extract events and inter-causal relations while SEAG can still identify causality triplets. With the increase of the data sizes, all models get better performances and SEAG outperforms other models in all percentages of the training set. The results demonstrate our intuitions that structure-aware event causality generation can better take advantage of generative pretrained language models. For the same reason, we notice that the Seq2Rel is better than DB+ERGO when there are only very limited data. Besides, our causality structural discrimination training enables SEAG to distinguish from negative structures even with only a small amount of data.

heading: 5 Related Works
text: Event Causality Extraction Current methods for Event Causality Extraction mainly break this task into Event Causality Identification (ECI) and Event Detection (ED). For ECI, Kadowaki et al. (2019) leverages the pre-trained language model to grasp the annotator’s policy. Liu et al. (2021); Cao et al. (2021) incorporate external event knowledge. Tan et al. (2021) augments dataset via generation of counterfactual causal sentences. Zuo et al. (2021a) enhances extracting performance by introducing causal statements. Zuo et al. (2021b) generates synthetic data via a dual-learning framework. Phu and Nguyen (2021) builds document-level graphs and encodes them via a graph neural network. Chen et al. (2022) formulates ECI as a node classification task. Liu et al. (2023) constructs a prompt to inject event knowledge. For ED, Wang et al. (2019) performs weak supervision by applying an adversarial training mechanism. Liu et al. (2016) builds a semi-supervised corpus on FrameNet text. Yang et al. (2019) performs distant supervision via Freebase, Wikipedia, and FrameNet. Huang and Peng (2021) proposes a method to model documentlevel structures. Xu et al. (2021) proposes a Graphbased method to capture the global interaction between entities in a document. Luan et al. (2019) employs an interactive graph-based propagation between events and entities. Lin et al. (2020b) enforces global constraints to the final extraction results. Nguyen et al. (2022) induces a cross-task dependency graph to boost representation learning. Among these methods, we are the first to extract an ECG by end-to-end generation.
Cause-Effect Span Detection Cause-Effect Span Detection is to detect the spans of two units
where the “cause” is the producer of the “effect”. Existing methods model this task as sequence labeling. Dasgupta et al. (2018) uses word-level embeddings and some linguistic features to detect causes and effects. Li et al. (2021) proposes to use Bi-LSTM-CRF with Flair Embeddings. Tan et al. (2022) introduces a news corpus with an annotation schema breaking out the restrictions that only explicit relations apply. The main difference between our work and these methods is that SEAG extracts an ECG consisting of a set of events with their structural inter causal relations rather than identifying two boundaries of “cause” and “effect”.
Generative Triplet Extraction While previous methods extract information jointly (Li et al., 2022) in processes of discrimination, current research also explores using a generative paradigm to solve triplet extraction tasks. Zeng et al. (2018, 2020) introduce copy mechanism into entity relation extraction. Cabot and Navigli (2021); Lu et al. (2022) utilize structural knowledge and label semantics with generative formats. Nayak and Ng (2020) designs indices-based generation for entity relation extraction. Chia et al. (2022) proposes to train with synthetic data in a generative way. Compared to existing generative triplet extraction approaches, we propose to extract the whole ECG structure of the context, which requires a global semantic understanding of all events and their causal relations.

heading: 6 Conclusion
text: We propose a novel Structure-Aware Event Causality Generation (SEAG) for Event Causality Extraction. We model this task as structural generation and design the novel ECG linearization. We also adopt the Causality Structural Discrimination training to foster the model’s understanding of the ECG. We conduct experiments on two settings of three datasets. Results demonstrate that SEAG outperforms the pipelined models for Event Causality Extraction on all datasets.

heading: 7 Acknowledgement
text: Our work is supported by the National Key Research and Development Program of China (Project Number: 2020AAA0109400). we kindly appreciate all the researchers who provide valuable insights, discussions, and comments on this work.
Limitations
As shown in Table 1, 2 and 4, although SEAG outperforms the pipelined models, there is still a gap in performances between EventStoryLine, MAVENERE and SCITE. The performance on SCITE is relatively high than EventStoryLine and MAVENERE. This shows that our model suffers in extracting implicit event causality compared to explicit ones. One potential way to deal with this issue could be introducing an in-context prompt for such relation extraction. We leave the modules for implicit event causality extraction for future work.

heading: A For every submission:

heading: 3 A1. Did you describe the limitations of your work?
text: Section Limitations

heading: 3 A2. Did you discuss any potential risks of your work?
text: This work could be used for some business behaviors.

heading: 3 A3. Do the abstract and introduction summarize the paper’s main claims?
text: Section Abstract and Introduction(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 4.

heading: 3 C1. Did you report the number of parameters in the models used, the total computational budget
text: (e.g., GPU hours), and computing infrastructure used? Section 4.4.
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.4.

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.5, 4.6.

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.4.
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 leave the modules for implicit event causality extraction for future work