JSEEGraph: Joint Structured Event Extraction as Graph Parsing
Year: 2023

Abstract:
We propose a graph-based event extraction framework JSEEGraph that approaches the task of event extraction as general graph parsing in the tradition of Meaning Representation Parsing. It explicitly encodes entities and events in a single semantic graph, and further has the flexibility to encode a wider range of additional IE relations and jointly infer individual tasks. JSEEGraph performs in an end-to-end manner via general graph parsing: (1) instead of flat sequence labelling, nested structures between entities/triggers are efficiently encoded as separate nodes in the graph, allowing for nested and overlapping entities and triggers; (2) both entities, relations, and events can be encoded in the same graph, where entities and event triggers are represented as nodes and entity relations and event arguments are constructed via edges; (3) joint inference avoids error propagation and enhances the interpolation of different IE tasks. We experiment on two benchmark datasets of varying structural complexities; ACE05 and Rich ERE, covering three languages: English, Chinese, and Spanish. Experimental results show that JSEEGraph can handle nested event structures, that it is beneficial to solve different IE tasks jointly, and that event argument extraction in particular benefits from entity extraction. Our code and models are released as open-source1.

heading: 1 Introduction
text: Event extraction (EE) deals with the extraction of complex, structured representations of events from text, including overlapping and nested structures (Sheng et al., 2021; Cao et al., 2022). While there are existing datasets annotated with such rich representations (Doddington et al., 2004; Song et al., 2015), a majority of current approaches model this task using simplified versions of these datasets or sequence-labeling-based encodings which are
1https://github.com/huiling-y/ JSEEGraph
not capable of capturing the full complexity of the events. Figure 1 shows an example from the Rich ERE dataset (Song et al., 2015) of a sentence containing both nested and overlapping events: “buy” serves as trigger for two overlapping events, transfermoney and transferownership with their respective argument roles, and similarly “made” for two artifact events triggered by the coordination of two GPE entities Canada and USA; at the same time, the event trigger “made” is nested inside the entity span “things made in Canada or USA”. For this example, models based on token tagging (such as the commonly used BIO-encoding) would fail completely when a token contributes to multiple information extraction elements. In this case, the version of the ACE05 dataset widely employed for EE would not fully capture the doubletagged event triggers, by simply disregarding one of the two events, and the nested entity “things made in Canada or USA” would be “things”.
Event extraction is a subtask of a wider set of Information Extraction (IE) tasks, jointly dealing with extracting various types of structured information from unstructured texts, from named entities, relations, to events. There have been continued efforts in creating benchmark datasets that can be used for evaluating a wide range of IE tasks. Both ACE05 (Doddington et al., 2004)2 and Rich
2https://catalog.ldc.upenn.edu/ LDC2006T06
115
ERE (Song et al., 2015)3 provide consistent annotations of entities, relations, and events. While there are clear inter-relations between these different elements, and despite the availability of rich annotations, existing works often deal with individual tasks, such as named entity recognition (NER) (Chiu and Nichols, 2016; Bekoulis et al., 2018) or event extraction (EE) (Yang and Mitchell, 2016; Du and Cardie, 2020; Li et al., 2020). Recently there have been some efforts in jointly modelling multiple IE tasks (Wadden et al., 2019; Lin et al., 2020; Nguyen et al., 2022), but these methods explicitly avoid nested instances.
We here propose to represent events, along with entities and relations, as general graphs and approach the task of event extraction as Meaning Representation Parsing (Oepen et al., 2020; Samuel and Straka, 2020). As shown in Figure 2, in such an information graph, event triggers and entities are represented as nodes; event types, argument roles, and relations are constrained edges; and nested/overlapped structures are straightforwardly represented, since a surface string can be abstracted into an unlimited number of nodes, as illustrated by the two separate nodes for the event triggers for “cost”. Our approach does not rely on ontology- or language-specific features or any external syntactic/semantic parsers, but directly parses raw text into an information graph. We experiment on the benchmark datasets ACE05 (Doddington et al., 2004) and Rich ERE (Song et al., 2015), zooming in on nested structures. Our results show JSEEGraph to be versatile in solving entity, relation, and event extraction jointly, even for heavily nested instances and across three different languages. Abla-
3https://catalog.ldc.upenn.edu/ LDC2020T18
tion studies consistently show that event extraction especially benefits from entity extraction.
The paper is structured as follows: section 2 provides the relevant background for our work, and section 3 further describes the tasks addressed and the datasets we employ, focusing in particular on their complexity, as measured by level of nesting. Section 4 presents the JSEE graph parsing framework and section 5 the experimental setup for evaluating the JSEE parser. Section 6 presents the results of our evaluations and provides a study of the performance for nested structures, as well as an ablation study assessing the effect of joint IE modeling and an error analysis. Finally we provide conclusions (Section 7) and discuss limitations of our work.

