EVIT: Event-Oriented Instruction Tuning for Event Reasoning (2024)

Abstract: Events refer to specific occurrences, incidents, or happenings that take place under a particular background. Event reasoning aims to infer events according to certain relations and predict future events. The cutting-edge techniques for event reasoning play a crucial role in various natural language processing applications. Large language models (LLMs) have made significant advancements in event reasoning owing to their wealth of knowledge and reasoning capabilities. However, smaller instructiontuned models currently in use do not consistently demonstrate exceptional proficiency in managing these tasks. This discrepancy arises from the absence of explicit modeling of events and the interconnections of them within their instruction data. Consequently, these models face challenges in comprehending event structures and semantics while struggling to bridge the gap between their interpretations and human understanding of events. Additionally, their limitations in grasping event relations lead to constrained event reasoning abilities to effectively deduce and incorporate pertinent event knowledge. In this paper, we propose EventOriented Instruction Tuning to train our LLM named EVIT specializing in event reasoning tasks. Specifically, we first propose a novel structure named event quadruple which contains the structure and semantics of events and is complete in the event representation. We then design event-relation learning based on the structures. We encapsulate the learning into the instruction-tuning formulation to better stimulate the event reasoning capacity of our model. We design a heuristic unsupervised method to mine event quadruple from a large-scale corpus. At last, we finetune a Llama model on our Event-Oriented Instruction Tuning. We conduct extensive experiments on event reasoning tasks on several datasets. Automatic and human evaluations demonstrate EVIT achieves competitive performances on event reasoning. **Corresponding authors.

text: Findings of the Association for Computational Linguistics ACL 2024, pages 8966–8979 August 11-16, 2024 ©2024 Association for Computational Linguistics
**Corresponding authors.

heading: 1 Introduction
text: Events are instances or occurrences that form the basic semantic building units encompassing the meanings of Activities, Accomplishments, Achievements, and States (Vendler, 1957). By employing advanced techniques and models, event reasoning aims to enable machines to comprehend the mechanism of real-world event evolution (Tao et al., 2023a). Under this ultimate goal, event reasoning consists of several key sub-objectives, including the understanding and reasoning about a diverse range of event inter-relations, and predicting events pertaining to certain relations. Reasoning events forms the foundation of sorts of NLP applications such as recommendation systems (Yang et al., 2020), and question answering (Souza Costa et al., 2020).
In recent times, substantial research efforts are dedicated to instructing-tuning language models to acquire the abilities for zero-shot inference such as Flan-T5 Alpaca (Taori et al., 2023), Vicuna (Chiang et al., 2023), WizardLM (Xu et al., 2023), and Dolly (Conover et al., 2023). These models have shown the potential to enhance the language models with versatile instruction-following capabilities through fine-tuning various instruction datasets. Nonetheless, in the training of these models, the instruction-tuning data involved did not explicitly model events and their inter-relations. Consequently, these models perform inferiorly on most event reasoning tasks. The limitations observed in the instruction-tuned models stem from several fundamental factors. Firstly, these models display an inadequate understanding of event structures and semantics and show discrepancies between the model’s interpretation and human comprehension of events. Secondly, the models exhibit deficiencies in comprehending the relations between events, resulting in insufficient event reasoning capabilities and the inability to effectively infer and integrate relevant event knowledge. Based on the perfor-
8966
mances, instruction-tuning smaller language models exhibit poorer performance when contrasted with large language models (LLMs) such as ChatGPT and Bloomz-175B (Muennighoff et al., 2022).
To address these obstacles, we present EVIT which is trained on our novel Event-oriented Instruction Tuning. In our method, we incorporate explicit event modeling and event relation comprehension. Specifically, to enhance the comprehension of the structure and semantics of events, we first design a novel structure named event quadruple. This event-centric structure contains two events, their relation, and the background information where the fact holds. The event quadruple covering contextualized events and their inter-relation knowledge would improve the model’s conceptions of events. Based on the event quadruple, we develop an event-relation learning paradigm. We train EVIT to predict the tail events of event quadruple in both generation and discrimination manners. We further encapsulate this training process into instruction tuning with generated instruction templates. It can better stimulate the model’s abilities to conduct event-related reasoning and associate event knowledge. To implement our training, we construct event quadruple from a large-scale textual corpus. We design a heuristic negative events mining algorithm to construct candidate events for discriminative event-relation training. We finetune Llama by our event-oriented instruction tuning.
We conduct extensive experiments to testify to the effectiveness of EVIT. We first evaluate the performance of EVIT across 8 tasks of event reasoning which are not seen during training. Among these tasks, four are held-in tasks, involving relations explicitly handled during training, while the remaining four tasks are held-out tasks. Results of automatic and human evaluations show that EVIT outperforms other instruction-tuned models.
We summarize our contributions: • We propose a novel event-oriented instruction
tuning paradigm that may also shed light on other event-oriented training. We first design an event-centric structure named event quadruple. Based on event quadruple, we develop the event-relation learning. We then encapsulate the objectives into instruction-tuning.
• We construct an event-oriented instructiontuning dataset encompassing integrated and diversified data of events in terms of both syntax and semantics with rich relation knowledge.
• We conduct extensive experiments on 8 datasets for testing. Results show the effectiveness of EVIT. Code and Dataset are available on https://github.com/TZWwww/EvIT.

