ULTRA: Unleash LLMs’ Potential for Event Argument Extraction through Hierarchical Modeling and Pair-wise Self-Refinement (2024)

Abstract: Structural extraction of events within discourse is critical since it avails a deeper understanding of communication patterns and behavior trends. Event argument extraction (EAE), at the core of event-centric understanding, is the task of identifying role-specific text spans (i.e., arguments) for a given event. Document-level EAE (DocEAE) focuses on arguments that are scattered across an entire document. In this work, we explore open-source Large Language Models (LLMs) for DocEAE, and propose ULTRA, a hierarchical framework that extracts event arguments more cost-effectively. Further, it alleviates the positional bias issue intrinsic to LLMs. ULTRA sequentially reads text chunks of a document to generate a candidate argument set, upon which non-pertinent candidates are dropped through self-refinement. We introduce LEAFER to address the challenge LLMs face in locating the exact boundary of an argument. ULTRA outperforms strong baselines, including strong supervised models and ChatGPT, by 9.8% when evaluated by Exact Match (EM).

heading: 1 Introduction
text: Event extraction, a long-standing and prominent information extraction task, aims to extract event structures consisting of core information elements (e.g., “who” did “what” to “whom”, “when”, “where”, and “why”) from unstructured texts (Mourelatos, 1978; Riloff, 1996; Walker et al., 2005). Event-centric understanding is of great importance, not only in its inherent merits, but also due to its role as an information-rich representation for downstream tasks like summarization (Marujo et al., 2017; Li et al., 2021a), recommendation (Lu et al., 2016; Li et al., 2020a), and news narrative understanding (Jin et al., 2022; Zhang et al., 2022; Keith Norambuena et al., 2023). Event argument extraction (EAE), a crucial and challenging step in Event Extraction, is the task of identifying
∗ Work done during XFZ’s internship at Bloomberg AI.
span is between March and May this year . ULTRA can correct itself with the LEAFER module, and drops less-pertinent candidates like “July”. In contrast, both Flan-UL2 and ChatGPT fail to extract since sentence [0] includes a strong distractor, “Wed 15 Sep 2021”.
role-specific text spans (i.e., arguments) for a given event (Nguyen et al., 2016; Kar et al., 2020).
Existing EAE research mainly focuses on sentence-level understanding (Chen et al., 2015; Du and Cardie, 2020b; Lu et al., 2021) on the prevalent ACE 2005 dataset (Walker et al., 2005). Yet, in news, events are usually described at the document level, and arguments are typically scattered across an entire article (Hamborg et al., 2019). Thus, there is a pressing need to systematically study the document-level EAE (DocEAE) task, since sentence-level EAE systems fail to accommodate long-distance dependency (Ebner et al., 2020), cross-sentence inference (Li et al., 2021b) and multi-answer (Tong et al., 2022) problems intrinsic to DocEAE. Traditional supervised approaches consume large-scale annotations (e.g., Zheng et al., 2019; Pouran Ben Veyseh et al., 2022, more than 30,000 annotated articles required) in order to
8172
excel, and the state-of-the-art EAE model requires manual designs of templates for each argument role (Hsu et al., 2022). These approaches are not only costly but also not generalizable, since they cannot handle emerging events (Yang et al., 2023).1 Recently, there has been a notable surge in applications of Large Language Models (LLMs) for NLP tasks, especially closed models such as Claude (Bai et al., 2022), PaLM (Chowdhery et al., 2022) and GPT-4 (OpenAI, 2023). The most relevant works to ours are Li et al. (2023); Han et al. (2023), but they only perform preliminary analysis by assessing ChatGPT’s capability of solving IE tasks. Meanwhile, there is no prior research that has attempted to leverage LLMs to tackle DocEAE. In our preliminary investigation, we identified at least three challenges that arise when employing closed LLMs: 1) hitting endpoints incurs substantial costs and poses scalability challenges at inference; 2) undesirable prompt hacking is needed to ensure performance (Ouyang et al., 2022); 3) given the nature of news, where information is spread across the article, LLMs suffer from the positional bias issue (a.k.a, lost in the middle; Hou et al., 2024; Liu et al., 2024). Detailed literature review is in Appendix A.
To this end, we propose an easy-to-use framework that Unleashes LLMs’ potential for event argument exTRAction through hierarchical modeling and pair-wise refinement, dubbed ULTRA. ULTRA, built on Flan-UL2 (Tay et al., 2022), first sequentially reads text chunks of a news article to generate a candidate argument set. ULTRA then learns to drop less-pertinent candidates through self-refinement by means of pairwise comparison.
1COVID-19 became an emerging topic since 2020 (Wang et al., 2020; Zhang et al., 2021), but not covered in traditional EE corpora (Walker et al., 2005; Ebner et al., 2020).
The LEAFER module, LEArning From ERrors, is implemented to improve boundary identification of an argument span. Finally, we augment ULTRA with a document-level extractor to capture arguments that require reasoning of the full article.
Results on DocEE benchmark (Tong et al., 2022) show that ULTRA outperforms strong baselines, e.g., previous state-of-the-art supervised models and ChatGPT, by at least 9.8% and 7.5% when evaluated by the Exact Match (EM) and Head Noun Phrase Match (HM) metrics, but at a considerably reduced monetary cost. Existing methods only cater to improving precision, while our ULTRA significantly boosts recall as well (39.4 EM vs. 25.2). Besides better performance and lower costs, ULTRA also doesn’t require specialized prompts, alleviates the positional bias issue, and grants stronger generalizability.