heading: 2 Related work
text: Event extraction is commonly approached as supervised classification, even though other approaches relying e.g. on generation (Paolini et al., 2021; Lu et al., 2021; Li et al., 2021; Hsu et al., 2022) or prompt tuning inspired by natural language understanding tasks (Shin et al., 2020; Gao et al., 2021; Li and Liang, 2021; Liu et al., 2022) also are gaining ground. Classification-based methods break event extraction into several subtasks (trigger detection/classification, argument detection/classification), and either solve them separately in a pipeline-based manner (Ji and Grishman, 2008; Li et al., 2013; Liu et al., 2020; Du and Cardie, 2020; Li et al., 2020) or jointly infer them as multiple subtasks (Yang and Mitchell, 2016; Nguyen et al., 2016; Liu et al., 2018; Wadden et al., 2019; Lin et al., 2020). Classification-based joint methods typically apply sequence-labeling-based encoding and extract all event components in one pass, whereas pipeline methods break the problem into separate stages which are performed sequentially. Whereas sequence-labeling approaches cannot distinguish overlapping events/arguments by the nature of the BIO-encoding, pipeline methods may in principle detect these. However, they typically suffer from error propagation and are not equipped to model the interactions between the different event elements (triggers, arguments).
Nested events Some previous work addresses the problem of overlapping or nested arguments in EE. Xu et al. (2020) address overlapping arguments in the Chinese part of the ACE05 dataset and jointly perform predictions for event triggers and argu-
ments based on common feature representations derived from a pre-trained language model. Sheng et al. (2021) propose a joint framework with cascaded decoding to tackle overlapping events, and sequentially perform type detection, event and argument extraction in a Chinese financial event dataset. They deal with cases of both “overlapping events” and “overlapping arguments”, however, their approach may suffer from error propagation due to the cascading approach. Cao et al. (2022) distinguish between overlapped and nested events and propose the OneEE tagging scheme which formulates EE as a word-to-word relation recognition, distinguishing separate span and role relations. OneEE is evaluated on the FewFC Chinese financial event dataset and the biomedical event datasets Genia11 and Genia13. While specifically focusing on nested events, these previous works are limited by focusing only on one language or on specialized (financial/biomedical) domains. In this work we aim to provide a more comprehensive evaluation over two datasets in several versions with increasing levels of structural complexity (see below) and across three different languages.
Joint IE approaches Wadden et al. (2019) propose the DyGIE++ model which approaches joint modeling of IE entities and relations via span-based prediction of entities and event triggers, and subsequent dynamic graph propagation based on relations. They evaluate on ACE05 and Genia datasets and limit their experiments to English only. Their approach is restricted to a certain span width, limiting the length of possible entities. OneIE (Lin et al., 2020) is a joint system for IE using global features to model cross-subtask or cross-instance interactions between the subtasks and predict an information graph. They propose the E+ extension of ACE05 which includes multi-token events (E+) as we do. As in our work, they also present results on Spanish and Chinese as well and develop a multilingual model, but their experiments avoid nested structures, by using only the head of entity mentions and specifically removing overlapped entities. Nguyen et al. (2022) model joint IE in a two-stage procedure which first identifies entities and event triggers and subsequently classify relations between these starting from a fully connected dependency graph; a GCN is employed to encode the resulting dependency graphs for computation of the joint distribution. While the approach is shown to be effective, it is still a pipeline approach which
can suffer from error propagation. Since it relies on sequence labeling for entity/event detection, it cannot identify overlapping entities/event triggers. Furthermore, the approach relies on syntactic information from an external parser and focuses only on English and Spanish in the Light ERE dataset (Song et al., 2015).
Meaning Representation Parsing Meaning Representation Parsing (MRP) (Oepen et al., 2014, 2015, 2020) is a framework covering several types of dependency-based semantic graph frameworks. Unlike syntactic dependency representations, these semantic representations are not trees, but rather general graphs, characterised by potentially having multiple top nodes (roots) and not necessarily being connected, since not every token is necessarily a node in the graph. The semantic frameworks include representations with varying levels of “anchoring” to the input string (Oepen et al., 2020), ranging from the so-called “bi-lexical” representations where every node in the graph corresponds to a token in the input string to a framework like AMR (Banarescu et al., 2013) which constitutes the most abstract and unanchored type of framework, such that the correspondence between the nodes in a graph and tokens in the string is completely flexible. This allows for straightforward representation of nesting and overlapping structures, where multiple nodes may be anchored to overlapping sub-strings. There have been considerable progress in developing variants of both transitionbased and graph-based dependency parsers capable of producing such semantic graphs (Hershcovich et al., 2017; Dozat and Manning, 2018; Samuel and Straka, 2020). Previous research has further made use of AMR-based input representations to constrain the tasks of event extraction (Huang et al., 2018) and more recently joint information extraction (Zhang and Ji, 2021), where an off-the-shelf AMR parser is used to derive candidate enitity and event trigger nodes before classifying pairwise relations guided by the AMR hierarchical structure. While there are clear parallels between the MRP semantic frameworks and the tasks proposed in IE, little work has focused on the direct application of MRP parsing techniques to these tasks. You et al. (2022) is a notable exception in this respect, who presents an adaptation of the PERIN semantic parser (Samuel and Straka, 2020) to the event extraction task. While their work is promising it is limited to only one dataset (ACE05), which does
not contain a lot of nested structures and is further limited to English event extraction only. In this work we extend their approach to the task of joint information extraction, covering both entities, events and relations taken from two different datasets in several versions and for three languages, and further demonstrates the effectiveness of approaching general information extraction from text via graph-parsing and the interpolation of different IE tasks.