heading: 2 Preliminaries

heading: 2.1 Event Definition
text: An event is something that happens involving participants (Mitchell, 2005), which may have correlations with others. Formally, let E be an event consisting of several participants or arguments. Two events Eu and Ev can have a relation R ∈ SR. SR is the universe set of event inter-relation which could cover abundant relation types such as temporality, causality, condition, prerequisites, and counterfactual (Zhang et al., 2020).

heading: 2.2 Event Reasoning
text: Event reasoning aims to comprehend, deduce interrelated events, or anticipate forthcoming occurrences (Tao et al., 2023a). It requires to process of queries to deduce events pertaining to specific relations (Han et al., 2021). These relations encompass causality, temporality, counterfactual scenarios, and intent. Distinct interconnections between events demand diverse reasoning proficiencies.
Building upon relational reasoning, the advanced objective of event reasoning revolves around predicting future events (Zhao, 2021). This intricate task mandates the model to grasp events and their relations, possess substantial event-related knowledge and an understanding of event-evolution mechanisms, and ultimately integrate these aspects to prognosticate future events.

heading: 3 EVIT Methodology

heading: 3.1 Overview
text: Our primary aim is to achieve an improved model EVIT that excels in event reasoning tasks. An overview of the EVIT training and evaluation process is illustrated in Figure 1. To accomplish this objective, we begin by proposing Event-Oriented Instruction Tuning. Within this training framework, we introduce an event-centric structure denoted as event quadruple along with event-relation learning. This learning is then integrated into the instructiontuning process. Subsequently, we establish the method of construction of the event quadruple and the training dataset to execute our novel training approach outlined.