heading: 2 Methodology
text: Taking as input a news article d, ULTRA first reads text chunks of the article d sequentially to generate a candidate argument set {a} (§2.1), upon which ULTRA drops less-pertinent candidates through self-refinement and returns {af} (§2.3). A LEAFER module, LEArning From ERrors (§2.2), is introduced to tackle LLMs’ incapability of locating exact boundaries of argument spans, and yield {a′}. ULTRA+ is a variant augmented with extractions by a document-level extractor to capture information that requires full-article discourse analysis (e.g., extracting “why”-type arguments; §2.4). Figure 1 depicts the overall framework of ULTRA+.
Putting it all together, we produce two versions: ULTRA-base and ULTRA-long, which consume 5-sentence and 15-sentence windows in layer-1, respectively. Instead of conducting costly prompt hacking (Ouyang et al., 2022), we adopt an existing instruction from NIv2 (Wang et al., 2022) and tailor
it to our use case, named aligned instruction. We show designed task instructions {I} in Table A4.

heading: 2.1 Layer-1: Local Understanding
text: Given a document d, we first divide d to multiple k-sentence passage windows with a step size of ⌊k2⌋, denoted as {w1, w2, · · ·, wl}. We adopt a fixed-window-size approach instead of a fixed-sequence-length approach (Devlin et al., 2019; Sun et al., 2019; Pappagari et al., 2019), which might cut a sentence in the middle, to allow each local extractor to comprehend each passage window in its entirety. Instantiated with Flan-UL2, the local extractor takes as input the concatenation of a task instruction (I), a passage window (wi), and a question written in natural language (qj), e.g., What is the “date” for the “Tsunami” event? We prompt the local extractor in a zero-shot fashion2
and explicitly instruct it to generate N/A if the input passage does not contain any relevant answer. After deduplication, we end up with a candidate argument set {a}j for each question qj .3
2.2 LEAFER Module LLMs are deemed to have a knack for extracting relevant information (Li et al., 2023; Han et al., 2023), but we notice that LLMs still suffer from pinpointing the exact boundary of an argument span. Specifically, as shown in Figure 1, local extractions ({a}) contain an apparently sensible answer “March and May” to the question “What is the ‘Date’ for the ‘Droughts’ event?”, which is lexically similar but semantically different from the ground-truth answer “between March and May this year”. To this end, we introduce a new module, LEAFER, short for LEArning From ERrors, to alleviate this issue. The LEAFER module is a small-scale LM trained on errors produced by Flan-UL2. The trained LEAFER is employed to generate a judgment, which is to explicitly inform what is wrong and why it is wrong. The insightful judgment enables ULTRA to rectify boundaries of candidate arguments in {a} and produce {a′}.
To support the training of LEAFER, we construct a LEAFER Bank using the few-shot training set of 50 annotated articles. Specifically, we prompt the same layer-1 local extractor to extract arguments for each (text chunk, question) input pair using the approach outlined in §2.1. For each input pair, we match the machine-extracted argument
2We observe that few-shot prompting yields inferior results 3For brevity, we omit the subscript j in main contents.
span with the corresponding ground-truth answer to produce a judgment automatically. Then, LEAFER is fine-tuned on this LEAFER Bank and trained to generate a judgment given an input pair and the machine-extracted answer. In this study, we instantiate the LEAFER module with Flan-T5-large.