heading: 3 Task and Data
text: While the main focus of this work is on event extraction, we hypothesize that our graph-based approach lends itself to dealing with two challenging aspects of current research on this task: the processing of nested and overlapping event structures, and the joint modeling of inter-related IE structures. In the following we quantify the level of nesting in two widely used datasets which contain rich annotations for both entities, events, and relations. We further propose two versions of each dataset with varying potential for nesting, which allows us to focus on this aspect during evaluation.
Event Extraction is the task of extracting events into structured forms, namely event triggers and their arguments. An event trigger is the word(s) that most clearly describes an event, such as “buy”, which evokes a transferownership and an transfermoney event in Figure 1. Event arguments are the participants and attributes of an event, and can be tagged as entities at the same time, as demonstrated in Figure 2.
We use the benchmark datasets ACE05 (Doddington et al., 2004) and Rich ERE (Song et al.,
2015), both containing consistent annotations for entities, relations, and events, for joint evaluation of multiple IE tasks and in multiple languages (ACE05 in English and Chinese, and ERE in English, Chinese, and Spanish). Table 1 summarizes the relevant statistics of the datasets. The inventory of event types, argument roles, entity types and relation types are listed in Table 2. Despite targeting the same IE tasks, from ACE05 to Rich ERE, the annotation guidelines have shifted towards more sophisticated representations, resulting in more complex structures in Rich ERE (Song et al., 2015). Prominent differences between ACE05 and Rich ERE are:
• Entities, and hence event arguments, are more fine-grained in Rich ERE, with 15 entity types, as compared to 7 types in ACE05. In terms of entity spans, ACE05 explicitly marks the head of the entity versus the entire mention, providing the possibility of solving a simpler task for entity extraction and recognizing only the head token as opposed to the full span of the entity in question. This is commonly done for this task in previous work of EE. However, in Rich ERE, the entire string of text is annotated for entity mentions, and heads are only marked explicitly for nominal mentions that are not named entities or pronominal entities. • Event triggers can be double-tagged in Rich ERE, namely one trigger can serve multiple event mentions, giving rise to overlapping events, as shown in Figure 1, while in ACE05, an event trigger only evokes one event. This means that Rich ERE presents a more complex task of event extraction.
We measure the nested instances in ACE05 and Rich ERE as a way to showcase different levels of complexity for extracting entities, relations, and events. More specifically, we quantify nested instances in two versions of each dataset, one using only the head of an entity mention (when it is annotated), and the other with the entire mention text. Following Lin et al. (2020) we dub the version which only marks the head of entities ACE-E+ and
Rich ERE-E+, and introduce two additional versions of the datasets, dubbed, ACE-E++ and Rich ERE-E++ which retain the full annotated mention text span. Nesting is measured between any pair of triggers and entities. Note that our notion of nesting subsumes both overlapping and nested target/entities (Cao et al., 2022), i.e. both full and partial overlap of text spans. As shown in Table 3, Rich ERE features many cases of nested triggers, while these are not found in ACE05, due to the aforementioned double-tagging in Rich ERE (see Figure 1); when only considering the head of an entity, ACE05 exhibits very little nesting, but Rich ERE exhibits a considerable amount of nesting within entities, as well as between entity-trigger. The reason for this is that in Rich ERE, only certain nominal mentions are marked with explicit heads; when the full entity mentions are considered, both datasets are heavily nested.
As mentioned above, this work deals with three IE tasks, as exemplified by Figure 2: entities, relations, and events. Given a sentence, our JSEEGraph framework extracts its entity mentions, relations, and event mentions. In addition to event extraction, we thus target two additional IE tasks in our graph-based model:
Entity Extraction is to identify entity mentions from text and classify them into types according to a pre-defined ontology. For example, in Figure 2,
“district” is an organization (ORG) entity.
Relation Extraction aims to assign a relation type to an ordered pair of entity mentions, based on a pre-defined relation ontology. For example, in Figure 2, the relation between PER “officials” and ORG “district” is orgaffiliation.

