An event extraction method, system and device based on multi-agent collaboration

Abstract

The present application discloses an event extraction method, system and device based on multi-agent collaboration. The method includes: receiving unstructured data, a first agent calling at least one second agent to identify entities and their types, and storing the results in an information pool; calling at least one third agent to identify trigger words and corresponding event types, and storing them in an information pool; parsing trigger words and event types, generating argument role sets; a fourth agent identifying argument roles, and storing the results in an information pool; dividing unstructured data into text units of different granularities such as sentences, paragraphs and chapters, generating corresponding context prompt information Prompt; calling an agent to perform event recognition on texts of each granularity, fusing event information of different granularities, and generating the final event extraction result. Through the collaborative work of multiple agents, more accurate event recognition and information integration are achieved, and the accuracy and efficiency of event extraction are improved.

Description

Technical Field

[0001] The present application relates to the field of big data technology, and in particular to an event extraction method, system and device based on multi-agent collaboration. Background Art

[0002] With the continuous development of natural language processing technology, event extraction has become one of the key tasks in the field of information extraction. Event extraction aims to identify events and their related entities, trigger words, and arguments (such as the time, location, participants, etc. of the event) from unstructured text. However, due to the semantic complexity of unstructured text and the diversity of event expressions, traditional event extraction methods show obvious limitations when facing large-scale and multi-type events.

[0003] The current event extraction methods mainly include the following:

[0004] Event extraction methods based on template matching: This type of method relies on predefined event templates to match text to identify events. However, template matching methods require manual construction of templates for a large number of event types, which is not only time-consuming and laborious, but also due to the variety of event description forms, a single template is difficult to adapt to diverse text expressions, resulting in insufficient generalization capabilities in practical applications.

[0005] Machine learning-based event extraction method: This method uses manually designed features to identify events, but these features are often shallow features based on vocabulary statistics and cannot abstract high-level semantic information of event descriptions. As a result, event extraction methods based on manual features are not effective in processing complex and multi-level semantic information and have difficulty capturing deep connections between events.

[0006] Event extraction methods based on deep learning: Deep learning methods can automatically learn complex features in text and have achieved good results. However, such methods usually rely on large-scale labeled data for training, and the data labeling cost is high. At the same time, the generalization ability of the model is often insufficient, and the effect is not satisfactory when dealing with new event types or cross-domain texts that have never been seen.

[0007] Event extraction methods based on pre-trained language models: In recent years, pre-trained language models (such as BERT and GPT) have made significant progress in natural language processing tasks. Through prompt-based learning technology, pre-trained language models can perform event extraction tasks with less labeled data, significantly reducing the reliance on manually labeled data. However, when dealing with complex chapter-level multi-event extraction tasks, such methods face the problems of insufficient semantic information and limited context understanding ability, especially difficult to handle cross-sentence and cross-paragraph event extraction.

[0008] In response to the limitations of the above-mentioned traditional methods, this patent proposes an event extraction method based on multi-agent collaboration. Summary of the invention

[0009] In order to solve the above technical problems, the present application provides an event extraction method, system and device based on multi-agent collaboration.

[0010] The technical solution provided in this application is described below:

[0011] The first aspect of the present application provides an event extraction method based on multi-agent collaboration, comprising:

[0012] Receiving unstructured data, calling at least one second agent through a first agent to perform entity recognition on the unstructured data, obtaining entities in the unstructured data and their corresponding entity types, and storing the recognition results in an information pool;

[0013] Calling at least one third agent to identify the trigger words in the unstructured data, obtain the corresponding event type, and store the identification results of the trigger words and the event type in the information pool;

[0014] Parsing the trigger words and event types, and generating an argument role set based on a predetermined event template library;

[0015] Calling at least one fourth agent to perform argument recognition on the argument role set, obtaining arguments and their corresponding role types, and storing the recognition results in an information pool;

[0016] Segmenting the unstructured data into text units of different granularities, including sentences, paragraphs, and chapters;

[0017] For each text unit, query the involved entities, trigger words, event types, arguments, and role types from the information pool, and integrate them to generate contextual prompt information of corresponding granularity;

[0018] Based on the context prompt information Prompt, call at least one intelligent agent to perform event recognition on the text at the sentence, paragraph and chapter granularity, and obtain and store corresponding event information;

[0019] Event information of different granularities is integrated to generate the final event extraction result.

[0020] Optionally, the parsing of the trigger word and the event type and generating an argument role set based on a predetermined event template library includes:

[0021] The first agent traverses all trigger words and event types and parses them to obtain argument roles in all events and form an argument role set;

[0022] The fourth agent is called by the first agent to perform argument recognition on each argument role in the argument role set to obtain all arguments and the argument roles corresponding to all arguments.

[0023] Optionally, the unstructured data is divided into text units of different granularities, including sentences, paragraphs and chapters, including:

[0024] Using the first agent, segment the unstructured text in the unstructured data into sentences respectively;

[0025] For each text unit, the involved entities, trigger words, event types, arguments, and role types are queried from the information pool, and the corresponding granular context prompt information is generated by integration, including:

[0026] For each sentence, query the involved entities, trigger words, event types, arguments and their corresponding argument roles from the information pool through the first agent;

[0027] Through the first intelligent agent, the entities, trigger words, event types, arguments and their corresponding argument roles obtained from the query are integrated to generate the first Prompt information corresponding to the sentence.

[0028] Optionally, the unstructured data is divided into text units of different granularities, including sentences, paragraphs and chapters, including:

[0029] Using the first agent, the unstructured text in the unstructured data is divided into paragraphs respectively;

[0030] For each text unit, the involved entities, trigger words, event types, arguments, and role types are queried from the information pool, and the corresponding granular context prompt information is generated by integration, including:

[0031] For each paragraph, query the involved entities, trigger words, event types, arguments and their corresponding argument roles from the information pool through the first agent;

[0032] Through the first intelligent agent, the entities, trigger words, event types, arguments and their corresponding argument roles obtained from the query are integrated to generate the second Prompt information corresponding to the paragraph.

[0033] Optionally, the unstructured data is divided into text units of different granularities, including sentences, paragraphs and chapters, including:

[0034] Using the first agent, the unstructured text in the unstructured data is divided into chapters respectively;

[0035] For each text unit, the involved entities, trigger words, event types, arguments, and role types are queried from the information pool, and the corresponding granular context prompt information is generated by integration, including:

[0036] For each chapter, the first agent queries the involved entities, trigger words, event types, arguments and their corresponding argument roles from the information pool;

[0037] Through the first intelligent agent, the entities, trigger words, event types, arguments and their corresponding argument roles obtained from the query are integrated to generate the third Prompt information corresponding to the chapter.

[0038] Optionally, based on the context prompt information Prompt, calling at least one intelligent agent to perform event recognition on texts at sentence, paragraph and chapter granularity, and obtaining and storing corresponding event information includes:

[0039] The first agent inputs the first prompt information integrated with the context prompt information as additional input content into the fifth agent;

[0040] Through the fifth agent, event recognition at the sentence granularity is performed based on the Prompt information, and the recognized first event information is returned to the information pool of the first agent.

[0041] Optionally, based on the context prompt information Prompt, calling at least one intelligent agent to perform event recognition on texts at sentence, paragraph and chapter granularity, and obtaining and storing corresponding event information includes:

[0042] Inputting the second Prompt prompt information integrated with the context prompt information as additional input content into the sixth agent;

[0043] Through the sixth agent, event recognition at the paragraph granularity is performed based on the Prompt information, and the recognized second event information is returned to the information pool of the first agent.

[0044] Optionally, based on the context prompt information Prompt, calling at least one intelligent agent to perform event recognition on texts at sentence, paragraph and chapter granularity, and obtaining and storing corresponding event information includes:

[0045] Inputting the third Prompt prompt information integrated with the context prompt information as additional input content into the seventh agent;

[0046] Through the seventh agent, chapter-level event recognition is performed based on the Prompt information, and the recognized third event information is returned to the information pool of the first agent.

[0047] Optionally, the fusing of event information of different granularities to generate a final event extraction result includes:

[0048] Performing similarity calculation on the sentence-level, paragraph-level and chapter-level event information by a first agent, wherein the similarity calculation is based on entity similarity, trigger word similarity, event type similarity and argument similarity;

[0049] When the similarity exceeds a preset threshold, merging similar event information through the first agent;

[0050] When there is a conflict between event types or argument roles, the chapter-level event information is given priority, and the argument roles are resolved in combination with the context information;

[0051] Supplement the details of sentence-level and paragraph-level event information, integrate the supplemented paragraph-level event information into the chapter-level event information, and generate a fused event containing detailed information;

[0052] The fused event information is sorted by the first agent to construct an event chain, where the event chain represents the time sequence and causal relationship between events;

[0053] Generate fused event extraction results.

[0054] Optionally, the similarity calculation of the sentence-level, paragraph-level and chapter-level event information by the first agent, wherein the similarity calculation is based on entity similarity, trigger word similarity, event type similarity and argument similarity and includes:

[0055] Calculate entity similarity, trigger word similarity, event type similarity, and argument similarity respectively;

[0056] And the total similarity is calculated by the following formula:

[0057] Total similarity = w1×entity similarity + w2×trigger word similarity + w3×event type similarity + w4×argument similarity;

[0058] Among them, w1, w2, w3, and w4 represent the corresponding weights respectively.

[0059] Optionally, the entity similarity, trigger word similarity, and argument similarity are calculated using the following formula:

[0060] Element similarity (e 1 ,e 2)=(V(e 1 )·V(e 2 )) / (||V(e 1 )||*||V(e 2 )||)

[0061] Where: V(e 1 ) and V(e 2 ) are the elements e 1 and element e 2 The vector representation of .

[0062] "·" represents the dot product of vectors.

