Few-Shot Event Argument Extraction Based on a Meta-Learning Approach (2024)

Abstract: Few-shot learning techniques for Event Extraction are developed to alleviate the cost of data annotation. However, most studies on few-shot event extraction only focus on event trigger detection and no study has been proposed on argument extraction in a meta-learning context. In this paper, we investigate few-shot event argument extraction using prototypical networks, casting the task as a relation classification problem. Furthermore, we propose to enhance the relation embeddings by injecting syntactic knowledge into the model using graph convolutional networks. Our experimental results show that our proposed approach achieves strong performance on ACE 2005 in several few-shot configurations, and highlight the importance of syntactic knowledge for this task. More generally, our paper provides a unified evaluation framework for meta-learning approaches for argument extraction.

## introduction event extraction (ee) aims to automatically identify and extract information about events from unstructured texts, targeting more specifically the event trigger (the word or phrase corresponding to the mention of the event) and the event arguments (the entities that play a role in the event). for instance, in the sentence "seven u.s. soldiers were killed when their vehicle hit an explosive device in baghdad", a life.die event, according to the ace 2005 @xcite terminology for event types, is mentioned through the trigger killed and associated with the arguments seven u.s. soldiers, explosive device, and baghdad, which correspond to the respective roles of victim, instrument, and location of the event structure. typical ee systems rely on supervised approaches that require a large amount of annotated data for each considered event type. unfortunately, data annotation is expensive and cannot be performed for all applications, since new event types may appear with only a few examples. as a result, there has been a growing interest in addressing the challenge of @xcite . most studies in fsee only consider event detection (ed), which focuses on extracting and classifying event triggers. some of them further restrict the ed task to the classification part only, using a candidate trigger already identified @xcite @xcite . other leverage event-related keywords @xcite or external resources for data enrichment @xcite @xcite . prototypical networks @xcite have also been applied successfully to this task formalized as a sequence annotation problem in a meta-learning context @xcite @xcite . however, very few studies address argument extraction using these methods. most existing methods for event argument extraction in lowresource scenarios rely on supervised approaches, with additional experiments to show the performance of the models with limited annotated data. such approaches exploit question answering frameworks @xcite , specific slot-filling techniques @xcite @xcite , or methods based on textual entailment @xcite . zero-shot approaches have also been proposed, either relying on external resources @xcite or using prompting techniques with pre-trained language models @xcite . to the best of our knowledge, only @xcite tackle few-shot argument extraction, but they do it at the document level and the performance of their approach is rather limited. our work focuses on using prototypical networks for fsee, modeling the task as a relation classification problem between candidate entities and the event trigger. moreover, we propose several extensions of this model by injecting syntactic information into the representation of relations. our contributions are summarized as follows: ## proposed method we tackle event argument extraction as a relation classification task between an event trigger and the entities in the sentence containing the trigger. foot_0 more precisely, for each of these entities, we perform a multi-class classification, each class corresponding to one of the possible roles for the event type associated with the considered trigger. in addition, a null class stands for the absence of a role for a candidate entity with respect to the event. our few-shot setting for this task is a variant of the standard n -ways k-shots meta-learning approach @xcite , which involves learning through multiple training episodes. each episode represents a classification task @xmath0, q}, with a support set s and a query set q, where s contains n classes, each with k labeled instances, and q contains examples from the same n classes as s. the goal of an episode is to classify the query set examples based on the support set examples. the idea is to train the model on various episodes of different tasks so that it can quickly adapt and generalize to new tasks (during inference), including on previously unseen argument role classes. for a given event type e, an instance is designed as x @xmath1, tr e i , e i ), with y @xmath2, where s e i is the sentence mentioning the event, tr e i the trigger, e i the argument candidate, and a i the role belonging to a @xmath3. the same sentence can therefore belong to as many instances as it contains entities. our formulation differs slightly from the typical meta-learning setting as, even if the classification is performed on the event argument roles, we consider new classes at the event level (the event types in the test set were not encountered during training). we therefore have new event types during inference, but we may have seen argument roles with the same semantics or not. this is more in line with real-world applications where new events can arise instead of just new roles for existing events. as a consequence, our formulation of the n -ways kshot setup includes a variable n , which represents the number of arguments for a given event type. also, some arguments in the events of the test set may be similar to arguments from the training set, even if they correspond to different event types (e.g. an argument agent may exist in several events). ## experiments settings. we conduct our experiments on the ace-2005 dataset with the split provided by @xcite . this split ensures that there is no overlap between train and test classes, thus simulating a real-life few-shot scenario. we use bert-large-uncased as our backbone encoder. additionally, for bert++ encoder, we use trainable vectors of size 256 to encode syntactic dependencies and pos tags obtained using spacy. the rgcn encoder is composed of two convolutional layers and three relation types (i.e. direct paths, indirect paths, and self-loops). we provide a list of hyper-parameters in main results. our main results are presented in figure 3 provides an overview of the representations learned by each encoder on the evaluation set. the pre-trained bert encoder corresponds to a bert model without any fine-tuning specific to the event argument extraction task. we compare the three encoders presented in this work: bert, bert++, and rgcn. first, it is clear that training the bert model significantly improves the possibility to discriminate among argument types compared to an untuned bert. this highlights the relevance of the model we have adopted for this task and the importance of fine-tuning the bert model in this context. we can also observe qualitatively that the two syntactically enriched encoders, bert++ and rgcn, seem to provide more discriminative representations than the original bert encoder. these observations are consistent with the results obtained during the evaluation, which reinforces the relevance of enriching the representations with syntactic information and suggests an overall improvement in the model's performance. ## conclusion and future work in this article, we propose a meta-learning approach for event argument extraction that complements existing work on few-shot event extraction. we cast the argument extraction as a relation classification problem and propose an adaptation of the n -ways k-shots framework that matches the expectations of a real-life few-shot event extraction task. we show that our proposed models achieve strong performance on the ace 2005 dataset. our experiments prove the interest of enhancing the event role embeddings using syntactic information. as a perspective, we plan to extend the development of few-shot models for event extraction towards the definition of joint approaches integrating entity, trigger, and argument extractions more tightly.