heading: 2.3 Layer-2: Self-Refinement
text: While LEAFER addresses the semantic drift and imprecise boundary issues, ULTRA exhibits an over-generation issue due to window-based local extractors. Seeing recent success leveraging an LLM as a judge (Zheng et al., 2023; Wang et al., 2023a), we propose a self-refinement module that allows ULTRA to reflect on candidate arguments ({a′}), and drop less pertinent candidates through pairwise ranking. There are usually two variations of LLM-as-a-judge: single-answer grading and pairwise comparison. As studied in Zheng et al. (2023) and observed in our preliminary study, we find that single answer grading cannot serve as an effective refinement judge since 1) absolute scores are extremely inflated and a considerably large portion of scores are close to 1 on a scale of 0 to 1; and 2) single answer grading fails to capture subtle differences between a specific pair. Therefore, in layer-2, we leverage ranking by pairwise comparison (Jamieson and Nowak, 2011; Lee and Vajjala, 2022; Jiang et al., 2023) to obtain the final argument set, {af}, by first prompting Flan-UL2 to pick a better answer between a candidate pair, then ranking all candidates by aggregating pairwise-comparison scores, and finally filtering out candidates at low positions. To support dynamic filtering, we decide on |{af}| as follows:
|{af}| = ⌊1 + log2(|{a′}|)⌋ (1)
The pairwise comparison produces a non-trivial score and catches nuanced differences, but is still trapped by the positional bias (Ko et al., 2020; Wang et al., 2023a; Liu et al., 2024) and lack of scalability due to the quadratic growth in pairwise comparisons. To mitigate these two issues, we resort to calibration and pruning, respectively.
Calibration. In layer-2, positional bias refers to a model’s tendency to assign a higher score to an option at a particular position in a list, which has been shown to exist in ChatGPT/GPT-4 (Wang et al., 2023a). The issue is manifested as Flan-UL2 biasing towards an earlier displayed candidate. Drawing on the Contextual Calibration (Zhao et al., 2021), as demonstrated in eq. (2), we calibrate the
raw probabilities of each option between a pair to reveal the truthful probabilities, i.e., P(ai|d).
P(ai|d) = softmax(g(P(ai|d, I; θ),P(ai|I; θ))) (2) where P(ai|·) denotes the probability of an argument ai being preferred given a certain input, and d and I denote the article and task instruction (see Table A4 for the instruction). Following Zhao et al. (2021), g(x,y) is a calibration function that can be instantiated as additive, g(x,y) = x − y, or multiplicative functions, g(x,y) = xy . Using our designed comparison instruction (I), we compute the prior probability P(ai|I; θ) by leaving the {article} field blank, while we fill in a concrete article when computing raw probability P(ai|d, I; θ). With this calibration, we manage to alleviate the positional bias induced by the input template I and the innate bias of LLMs, θ. Pruning. To tackle the scalability issue in which the number of comparisons grows quadratically, we prune the candidate set {a′} upfront to shrink its size. Specifically, we design a strategy that aligns with the fundamental principles of news journalism, wherein journalists prioritize the presentation of crucial information at the outset of a news story, known as the “inverted pyramid” structure (Pottker, 2003; Hamborg et al., 2019; Liu et al., 2022). That is, we consider up to 5 earliest candidate arguments, where the earliness of an argument is determined by its first occurrence in a news article. Our pruning strategy empirically reduces the number of subsequent pairwise computations by half. We also find that pruning itself can improve precision, even without pairwise comparisons. This further illuminates the validity of our designed pruning strategy.
2.4 Ensembling: ULTRA+
The ensembling technique consistently improves performance for a wide array of NLP tasks (Wang et al., 2019; Ganaie et al., 2022; Pitis et al., 2023; Jiang et al., 2023). LLM-Blender attempts to ensemble various LLMs on output space (Jiang et al., 2023), which prohibitively demands many computational resources. Instead, we suggest a simpler and more efficient approach: merging outputs by both ULTRA and a document-level argument extractor, which reads the full article and a question when extracting arguments. This way, we manage to combine the benefits of both local (high recall) and document-level (high precision)
extractions. Similar to Labrak et al. (2023); Han et al. (2023),
we also observe marginal improvement on the dev set when providing in-context examples. To reduce inference-time overhead, we prompt the document-level extractor in a zero-shot manner.