[0063] "||V(e 1 )||" and"||V(e 2 )||"respectively represent the vector V(e 1 ) and V(e 2 ) model.

[0064] Optionally, the similarity of the event type is calculated using the following formula:

[0065] Event type similarity (C1, C2) = 1, if C1 = C2;

[0066] Event type similarity (C1, C2) = 0 if C1≠C2.

[0067] The second aspect of the present application provides an event extraction system based on multi-agent collaboration, the system comprising:

[0068] An entity recognition unit, configured to receive unstructured data, perform entity recognition on the unstructured data by invoking at least one second agent through a first agent, obtain entities in the unstructured data and their corresponding entity types, and store the recognition results in an information pool;

[0069] An event type processing unit, configured to call at least one third agent to identify the trigger word in the unstructured data, obtain the corresponding event type, and store the identification results of the trigger word and the event type in an information pool;

[0070] A parsing unit, used for parsing the trigger word and event type, and generating an argument role set based on a predetermined event template library;

[0071] Calling at least one fourth agent to perform argument recognition on the argument role set, obtaining arguments and their corresponding role types, and storing the recognition results in an information pool;

[0072] Segmenting the unstructured data into text units of different granularities, including sentences, paragraphs, and chapters;

[0073] For each text unit, query the involved entities, trigger words, event types, arguments, and role types from the information pool, and integrate them to generate contextual prompt information of corresponding granularity;

[0074] Based on the context prompt information Prompt, call at least one intelligent agent to perform event recognition on the text at the sentence, paragraph and chapter granularity, and obtain and store corresponding event information;

[0075] Event information of different granularities is integrated to generate the final event extraction result.

[0076] The third aspect of the present application provides an event extraction device based on multi-agent collaboration, the device comprising:

[0077] Processor, memory, input-output unit, and bus;

[0078] The processor is connected to the memory, the input and output unit, and the bus;

[0079] The memory stores a program, and the processor calls the program to execute the first aspect and any optional method in the first aspect.

[0080] A fourth aspect of the present application provides a computer-readable storage medium, on which a program is stored. When the program is executed on a computer, the program executes the first aspect and any optional method in the first aspect.

[0081] It can be seen from the above technical solutions that this application has the following advantages:

[0082] 1. By dividing unstructured data into text units of different granularity at the sentence, paragraph and chapter levels, it is possible to more accurately capture event information at different levels. This hierarchical processing method improves the comprehensiveness and accuracy of event extraction, especially when dealing with complex events at the chapter level.

[0083] 3. This method uses multiple agents to work together, each responsible for different tasks such as entity recognition, trigger word recognition, argument role recognition, etc., making the entire event extraction process more modular. Each agent focuses on a specific task, which improves efficiency and accuracy.

[0084] 4. Generate contextual prompt information by integrating entities, trigger words, event types, arguments and role types, and identify events at different granularities, effectively utilizing contextual information to improve the accuracy of event extraction.

[0085] 5. The recognition results of all agents are stored in the information pool, which supports sharing and querying of results by text units of different granularities. This information pool mechanism makes information exchange and result integration between agents more efficient, and ensures the consistency and integrity of multi-granularity event extraction results.

[0086] 6. By calculating and fusing the similarity of event information at the sentence, paragraph, and chapter levels, the differences and conflicts between event information of different granularities are resolved, ensuring that the final event extraction results are more accurate and have a global perspective.

[0087] 7. This method is specially optimized for chapter-level event recognition, enabling it to handle complex multi-event tasks at the chapter level, overcoming the limitations of traditional methods in chapter-level event extraction. BRIEF DESCRIPTION OF THE DRAWINGS

[0088] In order to more clearly illustrate the technical solution in the present application, the drawings required for use in the description of the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative work.

[0089] Figure 1 A schematic diagram of an embodiment of the event extraction method based on multi-agent collaboration provided in this application;

[0090] Figure 2 A flowchart of another embodiment of the event extraction method based on multi-agent collaboration provided in this application;

[0091] Figure 3 A flowchart of another embodiment of the event extraction method based on multi-agent collaboration provided in this application;

[0092] Figure 4 A schematic diagram of the structure of an embodiment of an event extraction system based on multi-agent collaboration provided in this application;

[0093] Figure 5 A schematic diagram of the structure of an embodiment of an event extraction device based on multi-agent collaboration provided in this application;

[0094] Figure 6 A schematic diagram of the structure of multi-agent collaboration provided in this application. DETAILED DESCRIPTION

[0095] It should be noted that the event extraction method based on multi-agent collaboration provided in this application can be applied to a terminal, a system, or a server. For example, the terminal can be a smart phone or a computer, a tablet computer, a smart TV, a smart watch, a portable computer terminal, or a fixed terminal such as a desktop computer. For the convenience of explanation, this application uses the terminal as an example for explanation.

[0096] See also Figure 1 The present application first provides an embodiment of an event extraction device method based on multi-agent collaboration, which includes:

[0097] S101, receiving unstructured data, calling at least one second agent through a first agent to perform entity recognition on the unstructured data, obtaining entities in the unstructured data and their corresponding entity types, and storing the recognition results in an information pool;

[0098] When the system receives unstructured data, the first agent will call at least one second agent to perform entity recognition on the unstructured data. Unstructured data can be irregular information formats such as text, documents, social media content, etc. The second agent will identify various entities (such as people, places, organizations, etc.) from it and determine the entity type of each entity (for example, whether the entity is a person, place, or organization name). The identified entities and their types are stored in the system's information pool for use by other agents in subsequent steps.

[0099] Unstructured data reception:

[0100] Unstructured data can be presented in various forms, common ones include:

[0101] Natural language text: such as news articles, blogs, and email content;

[0102] Speech-to-text recording;

[0103] Social media comments, forum posts, etc.

[0104] For example, suppose the system receives a news article that contains the following text:

[0105] "Apple Inc. unveiled its new iPhone on Monday. The Cupertino, California-based company's chief executive, Tim Cook, said iPhone sales will continue to grow through 2024."

[0106] The task of the second agent is to extract entities from unstructured data using natural language processing (NLP) technology. Entities can be important information elements such as people, places, organizations, dates, etc. This process includes the following steps:

[0107] Tokenization: Split an article or text into individual words. For example, the sentence "Apple released a new iPhone on Monday." will be broken down into ["Apple", "on", "Monday", "released", "new model", "iPhone"].

[0108] Part-of-speech tagging: tagging each word with its part of speech. For example, "Apple" is tagged as a noun, and "Monday" is tagged as a time word.

[0109] Named Entity Recognition (NER): Use a pre-trained model to identify entities. The second agent analyzes the text and extracts the entities and their types. For example:

[0110] "Apple Inc." is identified as an organization (ORG)

[0111] "Monday" is recognized as a date time (DATE)

[0112] "Cupertino, California" is recognized as a place name (GPE)

[0113] "Tim Cook" is identified as a person name (PERSON)

[0114] "iPhone" is identified as a product (PRODUCT)

[0115] Through this analysis, the system can not only identify entities in the text, but also assign entity types to each entity so that each entity is semantically correctly classified. For example:

[0116] "Apple": Organization

[0117] "Tim Cook": Name

[0118] "Cupertino, California": Geographic location

[0119] “iPhone”: Product

[0120] "Monday": Date time

[0121] After completing entity recognition, the second agent will store the recognition results in the system's information pool. The information pool is an integrated data structure that can store, update, and retrieve entity information extracted from different data sources. The information pool supports other agents in subsequent steps to quickly query and access recognition results. For example, the information pool stores the following structured information:

[0122]

[0123] The function of this information pool is to provide instant access to structured entity information for the subsequent processing steps of the system. The agent in the subsequent steps can query the information pool to obtain the entity and its type information in each text unit, and further complete the complex event extraction.

[0124] Suppose a user initiates a request to process a batch of news texts through the system. The system receives the following texts:

[0125] "Musk announced that SpaceX will launch a Mars exploration program in 2024."

[0126] Through entity recognition by the second agent, the system is able to extract the following entities:

[0127] "Musk" is identified as a person's name (PERSON)

[0128] "SpaceX" is identified as an organization (ORG)

[0129] "2024" is recognized as a date (DATE)

[0130] Mars is identified as a Geographical Position (GPE)

[0131] All identified entities and their types will be stored in the information pool for subsequent event analysis and processing.

[0132] S102, calling at least one third agent to identify the trigger words in the unstructured data, obtain the corresponding event type, and store the identification results of the trigger words and event types in the information pool;

[0133] After entity recognition is completed, the first agent will call at least one third agent to identify trigger words in the same unstructured data. Trigger words are key words that trigger events, such as "outbreak" and "occurrence". At the same time, the third agent will determine the associated event type based on the identified trigger words, such as disaster events, conference events, etc. The identification results of trigger words and event types are also stored in the information pool for further analysis and processing.

[0134] When entity recognition is complete, the system will start the next stage of processing: trigger word recognition. Trigger words are keywords that can trigger specific events. They play a symbolic role in the sentence and help the system recognize the occurrence of events. To complete this step, the first agent will call at least one third agent to complete the trigger word recognition and event type determination.

[0135] Trigger words are important signs of an event. For each event, there is usually a set of specific words or phrases to identify the event. For example, in a news report:

[0136] “Outbreak” can be used to identify disaster or war events;

[0137] “Holding” can identify a meeting event;

[0138] "Release" may identify a product release event.

[0139] Trigger words guide the system to determine the event type, that is, the category or nature of the event, such as a natural disaster, accident, meeting, crime, etc. Therefore, identifying trigger words helps the system infer the specific type of event, thereby helping to better understand what actually happened in the text.

[0140] Trigger word recognition relies on natural language processing (NLP) technology. The task of the third agent is to find trigger words that can trigger events from the text and classify the trigger words according to the context. The specific steps of trigger word recognition are as follows:

[0141] Similar to entity recognition, the third agent first tokenizes and tags the sentence to ensure that the position and part of speech of each word are clearly marked. For example, the sentence: "The volcano erupted last night." will be tokenized into ["volcano", "in", "last night", "erupt"], and "erupt" is marked as a verb.

[0142] The agent then locates the keywords that trigger the event based on a predefined list of trigger words (or a set of trigger words identified through model training). For example:

[0143] In the sentence “The volcano erupted last night,” the agent would recognize that “erupt” is the trigger word;

[0144] In the sentence “The company will hold its annual general meeting this week,” the agent would recognize that “hold” is the trigger word.

[0145] After identifying the trigger word, the third agent will analyze its context and combine it with the pre-trained model to determine the event type associated with the trigger word. Different trigger words correspond to different event types. For example:

[0146] “Eruption” may be related to natural disasters (such as volcanoes, epidemics, etc.);

[0147] “Convene” is usually associated with conference events;

[0148] A "launch" is usually associated with a product launch or press release event.

[0149] Based on the trigger word and its associated context, the system is able to determine the event type. For example:

[0150] “Outbreak” is associated with the natural disaster event type;

[0151] “Convene” is associated with the meeting event type;

[0152] Release is associated with the product release event type.

[0153] Trigger word recognition example:

[0154] Suppose the system receives the following text:

[0155] "In 2024, an active volcano in the Pacific Ocean erupted again, causing thousands of people to evacuate."

[0156] The third agent first identifies that “burst” is the trigger word of the sentence;

[0157] Based on contextual information (such as “active volcano”, “evacuation”, etc.), the system infers that the event type triggered by “eruption” is a natural disaster event.

[0158] Another example:

[0159] "The company will hold a press conference next week to introduce its new smartphone."

[0160] The third agent recognizes that "hold" is a trigger word;

[0161] Based on the context (e.g., “press conference,” “introduction of new smartphones”), the system infers that the event type is a meeting event.

[0162] Once the third agent recognizes the trigger word and its associated event type, these results will be stored in the information pool together with the previous entity recognition results. For example:

[0163]

[0164] The trigger words and event type data in the information pool can be used by subsequent steps and other agents. For example, when the system needs to generate chapter-level event extraction results, these trigger words and event type information can be combined with entity information, argument information, etc. for higher-granularity analysis.

[0165] Trigger word recognition plays a key role in the entire event extraction process. By locating trigger words, the system can effectively identify the type of event that occurred in a certain text unit (sentence, paragraph or chapter). Trigger words not only help the system understand the occurrence of events, but also provide important clues for subsequent argument role recognition, event fusion, etc.

[0166] S103, parsing the trigger word and event type, and generating an argument role set based on a predetermined event template library;

[0167] After the trigger words and event types are identified and stored, the first agent will parse these data and generate a set of argument roles based on the predefined event template library. The event template library contains predefined frameworks for different events, which helps the system associate trigger words with possible roles. For example, an "accident" event may involve roles such as "victim" and "perpetrator". This step generates a corresponding set of roles based on the event type and template library, providing a basis for subsequent argument recognition.

[0168] In step S102, the system has identified the trigger words in the text and their corresponding event types through the third agent. These data are stored in the information pool and used as input for the next parsing step. For example:

[0169] Trigger word: Outbreak

[0170] Event Type: Natural disaster event

[0171] In this step, the first agent needs to parse these recognition results and associate them with the predetermined event framework. This means that the system must not only know the type of event (such as natural disasters, traffic accidents, meetings, etc.), but also understand the specific roles that may be involved in the event.

[0172] The system's event template library contains a series of predefined event frames that contain common argument roles in each event type. Argument roles are the participants or elements involved in the event, such as:

[0173] In a traffic accident, the argument roles may include: the perpetrator, the victim, the accident vehicle, the police, etc.;

[0174] In natural disaster events, argument roles may include: victims, rescuers, affected areas, etc.;

[0175] In a conference event, argument roles may include: moderator, attendee, speaker, etc.

[0176] The roles in these event templates provide a framework for subsequent argument identification.

[0177] Based on the trigger word and event type, the system will then search for a template corresponding to the current event type in the event template library. For example, if the event type detected by the system is a natural disaster event, a template related to natural disaster events will be called from the event template library, which may contain the following roles:

[0178] Victims: refers to individuals or groups harmed or affected by a disaster;

[0179] Rescuers: refers to individuals or organizations involved in disaster relief;

[0180] Affected area: The geographical area affected by the disaster;

[0181] Disaster type: specific type of natural disaster, such as earthquakes, volcanic eruptions, floods, etc.

[0182] The system will generate a corresponding argument role set based on the event type and template library. This argument role set lists all the argument roles that may be involved in the event type, providing basic data for the next step of argument identification (step S104).

[0183] The system matches the identified event types (such as natural disasters and traffic accidents) with the corresponding templates in the event template library.

[0184] Extract the possible argument roles of the event from the template that matches the event type. For example:

[0185] A natural disaster template might have roles such as “victims,” “rescuers,” and “affected areas”;

[0186] A traffic accident template may include roles such as "perpetrator", "victim", and "accident vehicle".

[0187] The extracted argument roles form a set, representing the roles that may appear in the event type. For example, for a natural disaster event, the generated role set may be:

[0188] {

[0189] "Event Type": "Natural Disaster",

[0190] "Argument role set": ["victims", "rescuers", "affected areas"]

[0191] }

[0192] Assume that the text contains the following information:

[0193] "The volcanic eruption caused a large number of residents to evacuate, and local rescue forces arrived quickly."

[0194] In the previous stage, the system has identified:

[0195] Trigger word: Outbreak

[0196] Event Type: Natural disaster event

[0197] At this point, the system will search for templates related to "natural disaster events" in the event template library and extract a set of possible argument roles, such as:

[0198] victims (evacuated residents);

[0199] Rescue workers (local rescue forces);

[0200] Affected area (affected area around the volcano).

[0201] The system generates a set of argument roles based on the template:

[0202] {

[0203] "Event Type": "Natural Disaster",

[0204] "Argument role set": ["victims", "rescuers", "affected areas"]

[0205] }

[0206] {

[0207] "Event Type": "Natural Disaster",

[0208] "Argument role set": ["victims", "rescuers", "affected areas"]

[0209] }

[0210] In step S103, the system analyzes the identified trigger words and event types, and generates a corresponding argument role set in combination with the preset event template library. This role set provides a clear role framework for the subsequent argument identification step, allowing the system to accurately identify the key participating roles in different events during the event extraction process.

[0211] S104, calling at least one fourth agent to perform argument recognition on the argument role set, obtaining arguments and their corresponding role types, and storing the recognition results in an information pool;

[0212] The first agent then calls at least one fourth agent to perform argument recognition using the argument role set generated in the previous step. In this process, the system identifies specific arguments in the text, that is, participants or objects related to the event, and assigns each argument to the corresponding role type. For example, in a fire incident, the identified arguments may be "building" and "firefighter", corresponding to the role types "victim" and "emergency personnel", respectively. The recognition results continue to be stored in the information pool.

[0213] In step S104, the system calls at least one fourth agent and uses the argument role set generated in the previous step to identify the arguments in the text. The core task of argument identification is to find specific participants or objects related to the event from the text and associate these arguments with their corresponding role types. This step further refines the results of event extraction and converts the abstract role type into actual event participants or objects.

[0214] In the previous stage (step S103), the system has generated a set of argument roles related to the current event type. This set includes various roles that may be involved in the event. For example, for the "fire" event, the argument role set may include:

[0215] victim

[0216] Emergency personnel

[0217] Disaster location

[0218] These roles provide a framework for the next step of argument identification, and the fourth agent will identify the actual arguments based on this framework.

[0219] The fourth agent is designed as a component specifically responsible for extracting arguments from text. In this process, the fourth agent identifies specific arguments in the text one by one according to the argument role set. For example, if the argument role set contains the two roles of "victim" and "emergency personnel", the agent will search the text for the actual participants corresponding to these two roles. This process involves natural language processing techniques such as named entity recognition (NER) and context analysis.

[0220] The fourth agent will perform a deep scan of the text, looking for objects that match each role in the argument role set. For example:

[0221] For the role of “victim,” the agent might look for words in the text that represent people or groups (such as “residents,” “injured,” etc.).

[0222] For the role “emergency worker,” the agent might recognize entities related to rescue (e.g., “firefighter,” “paramedic”).

[0223] For “disaster location,” the agent might identify entities related to geographic locations (e.g., “city,” “building”).

[0224] The agent not only relies on vocabulary matching, but also needs to analyze the context to ensure that the recognized arguments are consistent with the logic of the event. For example, after the agent recognizes "residents", it will confirm through the context that these "residents" were affected by the fire before marking them as "victims".

[0225] Once specific arguments are identified, the agent associates them with role types from the argument role set. For example:

[0226] After the resident is identified as an argument, the agent assigns it to the role type “victim”;

[0227] After the firefighter is identified as an argument, the agent assigns it to the role type "emergency personnel".

[0228] Once the fourth agent completes the argument recognition, the recognition results are stored in the information pool of the system. These results include the specific names of the arguments and the role types to which they belong. For example:

[0229] {

[0230] "Argument": "Resident",

[0231] "Role Type": "Victim"

[0232] },

[0233] {

[0234] "Argument": "Firefighter",

[0235] "Role Type": "Emergency Personnel"

[0236] },

[0237] {

[0238] "Argument": "Commercial Building",

[0239] "Role Type": "Disaster Location"

[0240] }

[0241] The following provides an example for analysis:

[0242] Suppose the text is as follows:

[0243] "Yesterday, a fire broke out in a commercial building in the city center. Hundreds of residents were urgently evacuated, and local firefighters quickly arrived and launched rescue operations."

[0244] In the previous stage, the system has generated an argument role set related to the "fire" event:

[0245] Victim

[0246] Emergency Personnel

[0247] Disaster Location

[0248] Next, the fourth agent performs argument recognition on the text. Through context analysis, the agent identifies that:

[0249] Resident corresponds to "Victim";

[0250] Firefighter corresponds to "Emergency Personnel";

[0251] Commercial Building corresponds to "Disaster Location".

[0252] The recognized arguments and role types are stored as:

[0253] {

[0254] "Argument": "Resident",

[0255] "Role Type": "Victim"},{

[0256] "Argument": "Firefighter",

[0257] "Role Type": "Emergency Personnel"},{

[0258] "Argument": "Commercial Building",

[0259] "Role Type": "Disaster Location"}

[0260] In step S104, the system accurately identifies the arguments in the text by calling the fourth agent and using the argument-role set generated previously. Each identified argument is assigned to the corresponding role type, and the identification results are stored in the information pool, providing a basis for subsequent event information fusion. This process ensures that the system can accurately classify and analyze specific participants during the event extraction process, making the event information more comprehensive and structured.

[0261] S105. Segment the unstructured data into text units of different granularities, including sentences, paragraphs, and chapters;

[0262] To process information at different levels, the system will segment the unstructured data into text units of different granularities, including sentence level, paragraph level, and chapter level. This hierarchical processing allows the system to identify events at different granularities, which helps to capture details and more complex event structures.

[0263] In this embodiment, unstructured data generally refers to data forms that are not strictly organized, such as articles, social media content, emails, reports, etc. To improve the analysis efficiency of the system, the system needs to segment these data to form text units at multiple levels, mainly including:

[0264] Sentence level: The unstructured data is segmented by sentence, and each sentence becomes the smallest analysis unit. This helps the system to identify events at the finest granularity and is particularly suitable for processing texts with short and single events.

[0265] Paragraph level: The text is segmented by paragraph. A paragraph usually contains multiple related sentences and expresses a complete view or event. Paragraph-level analysis helps the system to capture information associations among multiple sentences.

[0266] Chapter level: A chapter is the highest level of the text and represents the complete structure of the entire data. Chapter-level analysis helps the system to understand the overall event context of the text from a global perspective and identify more complex, cross-paragraph events.

[0267] Segmentation method

[0268] Sentence-level segmentation: The system first divides the text according to punctuation marks (such as period, question mark, exclamation mark, etc.). Each sentence is treated as an independent analysis unit. For example, the text:

[0269] "A fire broke out in the city center. Firefighters quickly arrived at the scene and started rescue work."

[0270] After segmentation, two sentence units are obtained:

[0271] Sentence 1: "There was a fire in the city center."

[0272] Sentence 2: "The firefighters quickly arrived at the scene and started rescue work."

[0273] Paragraph-level segmentation: A paragraph usually consists of multiple related sentences, and paragraphs are usually separated by line breaks or special formatting marks. The system will divide paragraph units by detecting line breaks or paragraph marks. For example:

[0274] "A fire broke out in the city center. Firefighters quickly arrived at the scene and started rescue work.\n The fire was quickly brought under control and there were no casualties."

[0275] After paragraph-level segmentation, two paragraph units are obtained:

[0276] Paragraph 1: Contains the sentence "A fire broke out in the city center. Firefighters quickly arrived at the scene and started rescue work."

[0277] Paragraph 2: Includes the sentence "The fire was quickly brought under control and no one was injured."

[0278] Chapter-level segmentation: Chapter is the overall segmentation of the entire document. Chapter-level segmentation helps analyze the macro events in the entire document, especially when a text contains multiple interrelated events. For example, the system may analyze an entire report or news article involving the development and background of different events.

[0279] Sentence-level segmentation allows the system to accurately extract events at the smallest unit, and is particularly suitable for processing simple events in a single sentence. For example, a sentence such as "a fire broke out in the city center" contains a single event, and the system can easily identify the event type and trigger words.

[0280] Paragraph-level segmentation helps the system capture the event relationship between multiple sentences. For example, in the same paragraph, the relationship between "firefighters quickly arrived at the scene and started rescue work" and "the fire was under control" can be derived through paragraph-level analysis, thus capturing the temporal order and causal relationship of events.

[0281] Chapter-level segmentation provides a macroscopic view of the entire text and is suitable for analyzing cross-paragraph, complex event structures. For example, the entire article may describe the entire process from the occurrence of a fire to the end of rescue. Through chapter-level analysis, the system can integrate information from different stages to form a complete event description.

[0282] After each granular text unit is segmented, the system will mark and store it for easy subsequent retrieval. For example, the system may assign a unique identifier to each unit so that subsequent steps (such as S106) can query the information pool for information such as entities, trigger words, event types, and arguments related to the specific unit.

[0283] After the text units are segmented into different granularities, the system can perform more accurate event recognition at each granularity level. In the next steps (S106 and S107), the system will generate contextual prompt information based on each text unit, combined with entities, trigger words, event types and argument roles in the information pool, and perform event recognition and information fusion.

[0284] In step S105, the system ensures that events can be identified and extracted at different levels by dividing unstructured data into text units of different granularities, such as sentence level, paragraph level, and chapter level. This multi-granular processing method allows the system to identify single details while capturing complex event structures from a global perspective. This flexible processing mechanism improves the system's event recognition capabilities and enhances the comprehensive understanding of complex events.

[0285] S106, for each text unit, query the involved entities, trigger words, event types, arguments and role types from the information pool, and integrate and generate context prompt information Prompt of corresponding granularity;

[0286] In this embodiment, after being segmented into text units of different granularities, the first agent will query the information pool to obtain entities, trigger words, event types, arguments, and their role types related to each text unit. The system integrates this information and generates contextual prompts corresponding to each text unit (sentence, paragraph, chapter). These prompts contain all relevant contextual information, helping the system to more accurately identify events in subsequent steps.

[0287] In this embodiment, after the previous steps, the information pool has stored various types of information related to the text unit, including:

[0288] Entity: Entity information such as people, places, organizations, etc. that appear in the text.

[0289] Trigger word: a key verb or vocabulary related to an event, indicating the occurrence of an event or the start of an action.

[0290] Event type: The specific event type corresponding to the trigger word, such as disaster events, social events, etc.

[0291] Argument: A participant or object related to an event in a text, representing a specific role.

[0292] Role type: The type of role the argument plays in the incident, such as victim, emergency responder, witness, etc.

[0293] The system needs to retrieve this data from the information pool for each text unit through the first agent to ensure that all relevant information can be integrated.

[0294] The system processes text units of different granularities, and the context prompt information (Prompt) corresponding to each unit may cover different ranges:

[0295] Sentence level: The prompt generated for a single sentence usually contains only one event related to the sentence and its trigger words, entities, and arguments.

[0296] Paragraph level: A paragraph may involve multiple related events. The system needs to query and integrate the information in all sentences from the information pool to generate a more complex prompt that covers multiple events and their related roles.

[0297] Chapter level: Chapters usually represent the structure of the entire text, which may describe the occurrence of a series of events. The system needs to integrate all events, roles, trigger words, and entity information involved in the entire text to generate a chapter-level prompt to help identify more complex event relationships and contexts.

[0298] Prompt is a piece of context information generated by the system to guide subsequent event recognition and processing. It contains various types of information queried and integrated from the information pool. The generation process of each prompt is as follows:

[0299] Entity extraction: The system queries all entity information related to the text unit, such as names of people, places, institutions, etc., and adds them to the prompt. Entities provide the basis for subsequent event analysis.

[0300] Trigger word identification: retrieve trigger words in text units from the information pool. These words usually indicate the occurrence of events or important actions, such as "outbreak", "convening", etc. Trigger words help determine the time or starting point of an event.

[0301] Event type identification: Based on the trigger word, the system finds the corresponding event type from the information pool and determines what type of event the event belongs to (such as disaster events, meeting events, etc.). Event types provide Prompt with clear event classifications to help the system identify events of different natures.

[0302] Arguments and role types: Extract arguments (event participants) related to the event from the information pool and assign each argument to the corresponding role type. For example, in a fire incident, the arguments may be "firefighter" or "victim", and the role types may be "emergency personnel" or "victim". Integrating arguments and their roles into Prompt can help the system understand the identity and role of each participant in subsequent processing.

[0303] Suppose the system is processing the following text unit:

[0304] "Yesterday, a serious fire broke out in the city center. Firefighters quickly arrived at the scene and launched a rescue operation. The fire was put out two hours later without causing any casualties."

[0305] The system processes the text at the sentence level, and each sentence will generate a corresponding context prompt information:

[0306] Sentence 1: "A serious fire broke out in the city center yesterday."

[0307] Entity: "Downtown"

[0308] Trigger word: "happen"

[0309] Event type: Disaster event (fire)

[0310] Argument: "fire"

[0311] Role Type: Event Core

[0312] Prompt generation: {"entity": "city center", "trigger word": "occurrence", "event type": "disaster event (fire)", "argument": "fire", "role type": "event core"}

[0313] Sentence 2: "The firefighters quickly arrived at the scene and launched a rescue operation."

[0314] Entity: "Firefighter"

[0315] Trigger word: "expand"

[0316] Event type: Emergency rescue event

[0317] Argument: "firefighter"

[0318] Role type: Emergency responder

[0319] Prompt generation: {"entity": "firefighter", "trigger word": "expand", "event type": "emergency rescue event", "argument": "firefighter", "role type": "emergency personnel"}

[0320] Sentence 3: "The fire was put out two hours later and no one was injured."

[0321] Entity: "Fire"

[0322] Trigger word: "extinguish"

[0323] Event type: Emergency rescue event (result)

[0324] Argument: "fire"

[0325] Role Type: Disaster Event

[0326] Prompt generation: {"entity": "fire", "trigger word": "extinguish", "event type": "emergency rescue event (result)", "argument": "fire", "role type": "disaster event"}