heading: 4 Graph parsing framework
text: Our JSEEGraph framework is a text-to-graph parser tailored for EE tasks, additionally with different IE components explicitly encoded in a single graph, as shown in Figure 2. Our framework builds on Samuel and Straka (2020) who developed the PERIN parser in the context of Meaning Representation Parsing (Oepen et al., 2020), as well as (You et al., 2022) who applied PERIN to the task of event extraction. We here extend this parser to the IE graphs shown in Figure 2 in a multilingual setting.
Given a sentence, as the example shown in Figure 3, JSEEGraph encodes the input tokens with the pre-trained language model XLM-R (Conneau et al., 2020) to obtain the contextualized embeddings and further maps the embeddings onto queries; nodes (triggers and entities) are predicted by classifying the queries and anchored to surface tokens via a deep biaffine classifier (Dozat and Manning, 2017); edges are constructed between nodes with two biaffine classifiers, assigning arguments to predicted events and relations to entity pairs. We describe each module in detail in what follows.

heading: 4.1 Sentence encoding
text: We use XLM-R (Conneau et al., 2020) to obtain the contextualized embeddings of the input sequence. To be specific, a trainable weight wl is used to get a weighted sum of representations of different layers, so the final contextual embedding e = ∑L l=1 softmax(wl)el with el as the intermediate output from the lth layer. If an input token consists of multiple subwords, the final contextual embedding will be the weighted sum over all subword embeddings with a learned subword attention.
Each contextual embedding is mapped into q = {q1, · · · ,qn} queries via a linear layer, and further transformed into hidden features h = {h1, · · · ,hn} with a stack of transformer encoder layers, which models inter-query dependency with multi-head self-attention.