heading: 3 Experiments
text: We conduct experiments on the DocEE dataset (Tong et al., 2022), which contains 27,485 news articles, classified into 59 event types, and 356 argument roles. We use the cross-domain setting in our experiments since it only contains a minimally annotated target training set (i.e., 50 articles) which can best assess models’ generalizability in the wild. Specifically, its test set contains 1, 955 news articles covering 10 different event types, and each article is annotated with ∼ 6.5 arguments. We use the same data split and processed texts as in the original DocEAE dataset for a fair comparison.
In terms of evaluation metrics, we follow the literature on document-level event argument extraction (Du and Cardie, 2020a; Tong et al., 2022), and adopt Exact Match (EM) and Head Noun Phrase Match (HM) as evaluation metrics. EM assesses if an extracted argument exactly matches a reference, while HM is a relaxed metric that concerns if there is an overlap of head words of noun phrases between extractions and references. Baselines. We compare ULTRA against three model families to comprehensively study extraction performance and monetary costs. The first model family, Supervised ML, characterized as using human annotations as the supervision signal to train small-scale LMs, consists of EEQA (Du and Cardie, 2020b) and Ontology QA (Tong et al., 2022). Ontology QA, an extension of EEQA, incorporates argument ontology knowledge, which achieves the SOTA performance for DocEAE. Second, we compare with ChatGPT using different prompting techniques, given its popularity and impressive capability. We follow Li et al. (2023) and prompt ChatGPT to extract spans for all argument roles in one pass. For single-question variant, we modify the original prompt to instruct ChatGPT to extract span(s) for only one argument role at a time. Motivated by Wang et al. (2023b), which generates a chain-of-thought rationale before summarizing an article, we build the CoT-ChatGPT variant by replacing the summarizer in Wang et al. (2023b) with an argument extractor. The last family involves prompting a document-level extractor
with different instructions, utilizing Flan-UL2 as its backbone for a fair comparison. This serves two purposes: test sensitivity to different custom instructions that are designed from scratch; and illuminate the effectiveness of Aligned Instructions.