[0327] For each text unit, the system generates a corresponding prompt based on the queried entity, trigger word, event type, and argument role type. These prompts provide a fine-grained understanding of the text by integrating various contextual information, which helps with event processing in subsequent steps. The system may generate prompts at multiple levels, for example:

[0328] Sentence-level prompt: Accurately captures events and participants in a single sentence, helping the system recognize simple events.

[0329] Paragraph-level prompt: Integrates the event information of the entire paragraph and captures the relationship between events.

[0330] Paragraph-level prompts: provide a global perspective to help understand the macro structure of cross-paragraphs and complex events.

[0331] The generated prompts will be used in subsequent steps, such as event recognition and information fusion in S107. Through these prompts, the system can more accurately identify events from the text, analyze causal relationships, and integrate multiple events and argument information to form a complete event report or analysis result.

[0332] S107, based on the context prompt information Prompt, calling at least one intelligent agent to perform event recognition on the text at the sentence, paragraph and chapter granularity, and obtaining and storing corresponding event information;

[0333] In this embodiment, after regenerating the context prompt, the first agent will call at least one agent to perform event recognition on the text at the sentence level, paragraph level and chapter level respectively. Based on the generated context prompt information Prompt, the agent can use the information therein to perform more accurate event recognition. Sentence-level recognition captures detailed events, paragraph-level recognition focuses on the event association between multiple sentences, and chapter-level recognition aims to capture complex event structures across paragraphs or even the entire text. The recognized event information is stored in the information pool.

[0334] In this embodiment, contextual prompt information provides clear clues for event recognition, including entities, trigger words, event types, arguments and their role types, etc. Each text unit corresponds to its own independent prompt, which serves as the input of the agent and provides detailed contextual information for event recognition.

[0335] The system calls the agent for each text unit and performs event recognition based on the information contained in the prompt:

[0336] Entities provide the core participants or objects for an event.

[0337] Trigger words indicate a key action or change in an event.

[0338] The event type determines the category of the identified event.

[0339] Arguments and their role types clarify the specific roles of each participant in the incident, such as victim, witness, executor, etc.

[0340] According to the different granularity of the text (sentence level, paragraph level, chapter level), the agent performs event recognition tasks at different levels:

[0341] Sentence-level event recognition

[0342] A sentence is the smallest unit of text, usually describing a single action or event. Sentence-level event recognition focuses on capturing fine-grained event details in a sentence.

[0343] The agent recognizes the event described by the sentence through the trigger words and entities in the prompt. For example, for the sentence "firefighters quickly arrived at the scene", the agent can recognize that "arrived" is the event trigger word and the associated entity is "firefighter", thus determining that this is an "emergency rescue event".

[0344] The identified event information, including event type, participating entities and their roles, is stored in the information pool.

[0345] Paragraph-level event recognition

[0346] A paragraph usually contains multiple sentences and may describe multiple aspects of a complex event or contain multiple related events. Paragraph-level event recognition needs to consider the connections between sentences and the overall context.

[0347] The agent uses the contextual information in the prompt to identify multiple events in the paragraph and determine the relevance between these events. For example, in a paragraph describing the occurrence of a fire, the rescue of firefighters, and the process of extinguishing the fire, the agent can recognize that these events are interrelated.

[0348] The event information recognized at the paragraph level includes not only the independent description of each event, but also the correlation between events (such as causal relationships), and stores this information in the information pool.

[0349] Chapter-level event recognition

[0350] A chapter is a larger text unit, which may contain multiple paragraphs and describe multiple events or the whole picture of a complex event. Chapter-level event recognition focuses more on the structure and time development process of the overall event.

[0351] Based on the prompts in the passage, the agent identifies cross-paragraph events and their relevance. For example, in one passage, the agent may identify the entire chain of events from the occurrence of a fire to the subsequent investigation and recovery. This includes not only the identification of each event, but also the role changes, timelines, and complex event relationships across paragraphs.

[0352] The event information recognized at the chapter level is more comprehensive. The intelligent system will store the global event description and the connection between each event, and record this information in the information pool.

[0353] S108: Fuse event information of different granularities to generate a final event extraction result.

[0354] After identifying event information at each granularity, the first agent will fuse this information. The system integrates sentence, paragraph, and chapter-level events based on event similarity calculations (such as similarity of entities, trigger words, event types, and arguments). The goal of fusion is to eliminate redundancy and conflict and generate a consistent, final event extraction result. These results combine perspectives of different granularities, allowing event extraction to reflect both details and present global event information.

[0355] Here is an example:

[0356] Suppose the system is processing the following text:

[0357] "Last night, a large-scale fire broke out in the city center. Firefighters quickly arrived at the scene and launched a fire-fighting operation. After two hours of efforts, the fire was finally brought under control."

[0358] Through the contextual prompt information Prompt, the system can perform the following event recognition:

[0359] Sentence Level Recognition:

[0360] The first sentence is: "A large-scale fire broke out in the city center", the trigger word is "occurred", the event type is "disaster event", the argument is "fire", and the role type is "event core".

[0361] The second sentence: "Firefighters quickly arrived at the scene and launched fire-fighting operations." The trigger words are "arrived" and "launched," the event type is "emergency rescue incident," the argument is "firefighter," and the role type is "emergency personnel."

[0362] The third sentence: "The fire was finally brought under control", the trigger word is "controlled", the event type is "emergency rescue event (result)", the argument is "fire", and the role type is "disaster event".

[0363] Paragraph-level recognition:

[0364] Recognizing that this is a paragraph describing a fire incident, which contains events such as "fire occurred", "firefighters rescued" and "fire was controlled", the intelligent agent can identify the correlation between these events, that is, the firefighters' rescue actions were the reason for the fire being controlled.

[0365] Chapter-level recognition:

[0366] If the entire chapter further describes the post-incident follow-up work, chapter-level event recognition can identify the entire process of the fire incident, including the occurrence of the incident, the rescue process and subsequent processing.

[0367] In step S107, based on the generated contextual prompt information, the system calls at least one intelligent agent to perform event recognition on the text at the sentence, paragraph and chapter granularity. Event recognition tasks of different granularities have different focuses. The system processes fine-grained single-sentence events, event associations within paragraphs, and complex event structures within chapters. The recognized event information will be stored in the information pool to provide a data basis for subsequent information analysis and decision support.

[0368] See also Figure 2 The present application also provides a specific embodiment of a method, which provides a specific implementation method for generating argument roles. The embodiment is described in detail below:

[0369] S201, receiving unstructured data, calling at least one second agent through a first agent to perform entity recognition on the unstructured data, obtaining entities in the unstructured data and their corresponding entity types, and storing the recognition results in an information pool;

[0370] S202, calling at least one third agent to identify the trigger words in the unstructured data, obtain the corresponding event type, and store the identification results of the trigger words and event types in the information pool;

[0371] S203, traversing all trigger words and event types and parsing them through the first agent to obtain argument roles in all events and form an argument role set;

[0372] In step S203, the system traverses and parses all identified trigger words and event types through the first agent, thereby extracting relevant argument roles from the event and forming a complete argument role set. The goal of this step is to associate each participant (argument) in the event with its corresponding role, providing a basis for subsequent argument recognition.

[0373] In the previous steps, the system has identified multiple trigger words and corresponding event types through text analysis. These trigger words represent the occurrence, change, or end of an event, and the event type associates the trigger words with specific event categories, such as natural disasters, accidents, meetings, etc.

[0374] The first agent will traverse each trigger word and event type, and through in-depth analysis of the events, identify the argument roles that may be involved in these events.

[0375] The first agent parses each event type according to a predefined event template library. The event template library contains the structural framework of different events and common role types. By analyzing the event type, the system can predict which argument roles are usually involved in a specific type of event.

[0376] For example, in a traffic accident, the template library may define argument roles such as "perpetrator", "victim", and "witness"; while in a natural disaster, the template library may define argument roles such as "disaster victims", "rescuers", and "the disaster itself".

[0377] After parsing each event, the first agent will integrate all identified argument roles (such as participants or important objects in the event) according to the event type and related trigger words to form an argument role set.

[0378] This argument role set contains all possible arguments and their corresponding role types in all current events. This set provides the basis for argument recognition in subsequent steps, ensuring that the system can accurately associate each argument with the correct role in complex text processing.

[0379] Example:

[0380] Assume that the system recognizes the following trigger words and event types:

[0381] Trigger words: "occurrence", "extinguish"

[0382] Event type: "fire", "rescue"

[0383] By traversing these trigger words and event types, the system will parse out the relevant argument roles, such as "victims" and "rescuers" in the "fire" event. These roles will then be integrated into the argument role set.

[0384] S204, calling a fourth agent through the first agent to perform argument recognition on each argument role in the argument role set to obtain all arguments and argument roles corresponding to all arguments;

[0385] In step S204, the system calls the fourth agent through the first agent to perform specific argument recognition on each argument role in the argument role set generated in the previous step. Through this step, the system can accurately extract each argument (i.e., the actual participant or object in the event) from the text and assign it to the correct argument role.

[0386] In step S204, the first agent will call one or more fourth agents based on the generated argument role set to perform a specific argument recognition task. The main responsibility of the fourth agent is to extract the actual participants or event objects (i.e., arguments) from the text and match them with the corresponding argument roles.

[0387] The fourth agent locates the specific arguments in each event through in-depth analysis of the text. For example, in a fire event, the system needs to identify that the argument "fire" may correspond to a specific entity such as "building" or "forest", and that the entity corresponding to "rescuer" may be "firefighter".

[0388] During argument recognition, the agent will combine contextual prompts and argument role sets to ensure that each argument is matched with the appropriate role. For example, if a paragraph describes "fire" and "firefighters", the fourth agent will match "fire" to the "disaster victim" role and "firefighter" to the "rescuer" role based on the context.