heading: 4.2 Node prediction
text: The node prediction module consists of a node label classifier and an anchor biaffine attention classifier.
The node label classifier is a linear classifier classifying each query into a node in the graph, and the node label is predicted by a single-layer feedforward network (FNN). If a query is classified
into “null”, no node is created from this query. Node anchoring, as shown in Equation (1), is performed by biaffine attention (Dozat and Manning, 2018) between the contextual embeddings e and hidden feature of queries h, to map each query (a candidate node) to surface tokens, as shown in Equation (3). For each query, every input token is binary classified into anchor or non-anchor.
Bilinear(X1,X2) = X T 1 UX2 (1)
Biaffine(X1,X2) = X T 1 UX2 +W(X1 ⊕X2) + b (2)
node(anchor) = Biaffine(anchor)(h, e) (3)
Node prediction is complete with queries that are classified into nodes and anchored to corresponding surface tokens. Predicted nodes are either event triggers or entities, labeled as “trigger” or entity type. A dummy node is randomly generated to add to predicted nodes to play the role of <root> node, and always holds the first position.

heading: 4.3 Edge prediction
text: Edge prediction between nodes is performed with two deep biaffine classifiers, as in Equation (6), one to predict edge presence between a pair of nodes and the other to predict the corresponding edge label. To construct edges between nodes, only queries from which nodes have been constructed will be used, and the new hidden features is h′, which are further split into two parts with a singlelayer FNN, as show in Equation (4) and (5).
h′(edge)1 = FNN (edge) 1 (h ′) (4) h′(edge)2 = FNN (edge) 2 (h ′) (5)
edge = Biaffine(edge)(h′(edge)1 , h ′(edge) 2 ) (6)
The edge presence biaffine classifier performs binary classification, deciding whether or not an edge should be constructed between a pair of nodes. The edge label biaffine classifier performs multiclass classification, and the edge label set is the union of argument roles and relation types.

heading: 4.4 Constrained decoding
text: During inference, we apply a set of constraints specifically developed for the correct treatment of event arguments and entity relations based on the graph encoding we define for the information graph (Figure 2): 1) directed edges from the <root> node can only connect to a trigger node, and the corresponding edge label is an event type; 2) directed edges from a trigger node to an entity indicates an event argument, with the argument role placed as edge label; 3) directed edges between a pair of entities indicate an entity relation, and the corresponding relation type is assigned to the edge label.

heading: 5 Experimental setup

heading: 5.1 Data
text: As mentioned above, we evaluate our system on the benchmark datasets ACE054 (LDC2006T06) and Rich ERE5 (LDC2020T18). As mentioned above, Table 1 summarizes the statistics of the preprocessed datasets.
Following Lin et al. (2020), we keep 33 event types, 22 argument roles, 7 entity types, and 6 relation types for both the English and Chinese parts of ACE05. We follow You et al. (2022) in employing the ACE-E++ version of this data, which uses the full text span of entity mentions instead of only the head, as described in section 3 above.
For Rich ERE, we keep 18 out of 38 event types defined in the Rich ERE event ontology 6, 18 out of 21 argument roles 7, 15 entity types, and 6 relation types for English, Chinese, and Spanish. Given no existing data splits, we randomly sample similar proportions of documents for train, development, and testing as the split proportions in ACE05.

heading: 5.2 Evaluation metrics
text: Following previous work (Lin et al., 2020; Nguyen et al., 2021), precision (P), recall (R), F1 scores are reported for the following information elements.
• Entity An entity mention is correctly extracted if its offsets and entity type match a reference entity. • Relation A relation is correctly extracted if its relation type, and offsets of both entity mentions match those of reference entities. • Event trigger An event trigger is correctly identified (Trg-I) if its offsets match a reference trigger, and correctly classified (Trg-C) if its event type also matches a reference trigger. • Event argument The evaluation of an argument is conditioned on correct event type prediction; if a predicted argument plays a role in an event that does not match any reference event types, the argument is automatically considered a wrong prediction. An argument is
4https://catalog.ldc.upenn.edu/ LDC2006T06
5https://catalog.ldc.upenn.edu/ LDC2020T18
6The Rich ERE event ontology defines 38 event types, but for Chinese and Spanish data, only 18 event types are annotated. For consistency, we also use the same 18 event types for the English part.
73 argument roles for the reduced event types are thus excluded.
correctly identified (Arg-I) if its offsets match a reference argument, and correctly classified (Arg-C) if its argument role also matches the reference argument.