heading: 4 Results and Analysis
text: Our proposed ULTRA achieves the best F1 scores across the board (Table 2), especially compared to two strong baseline families, Supervised ML and Closed LLM, at a considerably reduced monetary cost in training and inference. ULTRA also significantly improves the EM recall by 56% over the best-performing baseline model (39.4 vs. 25.2), demonstrating robust generalizability considering ULTRA’s exposure to at most 5-shots per event type.
Seeing the relatively low EM scores, we explore the errors and include case analyses in Table A1. We provide cost estimation in Appendix B. Using ChatGPT for DocEAE. Despite the common flaw of outputting seemingly coherent assertions that are false in reality, known as hallucination (Manakul et al., 2023; Feldman et al., 2023), we recognize another issue, which seems to be less studied in the NLP community, that answer spans extracted by ChatGPT are verbose (Zheng et al., 2023; Chen et al., 2023a). This explains the reason why ChatGPT achieves the best HM scores in the literature since longer generations are more likely to contain relevant information, while the EM is low due to the nature of verbosity.
Further Study on Window Size. Despite ULTRA-base and ULTRA-long achieving almost identical EM F1 scores, they present different
extraction properties, wherein ULTRA-base reaches the highest recall while ULTRA-long is more balanced. In this subsection, we specifically look into the extraction property of the Layer-1-only variant of ULTRA. Figure A1 shows the performance trend with the window size. We notice that precision steadily goes up while recall consistently goes down by increasing the window size. We attribute this trend to the fact that a larger window size leads to fewer text chunks being fed into ULTRA. It is also worth mentioning that the overall F1 performance plateaus after a window size of 15. This observation underscores a key aspect of ULTRA: its flexibility for accommodating various extraction criteria. For instance, when the objective is to harvest the most relevant information, opting for a smaller window size appears to be a favorable choice. Conversely, selecting a larger window is advisable if precision is the core of a product or the target audience consists of vulnerable populations susceptible to misinformation.

heading: 5 Conclusion
text: In this study, we present ULTRA, a cost-effective event argument extraction framework built upon an open-source LLM. Concretely, ULTRA reads a sequence of text chunks from an article, the outputs of which are refined through self-refinement. With minimal annotation efforts, a LEAFER module is implemented to improve argument span boundary identification. Our results show the superiority of ULTRA in comparison to supervised ML and closed LLMs. We further showcase the customizability of ULTRA to cater to different extraction criteria.
Limitations
GPU resources. Despite ULTRA managing to reduce monetary cost, it still requires advanced computational resources. Specifically, we deploy ULTRA on a single NVIDIA A100 (80GB) with significant CPU and memory resources. Due to budget constraints, we truncate an input if it is longer than 2, 048 tokens.
DocEE benchmark. Due to the limited large-scale, well-regarded datasets for the DocEAE task, we only conduct experiments on one benchmark – DocEE dataset (Tong et al., 2022). DocEE, though covering 59 event types and 356 argument roles, is still not comprehensive. Therefore, our results might not truthfully reveal the generalizability of ULTRA. In future work, we will explore how to examine the true generalizability of developed systems in the wild.

heading: Acknowledgements
text: The authors thank the Bloomberg AI team for their support of this work. We would like to thank Shijie Wu for hardware support and discussions on FLAN-UL2 setup configurations. We appreciate Igor Malioutov, Daniel Preoţiuc-Pietro and Umut Topkara for their insightful inputs and helpful feedback at different stages of this project. We also thank ACL ARR reviewers for their helpful feedback.