heading: 3.2 Event-Oriented Instruction Tuning
text: Large language models are first pre-trained on enormous unsupervised data and then fine-tuned on supervised data with instructions (Taori et al., 2023; Chiang et al., 2023; Xu et al., 2023; Conover et al., 2023; OpenAI, 2023). However, during all stages of training, existing LLMs are not explicitly trained to understand events and their inter-relations. This leads to several deficiencies. First, they exhibit a lack of comprehension of the structure and semantics of events. This makes a difference between the conceptualization of these models and human understanding. Second, they exhibit deficient apprehension of relations between events. When executing event reasoning, they prove unable to adequately ascertain and integrate knowledge pertaining to the events in question. This shows that these LLMs may not be able to achieve good performance in event reasoning.
In an endeavor to mitigate these limitations, we initially introduce a novel structure referred to as event quadruple, which encompasses comprehensive event knowledge and their inter-relations. Subsequently, we establish event-relation learning based on this framework, ultimately encapsulating this approach into instruction tuning.
Event Quadruple An event quadruple Q is:
Q = (C, Eh,R, E t), (1)
in which Eh is the head event, E t is the tail event, and R is the relation between them. C is a paragraph of context describing the background information of both events. The event quadruple Q entails rich semantic and syntactic information of events since each E describes an event occurring
unit that aligns with human understanding. Besides, Q is rich in event relational and structural knowledge since it precisely captures event inter-relations. Finally, Q extracts the necessary information for the above events from the context. Contextual information is important for an accurate understanding of an event, because, in the absence of contextual information, the understanding of the event is prone to ambiguity. In summary, using the event quadruple Q to capture different aspects of events may reduce the risk of event misunderstanding and enhance the conceptions of structure and semantics of the events, thereby improving the accuracy of achieving event reasoning.
Event-Relation Learning Our next objective is to leverage the event quadruple to stimulate the event reasoning abilities of LLMs. The motivation is to enhance the model’s understanding of event semantics, event composition, and the interpretation of event relations. We require the model learns to generate the tail event E t based on the head event Eh, the context C and according to the relation R:
E t = M (Eh,R, C). (2) M is the model to be trained. Through learning to generate events, the model’s comprehension of event semantics and structure was stimulated, enabling it to accomplish event reasoning tasks in a manner more aligned with human understanding. Concurrently, this process necessitated the model’s apprehension of inter-event relationships, empowering it to associate pertinent event knowledge in order to conduct event relational inference. Moreover, the model learns to draw proper information from the context to answer event reasoning questions more precisely.
In order to enhance the model’s event understanding capability and reduce instances of hallucination, we introduce an additional step involving multiple-choice discrimination:
E t = M (Eh,R, C| D). (3)
D is the set of candidate events including the ground-truth tail event E t and also several negative candidates. This learning process further reinforced the model’s comprehension of events and their interrelationships, enhancing the model’s discriminative capabilities of event knowledge.
Instruction-Tuning Encapsulation Incorporating event-relation learning into equations Eq. (2) and (3) can be approached by a basic method of merging the two training procedures into generation training (Tao et al., 2023b). However, this approach does not successfully capture the human strategies employed in these tasks, resulting in an absence of unsupervised event reasoning abilities. In contrast, instruction-tuning techniques achieve alignment and knowledge enhancement (Taori et al., 2023; Chiang et al., 2023). Thus, we integrate event-relation learning into instruction tuning as our means to attain the desired goal.
In instruction-tuning, each dataset includes an instruction, an input, and a response. Our method involves encapsulating the input notation Q within an instruction, adhering to a predefined template. Initially, we derive instruction templates by querying ChatGPT. Our exploration of event-relation learning encompasses |SR| relations, approached through two distinct formulations: generation and discrimination. Furthermore, we account for situations in which the context C might be absent. Consequently, we require total amounts to |SR|×2×2 variations of instruction templates. For each kind, we ask ChatGPT to list 100 prompts with the query. We depict a query for discrimination instruction templates of R = Before with context C in Figure 2 (a). More queries are in the Appendix E. We then query ChatGPT to generate instruction templates. The generation examples are in Figure 2 (b). More generated templates are in the Appendix F.
After that, we obtain an encapsulated instruction by changing the placeholder [event] by the head event Eh and the placeholder [context] by the context C (if exists). To encapsulate the candidates when in discrimination training, we formulate the choices as a multiple-choice question as shown in Figure 2 (c). Based on the acquired
encapsulated instruction and event candidates, following Alpaca (Taori et al., 2023), the final inputs are shown in Figure 2 (d).

heading: 3.3 Counstruction of Event Quadruples
text: In this section, we elaborate on the detail of constructing the event quadruple. We extract event quadruple from BookCorpus (Zhu et al., 2015).
Initially, we locate tail events which may have associated head events linked by a specific relation. Drawing inspiration from Zhou et al. (2022a), we identify explicit relation connectives within the PDTB (Prasad et al., 2008). For each identified connective, we proceed to locate its child nodes. If any of these child nodes possess a VERB part-ofspeech tag, we consider it as the triggering term for the tail event. Subsequently, we traverse the dependency tree originating from the trigger term, capturing a subsection of the tree. Given the sequential nature of the dependency tree, the resultant verb-rooted subsection can be correlated with a span of words, thereby forming a recognized tail event denoted as E t.
Next, we proceed to extract the head event Eh, relation R, and the contextual information C for event quadruple. It is important to note that obtain-
ing Eh is notably more complicated than locating the tail event. This increased complexity arises from the fact that establishing a direct link between the trigger of the head event and the relational connective is often challenging through dependency tree analysis since there may be other nodes intermediately. Rather than relying on linguistic rules for extraction, we employ an end-to-end relation parser similar to the one utilized in ASER (Zhang et al., 2020). The function of this relation parser is to dissect a given text where the tail event is. Then extract the head event with a series of relations connecting these two events 1. The parsed relation is denoted as R. Within this work, our focus is on the following set of relations:
R ∈ SR = {Cause, Effect, After, (4) Before, isCond, hasCond}.
We only keep relations R ∈ SR. We concatenate sentences before the sentence of Eh as the context C. Thus far, we have accomplished the construction of event quadruple Q.
We follow Zhou et al. (2022a) to retrieve the negative events to create the candidate event set D. We build a pool of events from the whole corpus and then retrieve negative events by three heuristic rules. Specifically, given a tail event E t, we build its negative events, in light of lexicon-based, PoSbased, or in-domain retrieval. Then we sample two events from all negative events and form the candidate event set D with the gold tail event E t.