heading: 5.3 Implementation detail
text: We adopt multi-lingual training for each dataset for the reported results. Results of monolingual models are listed in Appendix B. Detailed hyperparameter settings and runtimes are included in Appendix A.

heading: 5.4 System comparison
text: We compare our JSEEGraph to the following systems: 1) ONEIE (Lin et al., 2020); 2) GraphIE (Nguyen et al., 2022); 3) FourIE (Nguyen et al., 2021); 4) JMCEE (Xu et al., 2020); 5) EventGraph (You et al., 2022) on the ACE05 dataset. For Rich ERE there is little previous work to compare to; the only previously reported results (Li et al., 2022) for EE only solve the task of argument extraction, using gold entity and trigger information, hence their work is not included in our system comparison.

heading: 6 Results and discussion
text: We here present the results for our JSEEGraph model for the EE task, as well as its performance for the additional IE components: entities and relations, evaluated as described above. We further zoom in on the nested structures identified in Section 3 and assess the performance of our system on these rich structures which have largely been overlooked in previous work on event extraction. We go on to assess the influence of inter-related IE components in an ablation study. Finally we provide an error analysis of our model’s predictions.

heading: 6.1 Overall performance
text: As shown in Table 4, on ACE-E+, our overall results align with other systems. Our JSEEGraph results are especially strong for event argument extraction, with an improvement of around 10 percentage points from the best results of the previous best performing systems in our comparison.
On the newly introduced ACE-E++, despite having more complex structures, with a higher degree of nested structures, the results of JSEEGraph on trigger extraction remain stable. We further note that our results on argument, entity, and relation extraction suffers some loss from highly nested entities, which is not surprising.
From Table 5, we find that the scores on Rich ERE are consistently lower compared to those of ACE05. The double-tagging of event triggers described in Section 3 clearly pose a certain level of difficulty for the model to disambiguate events with a shared trigger. Argument and entity extraction also suffers from more fined-grained entity types.

heading: 6.2 Nesting
text: In order to directly evaluate our model’s performance on nested instances, we split each test set into nested and non-nested parts and report the corresponding scores, as shown in Table 68.
We observe that JSEEGraph is quite robust in tackling nested instances across different IE tasks and languages. On ACE05-E++, more than half of the test data are nested for both English and Chinese, and the results on the nested parts are lower, however consistently comparable with the non-nested parts of the datasets. On Rich EREE+, nested instances make up only a small part of
8ACE05-E+ is not included as it lacks sufficient nested instances.
Lang Nested #sents Trg-I Trg-C Arg-I Arg-C Entity Relation
the test data, but the results are still comparable to the non-nested part. On Rich ERE-E++, about one third of the test data are nested, results of the nested parts are in fact consistently better for trigger, entity, and relation extraction, but inferior for argument extraction.
To conclude, JSEEGraph does not suffer considerable performance loss from nesting among different IE elements, and in many cases actually gains in performance from more complex structures, notably for trigger, entity, and relation extraction. It is clear that the system can make use of inter-relations between the different IE elements of the information graph in order to resolve these structures.

heading: 6.3 Ablation study
text: In order to gauge the effect of the joint modeling of entities, events, and relations, we perform an ablation study where we remove the entity and relation information from our information graph, hence only performing the task of event extraction directly from text. In the reduced information graph, node labels for entity types are removed, and relation edges between entities are also removed. We find that event extraction clearly benefits from entity and relation extraction, especially for event argument extraction. As shown in Table 4 and Table 5, when we train our model only for event extraction, the performance on argument extraction drops consistently across different datasets and languages, but the performance on trigger extraction remains quite stable.

