Method, device, electronic device and medium for event extraction

Abstract

Embodiments of this disclosure relate to methods, apparatus, electronic devices, and media for event extraction. The method includes extracting multiple named entities as event arguments from a document, wherein the document comprises at least two sentences, and then determining event types in the document and templates corresponding to the event types. The method further includes filling the multiple event arguments into corresponding positions in the template to generate multiple candidate event records, and then filtering the multiple candidate event records to obtain one or more target event records. According to embodiments of this disclosure, by iteratively generating each candidate event record during document-level event record extraction, performance fluctuations caused by manual selection of the event role generation order can be avoided, as well as underfitting due to parallel generation, thereby improving the accuracy of event extraction.

Description

Technical Field

[0001] Embodiments of this disclosure relate to the field of computers, and more specifically, to methods, apparatus, electronic devices, and media for event extraction. Background Technology

[0002] Event extraction technology extracts events of interest to users from unstructured information and presents them to users in a structured event record format. Event extraction has wide applications in text summarization, automatic question answering, and automatic construction of event graphs. Automating event extraction tasks can utilize computing devices to automatically detect events and event content included in documents, forming structured data for subsequent processing. Summary of the Invention

[0003] Embodiments of this disclosure provide a method, apparatus, electronic device, and computer-readable storage medium for event extraction.

[0004] According to a first aspect of the present disclosure, a method for event extraction is provided. The method includes extracting a plurality of named entities as a plurality of event arguments from a document, wherein the document includes at least two sentences. The method further includes determining an event type in the document and a template corresponding to the event type. The method further includes filling the plurality of event arguments into corresponding positions in the template to generate a plurality of candidate event records, wherein during the generation of the plurality of candidate event records, each candidate event record is iteratively generated based on previously generated candidate event records, starting from the second candidate event record among the plurality of candidate events. The method further includes filtering the plurality of candidate event records to obtain one or more target event records.

[0005] In a second aspect of this disclosure, an apparatus for event extraction is provided. The apparatus includes a named entity extraction module configured to extract a plurality of named entities as a plurality of event arguments from a document, wherein the document includes at least two sentences. The apparatus also includes an event type determination module configured to further determine event types in the document and templates corresponding to the event types. The apparatus further includes an event record generation module configured to fill the plurality of event arguments into corresponding positions in the template to generate a plurality of candidate event records, wherein during the generation of the plurality of candidate event records, each candidate event record is iteratively generated based on previously generated candidate event records, starting from the second candidate event record among the plurality of candidate events. The apparatus also includes an event record filtering module configured to filter the plurality of candidate event records to obtain one or more target event records.

[0006] According to a third aspect of the present disclosure, an electronic device is provided. The electronic device includes a processor and a memory coupled to the processor, the memory having instructions stored therein, which, when executed by the processor, cause the electronic device to perform the method according to the first aspect.

[0007] In a fourth aspect of this disclosure, a computer-readable storage medium is provided. The computer-readable storage medium stores one or more computer instructions, wherein the one or more computer instructions are executed by a processor to implement the method according to the first aspect.

[0008] The summary section is provided to present the chosen concepts in a simplified form, which will be further described in the detailed description below. The summary section is not intended to identify key or principal features of the claimed subject matter, nor is it intended to limit the scope of the claimed subject matter. Attached Figure Description

[0009] The above and other features, advantages, and aspects of the embodiments of this disclosure will become more apparent from the accompanying drawings and the following detailed description. In the drawings, the same or similar reference numerals denote the same or similar elements, wherein:

[0010] Figure 1 A schematic diagram of an example environment in which an event extraction method according to some embodiments of the present disclosure may be implemented is shown;

[0011] Figure 2 A schematic diagram illustrating naming references according to some embodiments of the present disclosure is shown;

[0012] Figure 3 A schematic diagram illustrating event types, event arguments, and event roles according to some embodiments of the present disclosure is shown;

[0013] Figure 4 A flowchart of an event extraction method according to some embodiments of the present disclosure is shown;

[0014] Figure 5 A simplified event extraction process according to some embodiments of the present disclosure is illustrated in the diagram;

[0015] Figure 6 A schematic diagram of an event extraction model including a training process according to some embodiments of the present disclosure is shown;

[0016] Figure 7 A schematic diagram of an event template according to some embodiments of the present disclosure is shown;

[0017] Figure 8 A schematic diagram of a pre-filling process according to some embodiments of the present disclosure is shown;

[0018] Figure 9 A block diagram of an event extraction apparatus according to some embodiments of the present disclosure is shown; and

[0019] Figure 10 A block diagram of an electronic device according to some embodiments of the present disclosure is shown.

[0020] In all the accompanying figures, the same or similar reference numerals denote the same or similar elements. Detailed Implementation

[0021] It is understood that the data involved in this technical solution (including but not limited to the data itself, the acquisition or use of the data) shall comply with the requirements of relevant laws, regulations and related provisions.

[0022] Embodiments of this disclosure will now be described in more detail with reference to the accompanying drawings. While some embodiments of this disclosure are shown in the drawings, it should be understood that this disclosure can be implemented in various forms and should not be construed as limited to the embodiments set forth herein. Rather, these embodiments are provided to provide a more thorough and complete understanding of this disclosure. It should be understood that the accompanying drawings and embodiments of this disclosure are for illustrative purposes only and are not intended to limit the scope of protection of this disclosure.

[0023] In the description of embodiments of this disclosure, the term "comprising" and similar terms should be understood as open-ended inclusion, i.e., "including but not limited to". The term "based on" should be understood as "at least partially based on". The term "one embodiment" or "the embodiment" should be understood as "at least one embodiment". The terms "first", "second", etc., may refer to different or the same objects unless explicitly stated. Other explicit and implicit definitions may also be included below.

[0024] In some embodiments of this disclosure, an event extraction task in English will be described as an example; however, event extraction tasks in other languages ​​(e.g., Chinese) may also be used in conjunction with embodiments of this disclosure. Furthermore, all specific numerical values ​​herein are illustrative and are intended to aid understanding only, and are not intended to limit the scope of the invention.

[0025] Event extraction tasks require event detection and accurate determination of event types. They also necessitate argument detection, which involves identifying relevant elements of the event and accurately determining the role of each element within the event.

[0026] In a traditional event extraction method, trigger-less event extraction generates event arguments in a pre-defined order by constructing an entity-based directed acyclic graph (EDAG) autoregressively. In another traditional event extraction method, all arguments in an event record are generated simultaneously using a parallel approach.