[0389] After all arguments are identified, the system will store the identification results (including each argument and its corresponding role type) in the information pool. The data in the information pool will be used for subsequent event analysis and further decision support.

[0390] By accurately matching arguments to roles, the system is able to construct a complete framework of the event, including all participants in the event, their roles, and their role in the event.

[0391] Example:

[0392] In the case of a traffic accident, the system can identify from the text through argument recognition:

[0393] Argument: "Zhang San", "Li Si", "Car"

[0394] Role types: "Perpetrator", "Victim", "Vehicle"

[0395] By calling the fourth agent, the system identifies "Zhang San" as the "perpetrator", "Li Si" as the "victim", and "car" as the "vehicle". These arguments and their roles are stored in the information pool for subsequent analysis.

[0396] S205, calling at least one fourth agent to perform argument recognition on the argument role set, obtaining arguments and their corresponding role types, and storing the recognition results in an information pool;

[0397] S206, dividing the unstructured data into text units of different granularities, including sentences, paragraphs, and chapters;

[0398] S207, for each text unit, query the involved entities, trigger words, event types, arguments and role types from the information pool, and integrate and generate context prompt information Prompt of corresponding granularity;

[0399] S208, based on the context prompt information Prompt, calling at least one intelligent agent to perform event recognition on the text at the sentence, paragraph and chapter granularity, and obtaining and storing corresponding event information;

[0400] S209: Fuse event information of different granularities to generate a final event extraction result.

[0401] The specific implementation methods of other steps not described in detail in this embodiment are similar to the relevant steps in the aforementioned embodiments and will not be repeated here.

[0402] The present application also provides a specific embodiment of a method, which provides an implementation method for generating specific event information, that is, by calling different agents for processing, event information corresponding to different granularities is obtained. The embodiment is described in detail below:

[0403] This embodiment relates to an event extraction method based on multi-agent collaboration, which can identify events in texts at sentence, paragraph and chapter granularity, and store the identified event information in an information pool. This method uses contextual prompt information (Prompt) as additional input content, and calls different agents to process texts of different granularity to improve the accuracy and comprehensiveness of event recognition.

[0404] The system first generates contextual prompts based on the input unstructured text data. These prompts incorporate contextual information from the information pool, including recognized entities, trigger words, event types, arguments and their role types. The generated prompts are used to guide the agent to more accurately identify relevant information in the event during event recognition.

[0405] Event recognition at sentence level:

[0406] The first agent passes the first Prompt incorporating context information as additional input content to the fifth agent.

[0407] After receiving the first prompt, the fifth agent performs event recognition on the text at the sentence level based on the prompt information. The fifth agent performs a detailed analysis of the trigger words, arguments, and event types in each sentence to identify event information at the sentence level.

[0408] The identified first event information (including the specific event related to the sentence, participants, type of event and their association) is returned to the first agent and stored in the system's information pool.

[0409] Event recognition at paragraph level:

[0410] The first agent passes the second prompt that incorporates the context information as additional input content to the sixth agent.

[0411] Based on the prompt information, the sixth agent performs event recognition on the text at the paragraph level. Paragraph-level event recognition focuses on cross-sentence correlation analysis to capture the complex event relationship between sentences and further refine and supplement the sentence-level recognition results.

[0412] The identified second event information (including the events, participants, trigger words and context information involved in the paragraph) is returned to the first agent and is also stored in the system's information pool.

[0413] Event recognition at the chapter level:

[0414] The first agent calls the seventh agent and transmits the third prompt to the seventh agent. The prompt information contains context information related to the chapter level, including association data between multiple paragraphs.

[0415] The seventh agent performs event recognition on the text at the chapter level based on the prompt information. Chapter-level event recognition focuses on identifying complex events across paragraphs or even the entire text, ensuring that large events or the global structure of events can be recognized and processed.

[0416] The identified third event information (covering complex event relationships and global information within the chapter) is returned to the first agent and stored in the information pool for subsequent analysis and processing.

[0417] Through the above steps, the system can perform event recognition on text units of different granularities (sentences, paragraphs, and chapters) to form a comprehensive and detailed event information set. This event extraction method based on multi-agent collaboration guides the recognition of agents of different granularities through contextual prompt information (Prompt), improves the accuracy and precision of event recognition, and enables the system to better handle complex event structures.

[0418] See also Figure 3 as well as Figure 6 , Figure 6 This is a schematic diagram of a multi-agent collaboration structure provided in this application. This application also provides a specific embodiment of a method, which provides an implementation method for generating specific event information, that is, by calling different agents for processing, event information corresponding to different granularities is obtained. The embodiment is described in detail below:

[0419] S301, receiving unstructured data, calling at least one second agent through a first agent to perform entity recognition on the unstructured data, obtaining entities in the unstructured data and their corresponding entity types, and storing the recognition results in an information pool;

[0420] S302, calling at least one third agent to identify the trigger words in the unstructured data, obtain the corresponding event type, and store the identification results of the trigger words and event types in the information pool;

[0421] S303, parsing the trigger word and event type, and generating an argument role set based on a predetermined event template library;

[0422] S304, calling at least one fourth agent to perform argument recognition on the argument role set, obtaining arguments and their corresponding role types, and storing the recognition results in an information pool;

[0423] S305, dividing the unstructured data into text units of different granularities, including sentences, paragraphs, and chapters;

[0424] S306, for each text unit, query the involved entities, trigger words, event types, arguments and role types from the information pool, and integrate and generate context prompt information Prompt of corresponding granularity;

[0425] S307, based on the context prompt information Prompt, calling at least one intelligent agent to perform event recognition on the text at the sentence, paragraph and chapter granularity, and obtaining and storing corresponding event information;

[0426] S308, performing similarity calculation on the sentence-level, paragraph-level and chapter-level event information through the first agent, wherein the similarity calculation is based on entity similarity, trigger word similarity, event type similarity and argument similarity;

[0427] In this step, the system uses the first agent to calculate the similarity of event information at the sentence level, paragraph level, and chapter level, and analyzes similarities based on multiple dimensions. These similarity calculations include the following aspects:

[0428] Entity similarity: Compare entities mentioned in texts of different granularities to determine whether these entities are identical or related.

[0429] Trigger word similarity: Compare the trigger words in the event information to determine whether they point to the same or similar event occurrence points.

[0430] Event type similarity: Compare event types to determine whether the events belong to the same type of event (such as disaster events, conference events, etc.).

[0431] Argument similarity: Compare the argument roles in the event (such as victim, responsible person, etc.) to determine whether the same participants or objects are involved.

[0432] Specifically, calculating the similarity includes:

[0433] Calculate entity similarity, trigger word similarity, event type similarity, and argument similarity respectively;

[0434] And the total similarity is calculated by the following formula:

[0435] Total similarity = w1×entity similarity + w2×trigger word similarity + w3×event type similarity + w4×argument similarity;

[0436] Among them, w1, w2, w3, and w4 represent the corresponding weights respectively.

[0437] The entity similarity, trigger word similarity, and argument similarity are calculated using the following formula:

[0438] Element similarity (e 1 ,e 2 )=(V(e 1 )·V(e 2 )) / (||V(e 1 )||*||V(e 2 )||)

[0439] Where: V(e 1 ) and V(e 2 ) are the elements e 1 and element e 2 The vector representation of .

[0440] "·" represents the dot product of vectors.

[0441] "||V(e 1 )||" and"||V(e 2 )||"respectively represent the vector V(e 1 ) and V(e 2 ) model.

[0442] The similarity of the event type is calculated by the following formula:

[0443] Event type similarity (C1, C2) = 1, if C1 = C2;

[0444] Event type similarity (C1, C2) = 0 if C1≠C2.

[0445] S309, when the similarity exceeds a preset threshold, merging similar event information through the first agent;

[0446] After the similarity calculation is completed, if the similarity result exceeds the preset threshold (that is, the similarity between events is high enough), the first agent will merge these similar event information. During the merging process, the system will retain the key data in each granular event information to ensure that the core information of the event is not omitted or conflicting.

[0447] The purpose of merging is to reduce redundant event records while ensuring that the correlation between similar events can be reflected.

[0448] S310, when there is a conflict between event types or argument roles, give priority to the chapter-level event information, and resolve the conflict between argument roles in combination with context information;

[0449] When conflicts are found between event information of different granularities (sentence level, paragraph level, chapter level) during event merging, the system will give priority to chapter-level event information because chapter-level event information usually covers a wider context and has higher integrity and accuracy.

[0450] If there is a conflict in argument roles (i.e., participants or objects in an event), the system will make a judgment based on contextual information and adopt an argument role that is more in line with the overall event context, thereby effectively resolving the conflict.

[0451] S311, supplementing the sentence-level and paragraph-level event information with details, integrating the supplemented paragraph-level event information into the chapter-level event information, and generating a fused event containing the detail information;

[0452] When the system fuses events, it will supplement the event information at the sentence level and paragraph level with details. Sentence-level events usually contain more specific details, while paragraph-level events may cover the relationship between multiple sentences. With these supplementary details, the event information at the paragraph level can be more complete and accurate.

[0453] After supplementation, the paragraph-level event information will be fused with the chapter-level event information. The fused chapter-level event information not only contains the global event framework, but also covers more detailed event details.

[0454] S312: sorting the fused event information through the first agent to construct an event chain, where the event chain represents the time sequence and causal relationship between events;

[0455] Through the first agent, the system sorts the fused event information and constructs an event chain. An event chain is a sequence of events organized in chronological order and causality, which is used to describe the progress, connection and mutual influence between events.

[0456] During the event chain construction process, the system will determine the order of occurrence of each event and the causal relationship between them based on the time stamps and contextual prompts of the events, forming a chain structure with a logical order.

[0457] S313: Generate fused event extraction results.