heading: 4 Experiment

heading: 4.1 Evaluation Dataset
text: We follow Tao et al. (2023a) to incorporate ECARE (Du et al., 2022), MCTACO (Zhou et al., 2019), SocialIQA (Sap et al., 2019), and SCT (Mostafazadeh et al., 2016) to evaluate models’ capabilities. These datasets assess the abilities of causal, temporal, intentional event reasoning, and event prediction respectively. For each dataset, we evaluate both CLOSE and OPEN forms of task. In CLOSE form we provide candidates while in OPEN form we don’t. All datasets are the same with Tao et al. (2023a). We finally have 8 tasks for test. Note that ECARE and MCTACO are held-in datasets since we explicitly incorporate causal and temporal relations in our event-relational learning. On the contrary, SocialIQA and SCT are held-out tasks.
1We only consider Eh occurring before the tail event.

heading: 4.2 Baselines
text: We introduce Alpaca-7B (Taori et al., 2023), Vicuna-7B (Chiang et al., 2023), WizardLM7B (Xu et al., 2023), Dolly-v2-7B (Conover et al., 2023), ChatGPT, and InstructGPT (Ouyang et al., 2022) as our baselines. Details are in Appendix B.

heading: 4.3 Implementation Settings
text: EVIT undergoes fine-tuning using academic resources. Precisely, we utilize 4 × NVIDIA A100 GPUs to train the Llama-7B for 3 epochs. We use the DeepSpeed training framework 2, and ZERO-2 strategy along with mixed-precision training (fp16) using the standard AdamW optimizer. The maximum sequence length is set to 512, and the batch size is configured as 32. We use gradient checkpointing. The entire fine-tuning process is completed within a duration of 3 hours.
We use Spacy3 for all linguistic extraction. We utilize event quadruple instances where both Eh and E t have lengths in 2 to 10 words. We exclude data whose context length falls outside the range of 10 to 50 words. For each event quadruple instance, we equally consider training it as either generation or discrimination in event-relational learning.
In our pilot experiments, we test multiple input prompts for each model to search for the optimum prompt for evaluation tasks. We observe minimal fluctuations in the results despite prompt variations. To mitigate the impact of other variables, we ensure consistency by employing the same prompt for all models when they undertake the same task. We turn the CLOSE tasks into multiple-choice questions and require the model to answer by the label of choice. All prompts can be found in the Appendix D.
We find ChatGPT and Vicuna don’t generate well-formed events in the zero-shot setting. They generate answers in narrative sentences with explanations leading to difficulty in evaluation. Therefore, we use two-shot in-context learning for them. Other models are in the zero-shot setting.

heading: 4.4 Evaluation Metrics
text: Automatic Evaluation We follow Tao et al. (2023a) to evaluate all models on automatic metrics. For CLOSE tasks, we use accuracy. In OPEN tasks, we use ROUGE-L (Lin, 2004), and BERTSCORE (Zhang et al., 2019) metrics for evaluation.
2https://www.deepspeed.ai 3https://spacy.io
For CLOSE tasks, some models won’t directly generate the label as the answer. We design the following decode protocol to parse the output answers and obtain the final prediction for all models. We show this protocol in the Appendix A.
Human Evaluation One difficulty in automatically evaluating the OPEN tasks is that the answers for OPEN tasks may not be unique. Therefore, we also conduct the human evaluation for OPEN causality, intentional, and prediction tasks. In our evaluation, we focus on two main aspects. Firstly, we assess the content, which involves checking the correctness, reasonableness, and specificity of the generated events. A higher-quality event should accurately align with the queried relation, exhibiting logical coherence and minimal hallucination. Secondly, we examine the format, ensuring that the generated content adheres to the proper structure and completeness expected in an event. We give a score range from 1 to 5 for each aspect and report the average score of the well-educated human
evaluators for each data.