[0027] Most previous trigger-word-free event extraction methods either autoregressively generate event arguments in a pre-given order by constructing entity-based directed acyclic graphs, or use parallel methods to generate all arguments in a single event record simultaneously. Since event arguments in a single event record are typically scattered across multiple sentences, and overlapping arguments appear even more frequently across several event records, this leads to low-quality annotation of trigger words and a need for trigger-word-free methods. Therefore, extracting multiple event records without trigger words is a major challenge for trigger-word-free event extraction methods.

[0028] However, the study found that the entity-based directed acyclic graph method requires the pre-determined generation order of event roles. Different generation orders of event roles cause significant fluctuations in the performance of the event extraction model. Parallel methods avoid the selection of the order of event roles. However, parallel methods have serious underfitting problems, and even show low accuracy in extracting many event roles in some scenarios.

[0029] To address these issues, embodiments of this disclosure propose a document-level event extraction (DEE) scheme, designed to extract multiple event records from an entire document. This scheme provides an iteratively parallel generation method with a pre-filling strategy (IPGPF). The method of this disclosure can iteratively and parallelly generate event roles, avoiding the influence of the event role generation order. Since there is no need to pre-determine the order of event arguments, it avoids the performance fluctuations caused by manually selecting the event role generation order based solely on experience. Therefore, even if the event arguments of an event record are scattered across multiple sentences, the event record can be accurately extracted because there is no need for a manually predetermined order. In some embodiments, to alleviate the underfitting problem in parallel generation, this disclosure also proposes a pre-filling strategy. In event record generation, the pre-filling strategy first selects a portion of the results from the historical generation as event role fillers, and then generates unfilled event roles based on the already filled event roles. This pre-filling strategy avoids the underfitting phenomenon caused by conventional parallelism, thereby improving the accuracy of event extraction.

[0030] In the following description, some embodiments will be discussed with reference to the event extraction process described in the English documentation. However, it should be understood that this is merely to enable those skilled in the art to better understand the principles and ideas of the embodiments of this disclosure, and is not intended to limit the scope of this disclosure in any way.

[0031] Figure 1 A schematic diagram of an example environment 100 in which an event extraction method according to some embodiments of the present disclosure may be implemented is shown. Figure 1 As shown, example environment 100 may include document 110. Document 110 consists of at least two sentences, such as sentence 1 (i.e., 110-1) and sentence 2 (i.e., 110-2). It is understood that document 110 may also include more sentences (not shown).

[0032] Environment 100 also includes computing device 120. Computing device 120 may be a computer, computing system, a single server, a distributed server, or a cloud-based server. Computing device 120 can access document 110.

[0033] The computing device 120 is equipped with an event extraction model 130. After obtaining the document 110, the event extraction model 130 can generate multiple candidate event records, such as candidate event record 140-1 and candidate event record 140-2. It can be understood that the number of candidate event records can vary depending on different needs, and therefore, there can be more candidate event records.

[0034] After generating multiple candidate event records, the event extraction model 130 filters these candidate event records to obtain target event records 150. It is understandable that the number of target event records can vary depending on the configuration or the content of the document, and is therefore not limited to a single target event record. The number of target event records is generally less than the number of candidate event records.

[0035] It should be understood that the architecture and functionality in example environment 100 are described for illustrative purposes only and do not imply any limitation on the scope of this disclosure. Embodiments of this disclosure can also be applied to other environments with different structures and / or functionalities.

[0036] The following will combine Figures 2 to 8 The process according to embodiments of this disclosure is described in detail. For ease of understanding, the specific data mentioned in the following description are exemplary and not intended to limit the scope of this disclosure. It is understood that the embodiments described below may also include additional actions not shown and / or actions shown may be omitted, and the scope of this disclosure is not limited in this respect.

[0037] Figure 2 A schematic diagram of entity mentions according to some embodiments of this disclosure is shown. In the document-level event extraction method, a named entity can be understood as noun text belonging to a predefined semantic type (e.g., person, place, organization, etc.). An entity mention 202 can be understood as text in a document corresponding to a specific named entity.

[0038] As an example, document 210 may include sentence S6: Jinggong Group increased its holdings of the company's stock by 182,038 shares through the secondary market on Dec 15, 2011. Document 210 may also include sentences S7, S9, and S14, etc. In sentences S6 and S7, Jinggong Group is entity reference 202. In sentences S9 and S14, Jinggong Group is also entity reference 202. Other entity words can also be entity references 202.

[0039] Figure 3 A schematic diagram 300 illustrates event types, event arguments, and event roles according to some embodiments of this disclosure. An event record can be understood as an event expression containing a number of event arguments and their event roles. For example, event records 310 and 320. In event record 310, EquityOverweight is event type 302. In event record 320, EquityUnderweight is event type 302.

[0040] Taking event record 320 as an example, it includes event arguments 304 and event roles 306. Event arguments 304 can be understood as named entities that play a specific role in the event. For example, Jinggong Group. Event roles 306 can be understood as predefined categories of event arguments (such as time, location, people, etc.). For example, EndDate (end date).

[0041] In this disclosure, a document-level event extraction task without trigger words is adopted, which typically includes three subtasks: (1) Named entity recognition (NER). NER extracts named entities from the document as candidate event arguments. (2) Event detection (ED). ED determines whether a certain type of predefined event appears in the document. (3) Event record generation (ERG). ERG generates event records according to event categories. The absence of trigger words increases the difficulty of document-level event extraction, but avoids the manual selection of the event role generation order. The following will combine... Figure 6 Let's go into detail about these subtasks.

[0042] Figure 4 A flowchart of a method for event extraction 400 according to some embodiments of the present disclosure is shown. Figure 5 A simplified event extraction process 500 according to some embodiments of the present disclosure is illustrated below. Figure 4 and Figure 5 This describes the event extraction task disclosed herein.

[0043] At box 402, multiple named entities are extracted from the document as multiple event arguments, where the document includes at least two sentences. As an example, named entity recognition is performed on document 110, and the event roles to which the identified event arguments belong are EquityHolder 510, TradeShares 520, and AveragePrice 530.

[0044] At box 404, identify the event type in the document and the corresponding template. As an example, at box 502, perform event detection and determine the event type as "EquityOverweight," so the corresponding event template is also a template for "stock holdings increase." The following section will discuss event templates in conjunction with... Figure 7 Let me explain in detail.

[0045] At box 406, multiple event arguments are filled into the corresponding positions in the template to generate multiple candidate event records. During the generation of multiple candidate event records, each candidate event record is iteratively generated based on previously generated candidate event records, starting from the second candidate event record among the multiple candidate events. As an example, at box 504, the template for "stock increase" is filled to generate multiple candidate event records. The first generated candidate event record is generated based on the event template. Starting from the second generated candidate event record, it is based not only on the event template but also on other already generated candidate event records. At box 408, multiple candidate event records are filtered to obtain one or more target event records. As an example, at box 508, the multiple candidate event records obtained at box 504 are filtered to obtain one or more target event records. As an example, the argument representation and template representation of the event record in round t (where t is an integer greater than or equal to 2) can be compressed using max pooling to obtain the representation of the event record. In round t+1, the previously generated event records and the template to be filled this time are merged to generate the (t+1)th event record based on the event records in round t.