heading: A Related Work
text: A.1 Event Argument Extraction (EAE) Most event argument extraction research has experimented on the 2005 Automatic Content Extraction (ACE 2005; Walker et al., 2005), while recent work delves into domain-specific areas such as biomedical texts (Zhao et al., 2020; He et al., 2022), legal documents (Li et al., 2020b; Shen et al., 2020), partisan contents (Liu et al., 2023), morality-bearing contents (Zhang et al., 2024), and conversations (Srivastava et al., 2023).
Existing work primarily focused on the sentence-level event understanding task. Methods can be categorized under one of the three following approaches: sequence labeling (Chen et al., 2015; Nguyen et al., 2016) where Lin et al. (2020) further constrains the inference with global features; question answering (Du and Cardie, 2020b), which includes ontology knowledge about argument roles; and generative information extraction (Paolini et al., 2021; Lu et al., 2021). Particularly, DEGREE reformulates EAE as template-based conditional generation, and archives impressive performance on various benchmarks (Hsu et al., 2022). Yet, it demands huge annotation efforts, which require one template for each argument role, and is therefore not generalizable. In this work, we are seeking to improve EAE performance with general instructions instead of argument-specific templates.
Lately, there has been an increasing interest in document-level EAE (DocEAE), since events are usually described at the document level and arguments are usually scattered across multiple sentences (Sundheim, 1992; Hamborg et al., 2019; Tong et al., 2022). For example, RAMS (Ebner et al., 2020) and MEE (Pouran Ben Veyseh et al., 2022) both define “document” as a 5-sentence segment. In contrast, WikiEvents (Li et al., 2021b) and DocEE (Tong et al., 2022) present full articles and focus on argument extractions for the main event. In this work, we use DocEE as a benchmark since it features broad coverage of event types in the news domain. Methodology-wise, Du and Cardie (2020a) and Tong et al. (2022) handle DocEAE by extending sentence-level labeling and question-answering approaches, respectively. Li et al. (2021b) frames DocEAE as template-based conditional generation in the same vein as the sentence-level generative approach. Unfortunately, none of the aforementioned methods tackle the argument-scattering challenge; instead, they treat
a full article as if it were an extended sentence. Zheng et al. (2019) is the first work to address this issue by modeling DocEAE as an entity-centric graph, which is further augmented with a “tracker” module to capture the interdependency among arguments and events (Xu et al., 2021). Nonetheless, the “tracker” is insufficient due to its limitation of not considering the results of later extractions when processing earlier ones. On the contrary, our ULTRA bridges the gap through the implementation of a self-refinement module, which is grounded in pairwise comparison and functions akin to a bi-directional tracker.
A.2 Using Large Language Models for IE
The past years have witnessed the rise of transformer architecture (Vaswani et al., 2017), paving the way for a series of powerful language models. Recent studies have evinced that scaling up model sizes yields more powerful abilities (Hoffmann et al., 2022), and unlocks an emergent ability that is not present in smaller models (Wei et al., 2022a). These large language models (LLMs), which often exceed a hundred billion parameters, are typically closed systems (i.e., no open checkpoints available). Notable examples include PaLM (Chowdhery et al., 2022), Claude (Bai et al., 2022), and GPT-4 (OpenAI, 2023). Numerous methods are also developed to enhance LLMs’ reasoning and problem-solving capabilities, such as chain-of-thought (Wei et al., 2022b), self-correction (Pan et al., 2023), and external tool (e.g., Python interpreter) augmentation (Gao et al., 2022; Chen et al., 2023b) among others.
ChatGPT,4 one of the most burgeoning LLM, is trained on high-quality conversation datasets using reinforcement learning from human feedback (RLHF; Christiano et al., 2017), has led to a transformative wave. The most relevant to our research is leveraging ChatGPT for the information extraction task (Li et al., 2023; Han et al., 2023), including named entity recognition (Xie et al., 2023), temporal relation extraction (Yuan et al., 2023), event detection (Sharif et al., 2024), and event argument extraction (Wei et al., 2023). These papers’ primary focus is either benchmarking ChatGPT’s performance, which shows inferior results to specialized supervised IE systems (Li et al., 2023; Han et al., 2023), or curating new benchmark datasets (Gao et al., 2023). In contrast,
4https://chat.openai.com/
0 5 10 15 20 25 30 35
20
30 40 EM sc or es
0 5 10 15 20 25 30 35
40
50
60
70
HM sc
or es
Metric P R F1
Window size (unit: # of sentences)
Impact of window size on Layer-1 performance
Figure A1: The impact of window size on the performance of the Layer-1-only variant of ULTRA. Results are based on dev set. With the window size, precision goes up while recall goes down since fewer chunks are fed into ULTRA. The F1 performances plateau after the window size of 15.
our proposed ULTRA framework outperforms strong baselines, including the previous state-of-the-art (SOTA) models, capitalizing on the effectiveness of our designed LEAFER and self-reflection modules. Besides, to the best of our knowledge, we are the first to exploit LLMs for the DocEAE task.

heading: B Cost Estimation
text: In addition to models’ extraction performance, Table 2 also presents the cost estimation of each model family. We briefly introduce the criteria used when estimating monetary costs. The training cost is mainly associated with document annotations.6
Regarding inference, we consider the expenses incurred in hitting API endpoints.7 Per Tong et al. (2022), both EEQA and Ontology QA are trained on 22K articles, each costs $0.9, totaling $20, 000. Based on ChatGPT pricing,8 the base cost is $0.004/1K tokens. Processing each article and then producing answers would consume 5K to 50K tokens on average, depending on the input mode. The test set contains 2K examples, so the total cost is around $40 to $400. For the Flan-UL2 baseline and our ULTRA, each only needs annotations of up to 50 articles, for the training of the LEAFER module. It is noteworthy that ULTRA enables cost-effective scaling at inference, while ChatGPT might face budget constraints.
6Here, we omit the sunk cost incurred due to pre-training. 7The server maintenance cost is considered low (∼ 0). 8https://azure.microsoft.com/en-us/pricing/
details/cognitive-services/openai-service/
News title: Experts: Oregon seems to be in ’perpetual drought’ News body: [0] Experts say Oregon is becoming less resilient to drought as fewer seasons of abundant rain and snow prevent it from bouncing back from hot and dry conditions. [1] Wheat at the farm of Nicole Berg in Washington’s Horse Heaven Hills shows signs of a drought in May 2021, with a damaged curled head. [2] Anna King The Capital Press reports that Larry O’Neill, state climatologist at Oregon State University, says the current drought is “historically significant,” with about three-quarters of the state experiencing conditions considered “extreme” or “exceptional.” [3] However, the state is actually in the fourth year of below-average precipitation, which has exacerbated the drought during “unprecedentedly” high temperatures this summer, O’Neill told the Oregon Water Resources Commission on Wednesday. [4] “We don’t recover from droughts as quickly as we did previously,” he said. “We seem to be in perpetual drought.” [5] Parched soils were insufficiently recharged with moisture over winter and spring, which has harmed vegetative growth, including crops and forage, said Ryan Andrews, a hydrologist at the Oregon Water Resources Department, which is overseen by the commission. [6] Reservoir and stream flow levels are below average across most of the state, reducing water available to irrigators, while ranchers have sold off livestock due to poor rangeland conditions, he said. [7] Fish die-offs followed the June heat wave in several important rivers basins, including the Willamette, Grande Ronde, John Day and along the North coast, Andrews said. [8] The state would need plentiful rain and snow during the autumn to begin emerging from the drought, but the long-term federal climate forecast doesn’t anticipate such a reversal, he said. [9] “We’re anticipating conditions to persist, at least in the near term.” Between March and July, the state received less rain than during any comparable period in nearly a century, O’Neill said. [10] “The dry spring and summer is one of the main contributing factors to why this drought has become so severe.” [11] An IBIS explores what habitat remains on the Klamath Basin’s wildlife refuges during a drought year that is exacerbating water resources challenges in this arid region. [12] Devan Schwartz / OPB The area under “extreme” and “exceptional” drought ratings is the most extensive in Oregon since the start of the U.S. Drought Monitor more than 20 years ago, he said. [13] The most severe “exceptional” level of drought now seen across one-fourth of the state would normally be expected to occur every 20 to 50 years, O’Neill said. [14] However, droughts are judged by historical standards, so the concept of such “recurrence intervals” grows less valid as dry periods become more common, he said. [15] “It’s going to take some time to get used to the new normal we’re experiencing right now,” O’Neill said.
Argument role 1: Related Rivers or Lakes ULTRA: {“the Willamette, Grande Ronde, John Day and along the North coast”} Ground-truth: {“Willamette, Grande Ronde, John Day and along the North coast”}
Argument role 2: Cause ULTRA: {“fewer seasons of abundant rain and snow”} Ground-truth: {“The dry spring and summer”, “fewer seasons of abundant rain and snow”}
Argument role 3: Areas Affected ULTRA: {“Oregon”} Ground-truth: {“Willamette, Grande Ronde, John Day and along the North coast”, “Washington”}
Table A1: Case analyses of ULTRA outputs for a Droughts event. For argument role 1, the system output is considered an exact match with the ground-truth annotation, since stop words are removed at evaluation time. For argument role 2, our ULTRA achieves 100% precision but 50% recall since the model fails to capture both reasons that caused the drought. For argument role 3, the system output is completely wrong.
Model Configuration EM HM
P R F1 P R F1
ULTRA-base Layer-1 only 22.5 42.5 29.4 50.3 77.7 61.1 Layer-1 + LEAFER 22.6 43.4 29.7 50.7 78.4 61.6 Layer-1 + LEAFER + Layer-2 29.0 34.5 31.5 61.8 70.3 65.8
ULTRA-long Layer-1 only 29.2 34.0 31.4 63.3 68.9 66.0 Layer-1 + LEAFER 29.2 34.5 31.6 63.4 69.7 66.4 Layer-1 + LEAFER + Layer-2 32.3 30.5 31.4 68.4 65.9 67.1
Table A2: Ablation study results of variants of ULTRA. ULTRA-base manages to improve recall by over-generating candidate answers, while the over-generation problem is redressed by self-refinement (layer-2) through pairwise comparison. ULTRA-long does not confront the over-generation issue, thus, layer-2 does not contribute significantly to the performance as in ULTRA-base. Best results are bold.
ID EM HM
Instruction template P R F1 P R F1
0 26.5 18.9 22.0 67.6 45.2 54.2 The following is a news article about a “{e_type}”:\n{news}\nBy reading the above article, determine the “{arg_role}” for the “{e_type}”. 1 29.5 19.5 23.5 71.3 47.3 56.8 Here is a news article:\n{news}\nThe above news article is about a “{e_type}”. Identify “{arg_role}” for the “{e_type}” from the news article. 2 29.0 16.2 20.8 71.8 42.8 53.7 Read the following news article, and then answer questions. Context: {news} \nQuestion: Identify “{arg_role}” for this “{e_type}” event. 3 25.5 18.6 21.5 64.6 43.1 51.7 Given the following news about a “{e_type}”:\n{news}\nThe “{arg_role}” for the “{e_type}” is 4 27.6 15.7 20.0 70.5 47.5 56.8 Given the following news about a “{e_type}”:\n{news}\nWhat is the “{arg_role}” for the “{e_type}”?
Table A3: Performances of each individual custom instruction. {e_type}, {arg_role} and {news} are placeholders to be filled with event type, argument role and news content, respectively. Flan-UL2 is considerably sensitive to the input instruction, and even with a tiny change in the question, the model performance varies a lot, as manifested by contrasting instruction ID 3 and 4.
Stage Instruction
Layer-1 local extractor Given a passage from a news article about {e_type}, select the tokens representing information about ’{arg_role}’ or answer ’N/A’ if the question is not answerable. \nPassage: {sentence}. Question: What is the ’{arg_role}’ for the ’{e_type}’ event?
Layer-2 comparator Given a news article about ’{e_type}’ and two candidate spans, decide whether ’{arg1}’ is a more acceptable ’{arg_role}’ than ’{arg2}’ for the ’{e_type}’ event. \nArticle: {article} \n For this ’{e_type}’ event, is ’{arg1}’ a more acceptable ’{arg_role}’ than ’{arg2}’? Answer yes/no.
Document-level extractor Given a news article about {e_type}, select the tokens representing information about ’{arg_role}’. \n Context: {news}. Question: What is the ’{arg_role}’ for the ’{e_type}’ event?
Table A4: Instructions designed for each stage in ULTRA. The document-level extractor is utilized in the ensembling mode of ULTRA (§2.4), and serves as the Flan-UL2 baseline (§3). These aligned instructions are adapted from task 179 (participant extraction) in NIv25 (Wang et al., 2022).
Extraction Ground Truth Judgements
N/A N/A Yes. something N/A No, you should generate “N/A” N/A something No, you should generate “[GT]”. something something Yes. something something longer OR something shorter You are almost there! The right answer should be “[GT]”. anything something No, you should generate “[GT]”.
Table A5: Designed template-based judgments used to train the LEAFER module in order to address the boundary identification issue. We categorize the (extraction, ground truth) pairs into six classes. Here, “anything” refers to a generated extraction that is completely off, and “[GT]” acts as a placeholder to be replaced with a specific ground-truth argument.

heading: Future Work
text: In future work, we will explore how to examine the true generalizability of developed systems in the wild