heading: 6.4 Error analysis
text: The experimental results show that JSEEGraph has an advantage when it comes to the task of argument extraction. In a manual error analysis we therefore focus on the errors of event trigger extraction. After a manual inspection of our model’s predictions on the test data, we find that the errors fall into the following main categories.
Over-predict non-event sentences. Our system tends to be more greedy in extracting event mentions, and wrongly classifies some tokens as event triggers even though the sentence does not contain event annotation. For instance, the sentence “Anne-Marie will get the couple’s 19-room home in New York state” (from ACE05) does not have annotated events, but our system extracts “get” as trigger for a Transfer-Ownership event; in this case, however, one could argue that the Transfer-Ownership should be annotated.
Under-predict multi-event sentences When a sentence contains multiple event mentions, JSEEGraph sometimes fails to extract all of the event triggers. For example, this sentence “Kelly , the US assistant secretary for East Asia and Pacific Affairs , arrived in Seoul from Beijing Friday to brief Yoon, the foreign minister” from ACE05 contains a Transport event triggered by “arrived” and a Meet event triggered by “brief”, but our system fails to extract the trigger for the Meet event; in this example, it requires a certain level of knowledge to be able to identify “brief” as an event trigger, which is beyond the capacity of our model.
Wrong event types In some cases, even though our model successfully identifies an event trigger, it assigns a wrong event type. Some event types can easily be confused with each other. In this sentence from Rich ERE, “The University of Arkansas campus was buzzing Friday after a student hurt himself when a gun went off in his backpack in the KUAF building”, an Injure event is evoked by “hurt”, but our model assigns an event type of Attack. Clearly, Injure and Attack events are one typical case of event types that can be easily confused.
Context beyond sentence This error applies specifically to Rich ERE: even though the annotation of events is on a sentence level, annotators were instructed to take into account the context of
the whole article. Our model fails completely when a trigger requires context beyond the sentence. For instance, this sentence “If Mickey can do it , so can we!” is taken from an article describing an on-going demonstration in Disney Land, and “it” is the trigger for a demonstrate event; without the context, our model fails to identify the trigger. These are cases which would require information about event coreference.

heading: 7 Conclusion
text: In this paper, we have proposed JSEEG, a graphbased approach for joint structured event extraction, alongside entity, and relation extraction. We experiment on two benchmark datasets ACE05 and Rich ERE, covering the three languages English, Chinese, and Spanish. We find that our proposed JSEEGraph is robust in solving nested event structures, and is especially strong in event argument extraction. We further demonstrate that it is beneficial to jointly perform EE with other IE tasks, and event argument extraction especially gains from entity extraction.
Limitations
Our work has two main limitations. Firstly, we do not compare our system to previous works on the Rich ERE dataset. This is mainly due to the fact that most work use the light ERE (Song et al., 2015) dataset. We were unfortunately not able to got access to this version of the data9, which is why no experiments were carried out on it.
Secondly, we only experiment with one language model, the multilingual model XLM-R. As our model is language agnostic, and we aimed to test its performance on datasets in different languages, the choice of a multilingual model was obvious. XLM-R has been chosen based on its good performance in other tasks, and to make our work comparable to previous work (You et al., 2022). However, another approach would be to test our model with a selection of language-specific language models.

heading: Acknowledgements
text: This work was supported by industry partners and the Research Council of Norway with funding to MediaFutures: Research Centre for Responsible
9Here we refer to the datasets with LDC codes: LDC2015E29, LDC2015E68, and LDC2015E78 for English ERE, and LDC2015E107 for the Spanish ERE.
Media Technology and Innovation, through the centers for Research-based Innovation scheme, project number 309339.

heading: A Training detail
text: We use the large version of XLM-R available on HuggingFace transformers10 for obtaining contextual embeddings of the input sequence. We use the same hyperparameter configuration for all our models, as shown in Table 7, and weights are optimized with AdamW (Loshchilov and Hutter, 2019) following a warmed-up cosine learning rate schedule.
The training was done on a single node of Nvidia RTX3090 GPU. The runtimes and sizes (including the pretrained XLM-R) of the multilingual models for each dataset are listed in Table 8,
10https://huggingface.co/docs/ transformers/index

heading: B Monolingual training results
text: Apart from multilingual training, we also train two monolingual models for each language, one for joint event extraction with entity and relation and the for event extraction only. Results of monolingual models are summerized in Table 9.

heading: Future Work
text: This work was supported by industry partners and the Research Council of Norway with funding to MediaFutures: Research Centre for Responsible
9Here we refer to the datasets with LDC codes: LDC2015E29, LDC2015E68, and LDC2015E78 for English ERE, and LDC2015E107 for the Spanish ERE. Media Technology and Innovation, through the centers for Research-based Innovation scheme, project number 309339