[0046] In some embodiments, a pre-filling process may also be included when training the event extraction model 130. As an example, at 506, a subset of historically generated candidate event records may be selected as fillers for roles, and then unfilled roles may be generated based on the already filled roles.

[0047] The method 400 of the embodiments of this disclosure enables event extraction at the document level and avoids the manual selection of the event role generation order. It also improves the accuracy of event extraction by avoiding low-quality annotation of trigger words. Furthermore, method 400 does not require pre-determining the generation order of event roles, reducing significant fluctuations in event extraction accuracy and mitigating underfitting issues in the event extraction model.

[0048] Figure 6 A schematic diagram of an event extraction model 600, including a training process, according to some embodiments of the present disclosure is shown. The main idea of ​​process 600 is: for a given set of N... s a sentence Document D (e.g., document 602), the document-level event extraction task aims to generate multiple event records. Where z i Represents the i-th event record, N z This represents the number of actual event records in the document. Each event record consists of n event arguments. and their corresponding event roles constitute.

[0049] In some embodiments, entities are first extracted from the document as candidate event arguments. Then, it is determined whether the document contains an event of a given type. Finally, the model iteratively generates multiple event records, generating all roles in each event record in parallel. In some embodiments, a pre-filling strategy can also be used when training the event extraction model to improve its parallel generation capability.

[0050] In some embodiments, in named entity recognition 630, for a given N s a sentence Document D uses transformer encoder 1 to encode each sentence. Entity 604 in the sentence is obtained, and the implicit representation H of the sentence is obtained. w 606:

[0051]

[0052] in d represents the dimension of the latent space, and Encoder1 represents the operation of encoder 1. Represents vocabulary.

[0053] In some embodiments, conditional random fields are used to decode and extract entities, resulting in a maximum likelihood loss function for named entity recognition:

[0054]

[0055] Where y represents the label of word w, the sampling is from the BIO (Begin represents the starting position of an entity, Inside represents the middle character of an entity, Other represents a non-entity character) annotation specification, and P represents the probability that the label of word w is y.

[0056] In some embodiments, during event detection 640, the obtained N e individual entities In this process, identical entities are compressed using max pooling. After compression, N is obtained. a +1 candidate event arguments:

[0057]

[0058] in This represents an additional argument to indicate a null value (NULL). Furthermore, the sentence representation is obtained by compressing all lexical representations in the sentence using max pooling.

[0059]

[0060] In some embodiments, transformer encoder 2 is used to perform feature interaction between argument representations and sentence representations:

[0061]

[0062] Here, Encoder2 represents the operation of encoder 2. H a The event argument representation representing the perception of the argument. H s Sentence representation after argument perception.

[0063] In some embodiments, encoder 1 and encoder 2 may also be used together. In some embodiments, argument-aware sentence representation H is used. s Perform a multi-class classification task to obtain the probability of each type of event existing in the document:

[0064] P c =Sigmoid(H c (6)

[0065] in This represents the trainable parameters of the model. N represents cThe probability of an event type existing is represented by Sigmoid, which indicates the operation of the Sigmoid function.

[0066] In some embodiments, the cross-entropy loss function for event detection is calculated:

[0067]

[0068] in For the true label of the i-th event type, The probability of the x-th event type.

[0069] As an example, in box 608, the event type EquityFreeze has a higher probability and is identified as a detected event type, while EquityUnderweight has a lower probability and is not identified as a detected event type.

[0070] In event log generation 650, event logs can be generated based on an event template by filling in a given template. Let's first combine this with... Figure 7 This is a template for introducing events. Figure 7 A schematic diagram of an event template 700 according to some embodiments of the present disclosure is shown.

[0071] Parallel generation of all roles in an event effectively avoids the performance instability caused by manually selecting the generation order. To further assist in event role generation, templates can be constructed for each type of event, such as... Figure 7 As shown, the event roles to be generated are represented by special characters in these templates. Based on these templates, the model can generate event records by filling in a given template.

[0072] Template 700 includes event type 710 and the corresponding template 720. For example only, event type 710 includes Equity Freeze, Equity Repurchase, Equity Underweight, Equity Overweight, and Equity Pledge. It is understood that more event types from the financial sector, as well as templates from other sectors, can be included.

[0073] In some embodiments, the template corresponding to equity freeze is: On UnfrozeDate , Legal institution Freezes or unfreezes the FrozeShares held by EquityHolder It starts from StartDate and ends at EndDate.At present,he / she / it still holds TotalHoldingShares shares of the company,accounting for Total Holding Ratio ofthe company's total share capital(in UnfrozeDate Legallonstitution freeze or unfreeze EquityHolder Holding FrozeShares It comes from StartDate Beginning, to EndDate End. Currently, it still holds shares in the company. TotalHoldingShares Shares, representing a percentage of the company's total share capital Total Holding Ratio The underlined parts indicate the areas where event arguments need to be used for filling. It's understood that the template can have other styles and can be adjusted and optimized as needed.

[0074] Now return to Figure 6 In parallel template filling 652, for a given event type, N is first determined. t Representation of each template word:

[0075]

[0076] Then, using transformer decoder 1, an argument-aware template representation is obtained:

[0077] H t =Decoder1(Q t H a )

[0078] Next, a pointer neural network is used to select candidate arguments H. a The arguments corresponding to the roles in the event are obtained through filtering:

[0079] P r =Softmax(tanh(H) r W r +H a W a (9)

[0080] in H represents t The representation of event roles in W a ,v represents the model parameters, This represents the probability of the event argument corresponding to the event role. Ultimately, N can be extracted. r The event argument corresponding to each event role As an example, in box 610, Jinggong Group, 35,000 shares, and 19.88 were selected as the event arguments corresponding to the event roles.

[0081] In some embodiments, during iterative generation 654, an iterative generation method can be used to better utilize the results of historical generation. As an example, for a historically generated event record, the representation of the event record can be obtained by max-pooling compression of the argument representation and template representation in the event. In generating the (i+1)th event record, the previously generated event records and the template to be filled in this time can be merged to generate the (i+1)th event record with the help of the historical results.

[0082] In some embodiments, during event record filtering 656, the number of iterations generated for extracting all event records in a document can be greater than the number of actual event records. Therefore, a filter is needed to select a portion of the event records output by the model as the final result. In N i After rounds of iteration, a representation of all generated event records can be obtained. Then, the best event records can be filtered out as the final result using transformer decoder 2 and a linear classifier:

[0083]

[0084]

[0085] Among them W z This represents the trainable parameters of the event extraction model. This indicates the score of the output event record. This represents the event record being filtered, and Decoder2 represents the operation of decoder 2.

[0086] As an example, after decoding 1, Jinggong Group matches record 1, 35,000 shares matches record 1, and 19.88 matches record 2. These matches are candidate event records 614, 616, and 618. In some embodiments, the generated candidate event records can be iteratively regenerated by concatenating them with template 612. After decoding 2, event record 620 (i.e., the original event record 614) matches record 1, event record 622 (i.e., the original event record 616) does not match, and event record 624 (i.e., the original event record 618) matches record 2.

[0087] In some embodiments, to complete model training, it is necessary to assign true labels to the event records output by the model. Therefore, this disclosure proposes a matching method. During model training, event records under each event category are generated, and the loss function for that category is calculated. Finally, the loss function values ​​of all event categories are summed as the final loss.

[0088] In some embodiments, in event role matching 658, a given event argument extraction score and the theory of reality in and This represents the argument index corresponding to the j-th role in the i-th event record. In some embodiments, a cost function can be defined to compute the event records output by each event extraction model in pairs. Record of real events Losses:

[0089]

[0090] In some embodiments, a greedy algorithm can be used to combine each model output record. The most similar real-life event record is used as its tag:

[0091]

[0092] Where argmin represents finding the value in the... The smallest j operation.

[0093] In some embodiments, in order to incentivize the event extraction model to generate event records that have not been generated in the past, real event records can be assigned to the model output without replacement. After all real event records have been assigned to the model output, all real event records can be returned with replacement and assigned to the most similar model output.

[0094] In this way, we can obtain the final matching result, which is a surjective mapping. This represents mapping the event record output by the i-th model to the j-th real event record. This mapping satisfies the surjective property. Finally, the matching loss function for event roles can be obtained:

[0095]

[0096] In some embodiments, in event record matching 660, the filtering score of the event records output by the given model. Note the tags corresponding to the real event records. The event records output by the i-th model can be computed in pairs. and the j-th real event record tag

[0097]

[0098] in, Indicates the loss caused by the event.

[0099] To filter the best results from the event logs output by the model as the final result, we can define role loss and event loss:

[0100]

[0101] Among them, C role Indicates a loss of character, C all Total loss.

[0102] To find the best match between the event records output by the model and the real event records, we can define an injective mapping that maps the j-th real event record to the i-th model output event record. Satisfies the injective property definition For set I z to set The injective set. In some embodiments, the Hungarian algorithm can be used to obtain the matching with minimum loss:

[0103]

[0104] Then, the binary cross-entropy loss can be calculated as the loss function for event matching:

[0105]

[0106] Where A = π * (I z ), Finally, the loss function for generating event logs is:

[0107]

[0108] Where γ1, γ2∈(0,1) are the hyperparameters of the model.

[0109] Figure 8 A schematic diagram of a pre-filling process 800 according to some embodiments of the present disclosure is shown. The main idea of ​​process 800 is that, for a given document D, the goal of the event extraction model is to fit all event roles. The joint distribution P(y1,y2,…,y) n|D). However, direct fitting of parallel generation methods to complex high-dimensional distributions leads to underfitting. To mitigate underfitting, this disclosure also proposes a pre-filling strategy, which applies the joint distribution... The fitting is transformed into a conditional distribution Fitting.

[0110] like Figure 8 As shown, in some embodiments, in the (t+1)th iteration, the event records filtered by the filter are first examined, and the scores of these event records are used to determine the order of events. Use classification sampling to select one event record:

[0111]

[0112] Where α is the threshold for binary classification, and t represents the number of iterations. This indicates the probability of sampling the event record.

[0113] In some embodiments, after selecting a historical event record, a score P is selected from the arguments that were correctly predicted. r Arguments greater than β are sampled using Bernoulli with probability κ. Then, before the current generation begins, the sampled arguments are pre-filled into the corresponding roles in the template, so that only the remaining roles need to be filled during generation. When calculating the loss function, only the loss of the filled roles is calculated, not the loss of the pre-filled roles.

[0114] As an example, at position 802, event arguments 812, 814, and 816 are filled into the template. The threshold score β can be set to 0.75. Event argument 812 has a score of 0.98, so it does not need to be pre-filled. Event argument 814 has a score of 0.95 and is sampled as needing pre-filling at position 804. Event argument 816 has a score of 0.22, so it is directly determined to need pre-filling. Event arguments 814 and 816 are masked, and the corresponding positions in the template of their masks need to be filled again. After template filling at position 806, event argument 814 remains unchanged, while event argument 816 changes to event argument 822, at which point its score is 0.89. Event argument 814 is not pre-filled, so the role loss at position 824 is not calculated. The role loss at position 826 needs to be calculated for event arguments 814 and 822.

[0115] Because the pre-filling strategy requires true labels to sample correctly predicted event arguments, the event extraction model uses the pre-filling strategy during the training phase but can omit it during the inference phase. This pre-filling strategy significantly alleviates the underfitting problem of parallel event extraction methods and improves the accuracy of event extraction.

[0116] Figure 9 A block diagram of an event extraction apparatus 900 according to certain embodiments of the present disclosure is shown. Figure 9 As shown, apparatus 900 includes a named entity extraction module 902 configured to extract multiple named entities as multiple event arguments from a document, wherein the document includes at least two sentences. Apparatus 900 also includes an event type determination module 904 configured to further determine event types in the document and templates corresponding to the event types. Apparatus 900 also includes an event record generation module 906 configured to fill the multiple event arguments into corresponding positions in the template to generate multiple candidate event records, wherein during the generation of the multiple candidate event records, each candidate event record is iteratively generated based on previously generated candidate event records, starting from the second candidate event record among the multiple candidate events. Apparatus 900 also includes an event record filtering module 908 configured to filter the multiple candidate event records to obtain one or more target event records. Apparatus 900 may also include other modules that implement the steps of method 400 according to embodiments of the present disclosure; for brevity, these will not be described further here.

[0117] It is understood that the apparatus 900 of this disclosure can achieve at least one of the many advantages that the methods or processes described above can achieve. For example, it enables event extraction at the document level and avoids the manual selection of the event role generation order, thereby improving the accuracy of event extraction. Furthermore, it eliminates the need to predetermine the event role generation order, avoiding performance fluctuations caused by the manual selection of the event role generation order and reducing the underfitting problem of the event extraction model.

[0118] Figure 10 A block diagram of an electronic device 1000 according to certain embodiments of the present disclosure is shown. Device 1000 may be the device or apparatus described in the embodiments of the present disclosure. Figure 10 As shown, device 1000 includes a central processing unit (CPU) and / or a graphics processing unit (GPU) 1001, which can perform various appropriate actions and processes according to computer program instructions stored in read-only memory (ROM) 1002 or loaded from storage unit 1008 into random access memory (RAM) 1003. Various programs and data required for the operation of device 1000 can also be stored in RAM 1003. The CPU / GPU 1001, ROM 1002, and RAM 1003 are interconnected via bus 1004. Input / output (I / O) interface 1005 is also connected to bus 1004. Although not shown in... Figure 10 As shown, device 1000 may also include a coprocessor.

[0119] Multiple components in device 1000 are connected to I / O interface 1005, including: input unit 1006, such as keyboard, mouse, etc.; output unit 1007, such as various types of monitors, speakers, etc.; storage unit 1008, such as disk, optical disk, etc.; and communication unit 1009, such as network card, modem, wireless transceiver, etc. Communication unit 1009 allows device 1000 to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks.

[0120] The various methods or processes described above can be executed by CPU / GPU 1001. For example, in some embodiments, the methods may be implemented as computer software programs tangibly contained in a machine-readable medium, such as storage unit 1008. In some embodiments, part or all of the computer program may be loaded and / or installed on device 1000 via ROM 1002 and / or communication unit 1009. When the computer program is loaded into RAM 1003 and executed by CPU / GPU 1001, one or more steps or actions in the methods or processes described above can be performed.

[0121] In some embodiments, the methods and processes described above can be implemented as a computer program product. The computer program product may include a computer-readable storage medium having computer-readable program instructions loaded thereon for performing various aspects of this disclosure.

[0122] Computer-readable storage media can be tangible devices capable of holding and storing instructions for use by an instruction execution device. Computer-readable storage media can be, for example, but not limited to, electrical storage devices, magnetic storage devices, optical storage devices, electromagnetic storage devices, semiconductor storage devices, or any suitable combination thereof. More specific examples (a non-exhaustive list) of computer-readable storage media include: portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disc read-only memory (CD-ROM), digital multifunction disc (DVD), memory sticks, floppy disks, mechanical encoding devices, such as punch cards or recessed protrusions storing instructions thereon, and any suitable combination thereof. The computer-readable storage media used herein are not to be construed as transient signals themselves, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (e.g., light pulses through fiber optic cables), or electrical signals transmitted through wires.

[0123] The computer-readable program instructions described herein can be downloaded from computer-readable storage media to various computing / processing devices, or downloaded via a network, such as the Internet, a local area network (LAN), a wide area network (WAN), and / or a wireless network, to an external computer or external storage device. The network may include copper cables, fiber optic cables, wireless transmission, routers, firewalls, switches, gateway computers, and / or edge servers. A network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and forwards them to the computer-readable storage media in the respective computing / processing device.

[0124] Computer program instructions used to perform the operations of this disclosure may be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, status setting data, or source code or object code written in any combination of one or more programming languages, including object-oriented programming languages ​​and conventional procedural programming languages. The computer-readable program instructions may execute entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving a remote computer, the remote computer may be connected to the user's computer via any type of network—including a local area network (LAN) or a wide area network (WAN)—or may be connected to an external computer (e.g., via the Internet using an Internet service provider). In some embodiments, electronic circuitry, such as programmable logic circuitry, field-programmable gate arrays (FPGAs), or programmable logic arrays (PLAs), is personalized by utilizing the status information of the computer-readable program instructions to implement various aspects of this disclosure.

[0125] These computer-readable program instructions can be provided to a processing unit of a general-purpose computer, a special-purpose computer, or other programmable data processing apparatus to produce a machine such that, when executed by the processing unit of the computer or other programmable data processing apparatus, they create means for implementing the functions / actions specified in one or more blocks of the flowchart and / or block diagram. These computer-readable program instructions can also be stored in a computer-readable storage medium that causes a computer, programmable data processing apparatus, and / or other device to operate in a particular manner. Thus, the computer-readable medium storing the instructions comprises an article of manufacture that includes instructions for implementing aspects of the functions / actions specified in one or more blocks of the flowchart and / or block diagram.

[0126] Computer-readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable data processing apparatus, or other device to produce a computer-implemented process, thereby causing the instructions executed on the computer, other programmable data processing apparatus, or other device to perform the functions / actions specified in one or more boxes of a flowchart and / or block diagram.

[0127] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of devices, methods, and computer program products according to various embodiments of the present disclosure. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of an instruction containing one or more executable instructions for implementing a specified logical function. In some alternative implementations, the functions marked in the blocks may occur in a different order than those marked in the drawings. For example, two consecutive blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, may be implemented using a dedicated hardware-based system that performs the specified function or action, or using a combination of dedicated hardware and computer instructions.

[0128] The various embodiments of this disclosure have been described above. These descriptions are exemplary and not exhaustive, nor are they limited to the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments. The terminology used herein is chosen to best explain the principles, practical applications, or technical improvements to the technology in the market, or to enable others skilled in the art to understand the embodiments disclosed herein.

[0129] The following are some example implementations of this disclosure.

[0130] Example 1. A method for event extraction, comprising:

[0131] Extract multiple named entities from a document as multiple event arguments, wherein the document includes at least two sentences;

[0132] Determine the event types in the document and the corresponding templates for those event types;

[0133] The plurality of event arguments are filled into the corresponding positions in the template to generate a plurality of candidate event records, wherein during the generation of the plurality of candidate event records, each candidate event record is iteratively generated based on previously generated candidate event records, starting from the second candidate event record among the plurality of candidate events; and

[0134] Filter the multiple candidate event records to obtain one or more target event records.

[0135] Example 2. According to the method described in Example 1, extracting multiple named entities as multiple event arguments from a document includes:

[0136] Encode multiple words in the document;

[0137] Determine multiple sentence representations associated with the encoded words; and

[0138] Decode the multiple sentence representations to obtain the multiple named entities.

[0139] Example 3. The method according to any one of Examples 1-2, wherein determining the event type in the document and the template corresponding to the event type includes:

[0140] Determine multiple entity vectors for the multiple named entities;

[0141] The multiple entity vectors are compressed to generate a set of candidate argument representations;

[0142] Determine multiple sentence vectors of the document;

[0143] The multiple sentence vectors are compressed to generate a sentence representation set; and

[0144] The event type is determined based on the candidate argument representation set and the sentence representation set.

[0145] Example 4. The method according to any one of Examples 1-3, wherein filling the plurality of event arguments into corresponding positions in the template to generate a plurality of candidate event records includes:

[0146] Determine the set of word representations for the template words; and

[0147] The candidate argument representation set and the word representation set are decoded to determine the candidate event record.

[0148] Example 5. The method according to any one of Examples 1-4, wherein decoding the candidate argument representation set and the word representation set to determine the candidate event record includes:

[0149] Based on the candidate argument representation set and the word representation set, a template representation associated with the event argument is generated;

[0150] Determine multiple probabilities representing multiple event arguments corresponding to multiple event roles;

[0151] Based on the multiple probabilities, filter the multiple event arguments to determine event arguments corresponding to the multiple event roles; and

[0152] The event arguments and the event roles are determined as the candidate event records.

[0153] Example 6. The method according to any one of Examples 1-5 further includes:

[0154] The first event argument in the first event record from the plurality of candidate event records and the template representation are compressed to generate a representation of the first event record; and

[0155] A second event record is generated based on the representation of the first event record, the sentence representation in the document, and the representation of the plurality of event arguments.

[0156] Example 7. The method according to any one of Examples 1-6, wherein filtering the plurality of candidate event records to obtain one or more target event records comprises:

[0157] Determine the candidate representation set of the plurality of candidate event records;

[0158] Based on the candidate representation set, the multiple sentence representations are filtered to determine multiple extraction scores of the multiple sentence representations; and

[0159] Based on the scores obtained from the multiple extractions, one or more target event records are determined.

[0160] Example 8. The method according to any one of Examples 1-7, wherein the method is executed in a trained machine learning model, and determining the one or more target event records based on the plurality of extraction scores during the training phase includes:

[0161] Determine the role loss associated with the plurality of extracted scores and the set of real event arguments as labels, wherein the set of real event arguments indicates a plurality of real event arguments and a plurality of corresponding event roles;

[0162] Based on the role loss function associated with the role loss, the plurality of candidate event records and their corresponding real event arguments are determined; and

[0163] Each of the multiple candidate event records is matched with its corresponding real event record.

[0164] Example 9. The method according to any one of Examples 1-8, wherein matching each event record in the plurality of candidate event records with a corresponding real event record includes:

[0165] Determine multiple filtering scores for the multiple candidate event records;

[0166] Determine the event loss associated with the multiple filter scores and the multiple real event records used as labels;

[0167] The total loss is determined based on the event loss and the role loss.

[0168] Determine the event recording loss function associated with the total loss; and

[0169] Based on the event recording loss function, the real event records are matched with the corresponding event records among the multiple candidate event records.

[0170] Example 10. The method according to any one of Examples 1-9, wherein training the machine learning model further includes:

[0171] Select the first event record from multiple event records;

[0172] Based on the score, event arguments are used to populate the event roles in the first event record; and

[0173] The machine learning model is trained based on the unfilled event roles in the first event record.

[0174] Example 11. The method according to any one of Examples 1-10, wherein populating event roles with event arguments based on scores includes:

[0175] In response to the score exceeding a threshold, event arguments with scores exceeding the threshold are populated into the corresponding event roles; and

[0176] Identify the remaining unfilled event roles; and

[0177] The remaining event roles are populated using the multiple event arguments.

[0178] Example 12. The method according to any one of Examples 1-11 further includes:

[0179] Calculate the role loss of the remaining event roles; and

[0180] The machine learning model is trained based on the role loss of the remaining event roles.

[0181] Example 13. An event extraction apparatus, comprising:

[0182] The named entity extraction module is configured to extract multiple named entities as multiple event arguments from a document, wherein the document includes at least two sentences;

[0183] An event type determination module is configured to determine the event types in the document and the templates corresponding to the event types;

[0184] An event record generation module is configured to fill the plurality of event arguments into corresponding positions in the template to generate a plurality of candidate event records, wherein during the generation of the plurality of candidate event records, each candidate event record is iteratively generated based on previously generated candidate event records, starting from the second candidate event record among the plurality of candidate events; and

[0185] The event logging filtering module is configured to filter the multiple candidate event records to obtain one or more target event records.

[0186] Example 14. The apparatus according to Example 13, wherein the named entity extraction module includes:

[0187] The first encoding module is configured to encode multiple words in the document;

[0188] The first sentence representation determination module is configured to determine multiple sentence representations associated with the encoded plurality of words; and

[0189] The named entity acquisition module is configured to decode the multiple sentence representations to obtain the multiple named entities.

[0190] Example 15. The apparatus according to any one of Examples 13-14, wherein the event type determining module comprises:

[0191] The entity vector determination module is configured to determine multiple entity vectors of the plurality of named entities;

[0192] The candidate argument representation set generation module is configured to compress the plurality of entity vectors to generate a candidate argument representation set;

[0193] A sentence vector determination module is configured to determine multiple sentence vectors of the document;

[0194] The sentence representation set generation module is configured to compress the plurality of sentence vectors to generate a sentence representation set; and

[0195] The second event type determination module is configured to determine the event type based on the candidate argument representation set and the sentence representation set.

[0196] Example 16. The apparatus according to any one of Examples 13-15, wherein the event logging generation module comprises:

[0197] The word representation set determination module is configured to determine the word representation set of template words for the representation template; and

[0198] The candidate event record generation module is configured to decode the candidate argument representation set and the word representation set to determine the candidate event record.

[0199] Example 17. The apparatus according to any one of Examples 13-16, wherein the candidate event record generation module comprises:

[0200] The template representation generation module is configured to generate template representations associated with event arguments based on the candidate argument representation set and the word representation set;

[0201] The probability determination module is configured to determine multiple probabilities representing multiple event arguments corresponding to multiple event roles;

[0202] The second event recording filtering module is configured to filter the multiple event arguments based on the multiple probabilities to determine event arguments corresponding to the multiple event roles; and

[0203] The second candidate event record determination module is configured to determine the event argument and the event role as the candidate event record.

[0204] Example 18. The apparatus according to any one of Examples 13-17 further includes:

[0205] The template representation compression module is configured to compress a first event argument from a first event record among the plurality of candidate event records and the template representation to generate a representation of the first event record; and

[0206] The second event record generation module is configured to generate a second event record based on the representation of the first event record, the sentence representation in the document, and the representation of the plurality of event arguments.

[0207] Example 19. The apparatus according to any one of Examples 13-18, wherein the event logging filtering module comprises:

[0208] The candidate representation set determination module is configured to determine the candidate representation set of the plurality of candidate event records;

[0209] An extraction score determination module is configured to filter the plurality of sentence representations based on the candidate representation set to determine multiple extraction scores for the plurality of sentence representations; and

[0210] The target event record determination module is configured to determine one or more target event records based on the multiple extracted scores.

[0211] Example 20. The apparatus according to any one of Examples 13-19, wherein the apparatus is a trained machine learning model, and the target event recording determination module during the training phase includes:

[0212] The first training module is configured to determine a role loss associated with the plurality of extracted scores and a set of real event arguments as labels, wherein the set of real event arguments indicates a plurality of real event arguments and a plurality of corresponding event roles.

[0213] The second training module is configured to determine the plurality of candidate event records and corresponding real event arguments based on a role loss function associated with the role loss; and

[0214] The third training module is configured to match each of the plurality of candidate event records with the corresponding real event record.

[0215] Example 21. The apparatus according to any one of Examples 13-20, wherein the third training module comprises:

[0216] The filtering score determination module is configured to determine multiple filtering scores for the multiple candidate event records;

[0217] The event loss determination module is configured to determine the event loss associated with the plurality of filter scores and the plurality of real event records as labels;

[0218] The total loss determination module is configured to determine the total loss based on the event loss and the role loss;

[0219] An event logging loss function determination module is configured to determine an event logging loss function associated with the total loss; and

[0220] The first matching module is configured to match real event records with corresponding event records among the multiple candidate event records based on the event record loss function.

[0221] Example 22. The apparatus according to any one of Examples 13-21 further includes:

[0222] The event log selection module is configured to select the first event log from multiple event logs;

[0223] The event role population module is configured to populate event roles in the first event record based on scores using event arguments; and

[0224] The fourth training module is configured to train the machine learning model based on the unfilled event roles in the first event record.

[0225] Example 23. The apparatus according to any one of Examples 13-22, wherein the event role filling module comprises:

[0226] The second event role filling module is configured to, in response to the score exceeding a threshold, fill the event arguments whose scores exceed the threshold into the corresponding event roles; and

[0227] The third event role filling module is configured to determine the remaining event roles that have not been filled in the first event record; and

[0228] The fourth event role filling module is configured to fill the remaining event roles using the multiple event arguments.

[0229] Example 24. The apparatus according to any one of Examples 13-23 further includes:

[0230] The role loss calculation module is configured to calculate the role loss of the remaining event role; and

[0231] The fifth training module is configured to train the machine learning model based on the role loss of the remaining event roles.

[0232] Example 25. An electronic device comprising:

[0233] Processor; and

[0234] A memory coupled to the processor, the memory having instructions stored therein, the instructions which, when executed by the processor, cause the electronic device to perform actions, the actions including:

[0235] Extract multiple named entities from a document as multiple event arguments, wherein the document includes at least two sentences;

[0236] Determine the event types in the document and the corresponding templates for those event types;

[0237] The plurality of event arguments are filled into the corresponding positions in the template to generate a plurality of candidate event records, wherein during the generation of the plurality of candidate event records, each candidate event record is iteratively generated based on previously generated candidate event records, starting from the second candidate event record among the plurality of candidate events; and

[0238] Filter the multiple candidate event records to obtain one or more target event records.

[0239] Example 26. An electronic device according to Example 25, wherein extracting multiple named entities as multiple event arguments from a document includes:

[0240] Encode multiple words in the document;

[0241] Determine multiple sentence representations associated with the encoded words; and

[0242] Decode the multiple sentence representations to obtain the multiple named entities.

[0243] Example 27. An electronic device according to any one of Examples 25-26, wherein determining the event type in the document and the template corresponding to the event type includes:

[0244] Determine multiple entity vectors for the multiple named entities;

[0245] The multiple entity vectors are compressed to generate a set of candidate argument representations;

[0246] Determine multiple sentence vectors of the document;

[0247] The multiple sentence vectors are compressed to generate a sentence representation set; and

[0248] The event type is determined based on the candidate argument representation set and the sentence representation set.

[0249] Example 28. An electronic device according to any one of Examples 25-27, wherein filling the plurality of event arguments into corresponding positions in the template to generate a plurality of candidate event records includes:

[0250] Determine the set of word representations for the template words; and

[0251] The candidate argument representation set and the word representation set are decoded to determine the candidate event record.

[0252] Example 29. An electronic device according to any one of Examples 25-28, wherein decoding the candidate argument representation set and the word representation set to determine the candidate event record includes:

[0253] Based on the candidate argument representation set and the word representation set, a template representation associated with the event argument is generated;

[0254] Determine multiple probabilities representing multiple event arguments corresponding to multiple event roles;

[0255] Based on the multiple probabilities, filter the multiple event arguments to determine event arguments corresponding to the multiple event roles; and

[0256] The event arguments and the event roles are determined as the candidate event records.

[0257] Example 30. The electronic device according to any one of Examples 25-29, wherein the operation further includes:

[0258] The first event argument in the first event record from the plurality of candidate event records and the template representation are compressed to generate a representation of the first event record; and

[0259] A second event record is generated based on the representation of the first event record, the sentence representation in the document, and the representation of the plurality of event arguments.

[0260] Example 31. An electronic device according to any one of Examples 25-30, wherein filtering the plurality of candidate event records to obtain one or more target event records comprises:

[0261] Determine the candidate representation set of the plurality of candidate event records;

[0262] Based on the candidate representation set, the multiple sentence representations are filtered to determine multiple extraction scores of the multiple sentence representations; and

[0263] Based on the scores obtained from the multiple extractions, one or more target event records are determined.

[0264] Example 32. An electronic device according to any one of Examples 25-31, wherein the action is performed in a trained machine learning model, and determining the one or more target event records based on the plurality of extraction scores during the training phase includes:

[0265] Determine the role loss associated with the plurality of extracted scores and the set of real event arguments as labels, wherein the set of real event arguments indicates a plurality of real event arguments and a plurality of corresponding event roles;

[0266] Based on the role loss function associated with the role loss, the plurality of candidate event records and their corresponding real event arguments are determined; and

[0267] Each of the multiple candidate event records is matched with its corresponding real event record.

[0268] Example 33. An electronic device according to any one of Examples 25-32, wherein matching each event record in the plurality of candidate event records with a corresponding real event record includes:

[0269] Determine multiple filtering scores for the multiple candidate event records;

[0270] Determine the event loss associated with the multiple filter scores and the multiple real event records used as labels;

[0271] The total loss is determined based on the event loss and the role loss.

[0272] Determine the event recording loss function associated with the total loss; and

[0273] Based on the event recording loss function, the real event records are matched with the corresponding event records among the multiple candidate event records.

[0274] Example 34. An electronic device according to any one of Examples 25-33, wherein training the machine learning model further includes:

[0275] Select the first event record from multiple event records;

[0276] Based on the score, event arguments are used to populate the event roles in the first event record; and

[0277] The machine learning model is trained based on the unfilled event roles in the first event record.

[0278] Example 35. An electronic device according to any one of Examples 25-34, wherein event roles are populated using event arguments based on scores, including:

[0279] In response to the score exceeding a threshold, event arguments with scores exceeding the threshold are populated into the corresponding event roles; and

[0280] Identify the remaining unfilled event roles; and

[0281] The remaining event roles are populated using the multiple event arguments.

[0282] Example 36. An electronic device according to any one of Examples 25-35, wherein the action further includes:

[0283] Calculate the role loss of the remaining event roles; and

[0284] The machine learning model is trained based on the role loss of the remaining event roles.

[0285] Example 37. A computer-readable storage medium having stored thereon one or more computer instructions, wherein the one or more computer instructions are executed by a processor to implement the method according to any one of Examples 1 to 12.

[0286] Example 38. A computer program product tangibly stored on a computer-readable medium and comprising computer-executable instructions that, when executed by a device, cause the device to perform the method according to any one of Examples 1 to 12.

[0287] Although this disclosure has been described using language specific to structural features and / or methodological logic, it should be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or actions described above. Rather, the specific features and actions described above are merely illustrative examples of implementing the claims.

Claims

1. A method for event extraction, comprising: Extract multiple named entities from a document as multiple event arguments, wherein the document includes at least two sentences; Determine the event types in the document and the corresponding templates for those event types; The plurality of event arguments are filled into the corresponding positions in the template to generate a plurality of candidate event records. During the generation of the plurality of candidate event records, each candidate event record is iteratively generated based on previously generated candidate event records, starting from the second candidate event record among the plurality of candidate events. The iterative generation includes: selecting candidate event records based on multiple scores of the plurality of candidate event records for the current iteration, and filling the remaining event arguments in the template after excluding the filling results, wherein the filling results are the result obtained by filling the template based on the selected candidate event records. as well as Filter the multiple candidate event records to obtain one or more target event records.

2. The method of claim 1, wherein extracting multiple named entities as multiple event arguments from a document comprises: Encode multiple words in the document; Determine multiple sentence representations associated with the encoded words; as well as Decode the multiple sentence representations to obtain the multiple named entities.

3. The method according to claim 1, wherein determining the event type in the document and the template corresponding to the event type includes: Determine multiple entity vectors for the multiple named entities; The multiple entity vectors are compressed to generate a set of candidate argument representations; Determine multiple sentence vectors of the document; The multiple sentence vectors are compressed to generate a sentence representation set; as well as The event type is determined based on the candidate argument representation set and the sentence representation set.

4. The method of claim 3, wherein filling the plurality of event arguments into corresponding positions in the template to generate a plurality of candidate event records comprises: Determine the set of word representations for the template words; as well as The candidate argument representation set and the word representation set are decoded to determine the candidate event record.

5. The method of claim 4, wherein decoding the candidate argument representation set and the word representation set to determine the candidate event record comprises: Based on the candidate argument representation set and the word representation set, a template representation associated with the event argument is generated; Determine multiple probabilities representing multiple event arguments corresponding to multiple event roles; Based on the multiple probabilities, the multiple event arguments are filtered to determine the event arguments corresponding to the multiple event roles; as well as The event arguments and the event roles are determined as the candidate event records.

6. The method of claim 5, further comprising: The first event argument in the first event record among the plurality of candidate event records and the template representation are compressed to generate a representation of the first event record; as well as A second event record is generated based on the representation of the first event record, the sentence representation in the document, and the representation of the plurality of event arguments.

7. The method according to any one of claims 2-6, wherein filtering the plurality of candidate event records to obtain one or more target event records comprises: Determine the candidate representation set of the plurality of candidate event records; Based on the candidate representation set, the multiple sentence representations are filtered to determine multiple extraction scores of the multiple sentence representations; as well as Based on the scores obtained from the multiple extractions, one or more target event records are determined.

8. The method of claim 7, wherein the method is performed in a trained machine learning model, and determining the one or more target event records based on the plurality of extraction scores during the training phase comprises: Determine the role loss associated with the plurality of extracted scores and the set of real event arguments as labels, wherein the set of real event arguments indicates a plurality of real event arguments and a plurality of corresponding event roles; Based on the role loss function associated with the role loss, the plurality of candidate event records and their corresponding real event arguments are determined; as well as Each of the multiple candidate event records is matched with its corresponding real event record.

9. The method of claim 8, wherein matching each event record in the plurality of candidate event records with a corresponding real event record comprises: Determine multiple filtering scores for the multiple candidate event records; Determine the event loss associated with the multiple filter scores and the multiple real event records used as labels; The total loss is determined based on the event loss and the role loss. Determine the event record loss function associated with the total loss; as well as Based on the event recording loss function, the real event records are matched with the corresponding event records among the multiple candidate event records.

10. The method of claim 9, wherein training the machine learning model comprises: Select the first event record from multiple event records; Based on the score, event arguments are used to populate the event roles in the first event record; as well as The machine learning model is trained based on the unfilled event roles in the first event record.

11. The method of claim 10, wherein populating event roles based on scores using event arguments comprises: In response to the score exceeding a threshold, event arguments with scores exceeding the threshold are populated into the corresponding event roles; Identify the remaining event roles that have not been filled in the first event record; as well as The remaining event roles are populated using the multiple event arguments.

12. The method of claim 11, further comprising: Calculate the role loss of the remaining event roles; as well as The machine learning model is trained based on the role loss of the remaining event roles.

13. An event extraction apparatus, comprising: The named entity extraction module is configured to extract multiple named entities as multiple event arguments from a document, wherein the document includes at least two sentences; An event type determination module is configured to determine the event types in the document and the templates corresponding to the event types; An event record generation module is configured to fill the plurality of event arguments into corresponding positions in the template to generate a plurality of candidate event records. During the generation of the plurality of candidate event records, each candidate event record is iteratively generated based on previously generated candidate event records, starting from the second candidate event record among the plurality of candidate events. The iterative generation includes: selecting candidate event records based on multiple scores of the plurality of candidate event records for the current iteration, and filling the template with the remaining event arguments after excluding the filling results. The filling results are obtained by filling the template based on the selected candidate event records. as well as The event logging filtering module is configured to filter the multiple candidate event records to obtain one or more target event records.

14. An electronic device, comprising: processor; as well as A memory coupled to the processor, the memory having instructions stored therein, which, when executed by the processor, cause the electronic device to perform the method according to any one of claims 1 to 12.

15. A computer-readable storage medium having stored thereon computer-executable instructions, wherein the computer-executable instructions are executed by a processor to implement the method according to any one of claims 1 to 12.

Images