heading: 4.5 Results
text: CLOSE Tasks We show evaluation results of Close tasks in Table 1. We first find EVIT performs well in HELD-IN tasks. EVIT outperforms all other instruction-tuning models both in HELDIN and HELD-OUT. EVIT obtains 75.69 overall average CLOSE score which is 4.34 higher than the second best Alpaca. In ECARE dataset, EVIT event achieves better results than Text-Davinci-002. The results demonstrate the effectiveness of our event-oriented instruction tuning. EVIT can better associate event knowledge to distinguish the correct event from event candidates.
We also find EVIT performs well in HELD-OUT tasks. EVIT outperforms all other instructiontuning models both in SocialIQA and SCT and obtains a 71.46 average score which is 3.86 higher than the second-best Alpaca. The results demonstrate that EVIT can transfer event knowledge to other event reasoning tasks or event relations.
OPEN Tasks We report automatic evaluation of OPEN Tasks in Table 2. We find EVIT performs well in ROUGE-L and Bert-Score. The average OPEN Bert-Score of our model is 7.51 higher than the second-best Alpaca. This result shows that EVIT can understand the event semantics more and generate better structures and semantics.
Human Evaluation We conduct a human evaluation of three OPEN tasks. We assess CONTENT and FORMAT aspects for all tasks. We find this human evaluation is consistent with automatic evaluation. EVIT achieves highest scores in both CONTENT and FORMAT. These results further demonstrate the effectiveness of our model. Our model can answer the event relational reasoning tasks in a way that human favors more. It can generate more precisely and concisely. The generations are more readable and understandable by humans. The events generated are more complete than others. The results also indicate that EVIT can generate more confidently without extra guesses by generally trained models. We find, in the intentional task, EVIT falls behind Alpaca in CONTENT. This result may be due to the training relation we choose. Since intentional is a held-out relation, there may exist a misalignment of generations of intention content. Overall, EVIT performs the best under human evaluation on average.

heading: 4.6 Case Analysis
text: Event Structure We show the top frequent event structure patterns in Table 4. We obtain the pattern
by extracting the root verb and its direct children of an event according to dependency parsing results. We find our event quadruple maintains the completeness of events and covers stereotypical patterns. We also show the length distribution of events in the Appendix C. We notice the events are diversified in patterns and lengths.
Event Distribution In Figure 3, we showcase a word cloud of verbs of event quadruple. We find our curated event quadruple covers a spectrum of event types. This is the main reason that EVIT is able to integrate event knowledge and reason events in various domains.
Evaluation Cases We showcase several cases of OPEN task generations of three models in Table 5. In the first example, EVIT can generate precise cause intent of the head event. The generation is also as concise as the label. Alpaca could generate the correct intent of the subject, however, the generation is lengthy. The WizardLM fails to output the answer. In the second example, EVIT also answers correctly about the cause of the head event. Alpaca and WizardLM make predictions with excessive association and hallucination. These cases further demonstrate that EVIT can associate correct event knowledge and maintain the completeness of generated events. Furthermore, EVIT can make concise inferences among all models.
5 Related Work
Event Reasoning Event relational reasoning infers events of certain inter-relations. Du et al. (2022) aims to select the accurate cause or effect event from candidates. Zhou et al. (2019) serves as a dataset for event temporal reasoning. Current works presented a scenario for current language understanding and generation systems by incorporating the need for counterfactual reasoning (Qin et al., 2019, 2020). In addition to single-event relation reasoning, existing works also reason events according to diversified event relations (Poria et al., 2021; Han et al., 2021; Yang et al., 2022). Tao et al. (2023b) further unifies datasets of several eventinter relations to transfer event relational knowledge to unseen tasks.
Predicting events necessitates the model to anticipate forthcoming occurrences grounded in the present context (Zhao, 2021). Mostafazadeh et al. (2016) employs a multiple-choice framework to predict future events by encompassing a diverse range of common-sense connections among events. Guan et al. (2019) establish a dataset oriented towards capturing event logic, enabling the generative prediction of future incidents.
Tao et al. (2023a) present the Event Semantic Processing including the event understanding, reasoning, and prediction of event semantics.
Instruction Tuning Instruction tuning refers to the process of fine-tuning a large language model based on specific instructions or guidance provided during training. Chung et al. (2022) finetunes on T5 with a scaling number of datasets which achieves strong few-shot performance even compared to much larger models. Taori et al. (2023) is trained by fine-tuning the LLaMA (Touvron et al., 2023) model using a dataset consisting instructions generated by text-davinci-003. Chiang et al. (2023) is an open-source chatbot created by fine-tuning LLaMA using user-shared conversations gathered from ShareGPT. Xu et al. (2023) extends the previ-
ous model by evolve-instruct algorithms to improve the model. Conover et al. (2023) leverages data on the Databricks platform.
In another line of research, instruction tuning is used to make a language model more focused and specialized in certain abilities or domains. Zhang et al. (2023a) trains a medical conversation model with different sources of datasets with instructions. Cui et al. (2023) propose a legal LLM named ChatLaw by legal domain dataset and mitigate hallucination of the model. Zhang et al. (2023b) train an LLM specialized for information extraction with data adapted from a knowledge graph. Yang et al. (2023) design an automatic data curation pipeline and in building financial open-source LLM. Tang et al. (2023) propose a dataset to improve the tool manipulating ability of LLMs. Our work lies in this ability enhancement line of research.
Event-Aware Pretraining Considering both the pre-training and fine-tuning strategies, researchers are dedicated to improving event processing through fine-tuning techniques that incorporate events. In their study, Yu et al. (2020) inject intricate commonsense knowledge about events into pre-trained language models. Similarly, Zhou et al. (2022a,b) enhance language models by focusing on event-related tasks through event masking prediction and generation. However, these works struggle to effectively perform zero-shot reasoning.