[0458] Finally, the system generates a fused event extraction result containing detailed information and event chains. The result contains processed and integrated event information, with rich semantic details and clear event sequence.

[0459] The results can be used for subsequent decision support, intelligence analysis or other related applications, ensuring that the system can comprehensively and accurately describe and analyze complex events.

[0460] In this embodiment, the event information fusion and event chain construction method solves the redundancy, conflict and correlation problems in multi-granularity event recognition through multi-dimensional event similarity calculation, conflict resolution, detail supplementation and event chain construction, and has the following technical effects:

[0461] Through multi-dimensional similarity analysis of entities, trigger words, event types, and arguments, the system can more comprehensively and finely determine whether events of different granularities belong to the same event. This multi-level analysis effectively avoids misjudgments caused by different text granularities. For example, the same event may only recognize some details at the sentence level, but present a more complete context at the paragraph level. Using similarity analysis, the system can integrate this information to avoid omissions or misidentifications.

[0462] By merging similar event information, we can effectively reduce redundant events recorded repeatedly in the system and simplify the storage and management of event data. Multi-granular event recognition usually results in the same event being captured multiple times. By calculating similarity and merging events, this method effectively reduces duplication and redundancy and improves the overall consistency of event information.

[0463] There are hierarchical differences in the description of events in texts of different granularities. Sentence-level events are usually more specific, paragraph-level events contain more contextual associations, and chapter-level events are global. By integrating sentence-level and paragraph-level details into chapter-level event information, the system can supplement details and accuracy while retaining global event information, making the final generated event information more comprehensive. For example, a fire event identified at the chapter level can be supplemented at the sentence level to obtain more details, such as the cause of the fire, time, and specific participants.

[0464] When the system encounters conflicts in event recognition (such as inconsistencies in entities, trigger words, event types, or argument roles), it prioritizes chapter-level event information and combines the context to resolve the conflict. This is because chapter-level recognition usually has richer contextual information and can provide a more reliable basis for conflict resolution. Through this conflict resolution mechanism, the system can avoid wrong decisions to the greatest extent. For example, when argument roles conflict at the sentence and paragraph levels, the system will comprehensively consider the context at the chapter level and select an argument role that is more in line with the overall background, thereby ensuring the consistency and rationality of the event description.

[0465] By sorting the fused event information, the system generates a chronological and causally arranged event chain. The event chain not only helps the system to sort out the chronological order of events, but also reveals the causal relationship between events. This is of great value for the analysis of complex events, especially in events involving multiple stages and multiple participants, such as disaster emergency response or meeting records of multiple negotiations. Through the event chain, the system can track the progress of events more accurately and construct a complete event narrative to facilitate subsequent decision support and risk assessment.

[0466] See also Figure 4 The present application provides an event extraction system based on multi-agent collaboration, the system comprising:

[0467] The entity recognition unit 401 is used to receive unstructured data, perform entity recognition on the unstructured data by invoking at least one second agent through a first agent, obtain entities in the unstructured data and their corresponding entity types, and store the recognition results in an information pool;

[0468] An event type processing unit 402 is used to call at least one third agent to identify the trigger word in the unstructured data, obtain the corresponding event type, and store the identification results of the trigger word and the event type in the information pool;

[0469] A parsing unit 403, configured to parse the trigger word and event type, and generate an argument role set based on a predetermined event template library;

[0470] The argument recognition unit 404 calls at least one fourth agent to perform argument recognition on the argument role set, obtains arguments and their corresponding role types, and stores the recognition results in an information pool;

[0471] A segmentation unit 405, which segments the unstructured data into text units of different granularities, including sentences, paragraphs, and chapters;

[0472] The query unit 406 queries the involved entities, trigger words, event types, arguments and role types from the information pool for each text unit, and integrates and generates context prompt information Prompt of corresponding granularity;

[0473] The event recognition unit 407, based on the context prompt information Prompt, calls at least one intelligent agent to perform event recognition on the text at the sentence, paragraph and chapter granularity, and obtains and stores corresponding event information;

[0474] The event fusion unit 408 fuses event information of different granularities to generate a final event extraction result.

[0475] Optionally, the parsing unit 403 is specifically used for:

[0476] The first agent traverses all trigger words and event types and parses them to obtain argument roles in all events and form an argument role set;

[0477] The fourth agent is called by the first agent to perform argument recognition on each argument role in the argument role set to obtain all arguments and the argument roles corresponding to all arguments.

[0478] Optionally, the segmentation unit 405 is specifically used for:

[0479] Using the first agent, segment the unstructured text in the unstructured data into sentences respectively;

[0480] The query unit 406 is specifically used for:

[0481] For each sentence, query the involved entities, trigger words, event types, arguments and their corresponding argument roles from the information pool through the first agent;

[0482] Through the first intelligent agent, the entities, trigger words, event types, arguments and their corresponding argument roles obtained from the query are integrated to generate the first Prompt information corresponding to the sentence.

[0483] Optionally, the segmentation unit 405 is specifically used for:

[0484] Using the first agent, the unstructured text in the unstructured data is divided into paragraphs respectively;

[0485] The query unit 406 is specifically used for:

[0486] For each paragraph, query the involved entities, trigger words, event types, arguments and their corresponding argument roles from the information pool through the first agent;

[0487] Through the first intelligent agent, the entities, trigger words, event types, arguments and their corresponding argument roles obtained from the query are integrated to generate the second Prompt information corresponding to the paragraph.

[0488] Optionally, the segmentation unit 405 is specifically used for:

[0489] Using the first agent, the unstructured text in the unstructured data is divided into chapters respectively;

[0490] The query unit 406 is specifically used for:

[0491] For each chapter, the first agent queries the involved entities, trigger words, event types, arguments and their corresponding argument roles from the information pool;

[0492] Through the first intelligent agent, the entities, trigger words, event types, arguments and their corresponding argument roles obtained from the query are integrated to generate the third Prompt information corresponding to the chapter.

[0493] Optionally, the event identification unit 407 is specifically configured to:

[0494] The first agent inputs the first prompt information integrated with the context prompt information as additional input content into the fifth agent;

[0495] Through the fifth agent, event recognition at the sentence granularity is performed based on the Prompt information, and the recognized first event information is returned to the information pool of the first agent.

[0496] Through the sixth agent, event recognition at the paragraph granularity is performed based on the Prompt information, and the recognized second event information is returned to the information pool of the first agent.

[0497] Optionally, the event identification unit 407 is specifically configured to:

[0498] Inputting the second Prompt prompt information integrated with the context prompt information as additional input content into the sixth agent;

[0499] Through the sixth agent, event recognition at the paragraph granularity is performed based on the Prompt information, and the recognized second event information is returned to the information pool of the first agent.

[0500] Optionally, the event identification unit 407 is specifically configured to:

[0501] Through the seventh agent, chapter-level event recognition is performed based on the Prompt information, and the recognized third event information is returned to the information pool of the first agent.

[0502] Optionally, the event identification unit 407 is specifically configured to:

[0503] Inputting the third Prompt prompt information integrated with the context prompt information as additional input content into the seventh agent;

[0504] Through the seventh agent, chapter-level event recognition is performed based on the Prompt information, and the recognized third event information is returned to the information pool of the first agent.

[0505] Optionally, the event fusion unit 408 is specifically used to: perform similarity calculation on the sentence-level, paragraph-level and chapter-level event information through the first agent, wherein the similarity calculation is based on entity similarity, trigger word similarity, event type similarity and argument similarity;

[0506] When the similarity exceeds a preset threshold, merging similar event information through the first agent;

[0507] When there is a conflict between event types or argument roles, the chapter-level event information is given priority, and the argument roles are resolved in combination with the context information;

[0508] Supplement the details of sentence-level and paragraph-level event information, integrate the supplemented paragraph-level event information into the chapter-level event information, and generate a fused event containing detailed information;

[0509] The fused event information is sorted by the first agent to construct an event chain, where the event chain represents the time sequence and causal relationship between events;

[0510] Generate fused event extraction results.

[0511] Optionally, the event fusion unit 408 is specifically configured to:

[0512] Calculate entity similarity, trigger word similarity, event type similarity, and argument similarity respectively;

[0513] And the total similarity is calculated by the following formula:

[0514] Total similarity = w1×entity similarity + w2×trigger word similarity + w3×event type similarity + w4×argument similarity;

[0515] Among them, w1, w2, w3, and w4 represent the corresponding weights respectively.

[0516] Optionally, the entity similarity, trigger word similarity, and argument similarity are calculated using the following formula:

[0517] Element similarity (e 1 ,e 2 )=(V(e 1 )·V(e 2 )) / (||V(e 1 )||*||V(e 2 )||)

[0518] Where: V(e 1 ) and V(e 2 ) are the elements e 1 and element e 2 The vector representation of .

[0519] "·" represents the dot product of vectors.

[0520] "||V(e 1 )||" and"||V(e 2 )||"respectively represent the vector V(e 1 ) and V(e 2 ) model.

[0521] Optionally, the similarity of the event type is calculated using the following formula:

[0522] Event type similarity (C1, C2) = 1, if C1 = C2;

[0523] Event type similarity (C1, C2) = 0 if C1≠C2.

[0524] See also Figure 5 The present application also provides an event extraction device based on multi-agent collaboration, comprising:

[0525] Processor 501, memory 502, input and output unit 503, bus 504;

[0526] The processor 501 is connected to the memory 502, the input and output unit 503 and the bus 504;

[0527] The memory 502 stores a program, and the processor 501 calls the program to execute any of the above methods.

[0528] The present application also relates to a computer-readable storage medium on which a program is stored, wherein when the program is run on a computer, the computer is caused to execute any of the above methods.

[0529] Those skilled in the art can clearly understand that, for the convenience and brevity of description, the specific working processes of the systems, devices and units described above can refer to the corresponding processes in the aforementioned method embodiments and will not be repeated here.