heading: 6 Conclusion
text: In this study, we introduce Event-Oriented Instruction Tuning to enhance event reasoning capabilities and train our model EVIT. We first introduce a novel structure called event quadruple as a foundational structure. Building upon this, we establish event relation learning through instruction tuning using generated prompts. We create an instructiontuning dataset focused on events, encompassing comprehensive and diversified event data both in
syntax and semantics. Subsequently, we fine-tune Llama to create the EVIT model. We conduct experiments on both CLOSE and OPEN task settings and compare with several strong cutting-edge instruction-tuned models. Through extensive experiments on 8 datasets, the outcomes demonstrate the efficacy of our proposed approach.
Limitations
In this paper, we only achieve a model that excels in textual event reasoning. However, the event can be represented in other modalities such as visual data. Images would contain more information beyond sentences of events. Leveraging data from other modalities to improve performance remains challenging. We leave it to future work.

heading: Acknowledgement
text: This work is supported by the National Natural Science Foundation of China under Grant No. 62192731.

heading: A Decoding Protocol
text: We show our decoding protocol for extracting answers of CLOSE tasks as follows:
Input :Prediction P , candidate set D. Output :Answer A.
1 pattern = "the(?: correct)? (?:option|answer) is[\ s:]+([A-H])" 2 if P.startsWithAlphabet() then 3 A = starts_alphabet 4 else if re.match(pattern, P) then 5 A = re.extract(P, patten) 6 else 7 A=argmax
c∈D (WordOverlap(c, P))
8 return A

heading: B Baselines
text: Alpaca Vicuna, an open-source chatbot, is developed by fine-tuning LLaMA using user-shared conversations collected from ShareGPT. Preliminary evaluations with GPT-4 as the evaluator reveal that Vicuna achieves more than 90% quality when compared to ChatGPT.
Vicuna This particular model undergoes training through fine-tuning the LLaMA 7B model with a dataset containing 52,000 demonstrations accompanied by instructions generated using Text-Davinci003.
WizardLM WizardLM is trained on instructiontuning data generated by the Evol-Instruct algorithm. It demonstrates remarkable performance on complex tasks and remains competitive across various metrics.
Dolly-v2 Databricks’ Dolly-v2 7B is a sizable language model designed for instruction-following,
trained using 15,000 instruction/response finetuning records created by Databricks employees. These records cover various capability domains, encompassing classification, closed QA, generation, information extraction, open QA, and summarization.
ChatGPT An extensive language model developed by OpenAI4. The model undergoes finetuning, employing a combination of supervised and reinforcement learning techniques to enhance its performance.
InstructGPT We assess two InstructGPT models, specifically Text-Davinci-002.

heading: C Event Length
text: We show the length distribution of events in Figure 4.

heading: D Event Reasoning Evaluation Prompts
text: We show prompts for evaluation on all tasks for all models in Figure 5.
E Input for ChatGPT
We show ChatGPT input for generating instruction templates in Figure 6.

heading: F Examples of Instruction Templates
text: We showcase examples of instruction templates in Figure 7.
4https://chat.openai.com/

heading: Future Work
text: We leave it to future work