[0530] In the several embodiments provided in the present application, it should be understood that the disclosed systems, devices and methods can be implemented in other ways. For example, the device embodiments described above are only schematic. For example, the division of the units is only a logical function division. There may be other division methods in actual implementation, such as multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be an indirect coupling or communication connection through some interfaces, devices or units, which can be electrical, mechanical or other forms.

[0531] The units described as separate components may or may not be physically separated, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed on multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution of this embodiment.

[0532] In addition, each functional unit in each embodiment of the present application may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit. The above-mentioned integrated unit may be implemented in the form of hardware or in the form of software functional units.

[0533] If the integrated unit is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present application is essentially or the part that contributes to the prior art or all or part of the technical solution can be embodied in the form of a software product. The computer software product is stored in a storage medium, including several instructions to enable a computer device (which can be a personal computer, server, or network device, etc.) to execute all or part of the steps of the method described in each embodiment of the present application. The aforementioned storage medium includes: U disk, mobile hard disk, read-only memory (ROM, read-only memory), random access memory (RAM, random access memory), disk or optical disk and other media that can store program code.

Claims

1. An event extraction method based on multi-agent collaboration, It is characterized in that The method comprises: Receiving unstructured data, calling at least one second agent through a first agent to perform entity recognition on the unstructured data, obtaining entities in the unstructured data and their corresponding entity types, and storing the recognition results in an information pool; Calling at least one third agent to identify the trigger words in the unstructured data, obtain the corresponding event type, and store the identification results of the trigger words and the event type in the information pool; Parsing the trigger words and event types, and generating an argument role set based on a predetermined event template library; Calling at least one fourth agent to perform argument recognition on the argument role set, obtaining arguments and their corresponding role types, and storing the recognition results in an information pool; Segmenting the unstructured data into text units of different granularities, including sentences, paragraphs, and chapters; For each text unit, query the involved entities, trigger words, event types, arguments, and role types from the information pool, and integrate them to generate contextual prompt information of corresponding granularity; Based on the context prompt information Prompt, call at least one intelligent agent to perform event recognition on the text at the sentence, paragraph and chapter granularity, and obtain and store corresponding event information; Event information of different granularities is integrated to generate the final event extraction result.

2. According to the event extraction method based on multi-agent collaboration described in claim 1, It is characterized in that The step of parsing the trigger word and the event type and generating an argument role set based on a predetermined event template library includes: The first agent traverses all trigger words and event types and parses them to obtain argument roles in all events and form an argument role set; The fourth agent is called by the first agent to perform argument recognition on each argument role in the argument role set to obtain all arguments and the argument roles corresponding to all arguments.

3. According to the event extraction method based on multi-agent collaboration described in claim 1, It is characterized in that Dividing the unstructured data into text units of different granularities, including sentences, paragraphs and chapters, includes: Using the first agent, segment the unstructured text in the unstructured data into sentences respectively; For each text unit, the involved entities, trigger words, event types, arguments, and role types are queried from the information pool, and the corresponding granular context prompt information is generated by integration, including: For each sentence, query the involved entities, trigger words, event types, arguments and their corresponding argument roles from the information pool through the first agent; Through the first intelligent agent, the entities, trigger words, event types, arguments and their corresponding argument roles obtained from the query are integrated to generate the first Prompt information corresponding to the sentence.

4. According to the event extraction method based on multi-agent collaboration described in claim 1, It is characterized in that Dividing the unstructured data into text units of different granularities, including sentences, paragraphs and chapters, includes: Using the first agent, the unstructured text in the unstructured data is divided into paragraphs respectively; For each text unit, the involved entities, trigger words, event types, arguments, and role types are queried from the information pool, and the corresponding granular context prompt information is generated by integration, including: For each paragraph, query the involved entities, trigger words, event types, arguments and their corresponding argument roles from the information pool through the first agent; Through the first intelligent agent, the entities, trigger words, event types, arguments and their corresponding argument roles obtained from the query are integrated to generate the second Prompt information corresponding to the paragraph.

5. According to the event extraction method based on multi-agent collaboration described in claim 1, It is characterized in that Dividing the unstructured data into text units of different granularities, including sentences, paragraphs and chapters, includes: Using the first agent, the unstructured text in the unstructured data is divided into chapters respectively; For each text unit, the involved entities, trigger words, event types, arguments, and role types are queried from the information pool, and the corresponding granular context prompt information is generated by integration, including: For each chapter, the first agent queries the involved entities, trigger words, event types, arguments and their corresponding argument roles from the information pool; Through the first intelligent agent, the entities, trigger words, event types, arguments and their corresponding argument roles obtained from the query are integrated to generate the third Prompt information corresponding to the chapter.

6. According to the event extraction method based on multi-agent collaboration described in claim 3, It is characterized in that The calling of at least one agent to perform event recognition on texts at sentence, paragraph and chapter granularity based on the context prompt information Prompt, and obtaining and storing corresponding event information includes: The first agent inputs the first prompt information integrated with the context prompt information as additional input content into the fifth agent; Through the fifth agent, event recognition at the sentence granularity is performed based on the Prompt information, and the recognized first event information is returned to the information pool of the first agent.

7. According to the event extraction method based on multi-agent collaboration described in claim 4, It is characterized in that The calling of at least one agent to perform event recognition on texts at sentence, paragraph and chapter granularity based on the context prompt information Prompt, and obtaining and storing corresponding event information includes: Inputting the second Prompt prompt information integrated with the context prompt information as additional input content into the sixth agent; Through the sixth agent, event recognition at the paragraph granularity is performed based on the Prompt information, and the recognized second event information is returned to the information pool of the first agent.

8. According to the event extraction method based on multi-agent collaboration described in claim 5, It is characterized in that The calling of at least one agent to perform event recognition on texts at sentence, paragraph and chapter granularity based on the context prompt information Prompt, and obtaining and storing corresponding event information includes: Inputting the third Prompt prompt information integrated with the context prompt information as additional input content into the seventh agent; Through the seventh agent, chapter-level event recognition is performed based on the Prompt information, and the recognized third event information is returned to the information pool of the first agent.

9. According to the event extraction method based on multi-agent collaboration described in claim 1, It is characterized in that The fusion of event information of different granularities to generate the final event extraction result includes: Performing similarity calculation on the sentence-level, paragraph-level and chapter-level event information by a first agent, wherein the similarity calculation is based on entity similarity, trigger word similarity, event type similarity and argument similarity; When the similarity exceeds a preset threshold, merging similar event information through the first agent; When there is a conflict between event types or argument roles, the chapter-level event information is given priority, and the argument roles are resolved in combination with the context information; Supplement the details of sentence-level and paragraph-level event information, integrate the supplemented paragraph-level event information into the chapter-level event information, and generate a fused event containing detailed information; The fused event information is sorted by the first agent to construct an event chain, where the event chain represents the time sequence and causal relationship between events; Generate fused event extraction results.

10. According to the event extraction method based on multi-agent collaboration described in claim 9, It is characterized in that The similarity calculation of the sentence-level, paragraph-level and chapter-level event information by the first agent is based on entity similarity, trigger word similarity, event type similarity and argument similarity, and includes: Calculate entity similarity, trigger word similarity, event type similarity, and argument similarity respectively; And the total similarity is calculated by the following formula: Total similarity = w1×entity similarity + w2×trigger word similarity + w3×event type similarity + w4×argument similarity; Among them, w1, w2, w3, and w4 represent the corresponding weights respectively.

11. According to the event extraction method based on multi-agent collaboration described in claim 10, It is characterized in that The entity similarity, trigger word similarity, and argument similarity are calculated using the following formula: Element similarity (e 1 ,e 2 )=(V(e 1 )·V(e 2 )) / (||V(e 1 )||*||V(e 2 )||); Where: V(e 1 ) and V(e 2 ) are the elements e 1 and element e 2 The vector representation of ; "·" represents the dot product of vectors; "||V(e 1 )||" and"||V(e 2 )||"respectively represent the vector V(e 1 ) and V(e 2 ) model.

12. According to the event extraction method based on multi-agent collaboration described in claim 10, It is characterized in that The similarity of the event type is calculated by the following formula: Event type similarity (C1, C2) = 1, if C1 = C2; Event type similarity (C1, C2) = 0 if C1≠C2.

13. An event extraction system based on multi-agent collaboration, It is characterized in that The system comprises: An entity recognition unit, configured to receive unstructured data, perform entity recognition on the unstructured data by invoking at least one second agent through a first agent, obtain entities in the unstructured data and their corresponding entity types, and store the recognition results in an information pool; An event type processing unit, configured to call at least one third agent to identify the trigger word in the unstructured data, obtain the corresponding event type, and store the identification results of the trigger word and the event type in an information pool; A parsing unit, used for parsing the trigger word and event type, and generating an argument role set based on a predetermined event template library; An argument recognition unit, configured to call at least one fourth agent to perform argument recognition on the argument role set, obtain arguments and their corresponding role types, and store recognition results in an information pool; A segmentation unit, used to segment the unstructured data into text units of different granularities, including sentences, paragraphs, and chapters; The query unit is used to query the entities, trigger words, event types, arguments, and role types involved in each text unit from the information pool, and integrate them to generate contextual prompt information of corresponding granularity; An event recognition unit, configured to call at least one agent to perform event recognition on texts at sentence, paragraph and chapter granularity based on the context prompt information Prompt, and obtain and store corresponding event information; The event fusion unit fuses event information of different granularities to generate the final event extraction result.

14. An event extraction device based on multi-agent collaboration, It is characterized in that The device comprises: Processor, memory, input-output unit, and bus; The processor is connected to the memory, the input and output unit, and the bus; The memory stores a program, and the processor calls the program to execute the method according to any one of claims 1 to 12.

Images