Rail transit emergency plan generation method and system based on large model agent

Abstract

The application provides a rail transit emergency plan generation method and system based on a large model agent, a multi-source unstructured rail transit emergency disposal data is analyzed by a disposal module logic self-learning agent, atomic disposal modules are automatically extracted and the logical relationship therebetween is mined, a disposal module logic graph is constructed, and explicit and structured storage of emergency disposal logic is realized. When receiving rail transit emergency event information, relying on the graph and combining the emergency event information, a logically self-consistent, complete and practical emergency plan is dynamically generated, and the plan generation process is driven by logic. Moreover, the system constructs a learning closed loop of "generation-verification-feedback-optimization", when a user corrects the plan, the system records the correction operation and uses the corrected plan to incrementally train the model agent, and simultaneously optimizes the node relationship and connection weight in the disposal module logic graph, so as to realize continuous evolution and autonomous improvement of the system in practical feedback.

Description

Technical Field

[0001] This invention relates to the field of intelligent rail transit and artificial intelligence, and in particular to a method for generating rail transit emergency plans based on large-scale intelligent models. Background Technology

[0002] As the scale of rail transit expands and the operating environment becomes increasingly complex, traditional emergency management is encountering significant bottlenecks in terms of intelligence. Currently, there are two common technical approaches, but neither can achieve automatic generation and continuous optimization of contingency plans.

[0003] The first type is the traditional contingency plan matching system based on a static knowledge base. This type of system relies on a contingency plan database that is manually compiled, organized, and labeled in advance, which has obvious limitations: the cost of manually building and maintaining the knowledge base is high, the cycle is long, and it is difficult to update. The system itself cannot extract new knowledge or summarize new patterns from historical data, resulting in the difficulty of effectively accumulating experience in handling situations. The content of the contingency plans gradually lags behind actual needs and eventually becomes a slowly updated "static archive".

[0004] The second type is a real-time decision support system based on large models. These systems leverage the analytical capabilities of large language models to provide handling suggestions during emergencies. However, they essentially still operate within an existing knowledge framework, and their effectiveness depends on pre-set prompts and existing tool models. The system lacks the ability to deeply understand, autonomously summarize, and structurally model specialized emergency knowledge, failing to address the fundamental question of "where does emergency knowledge come from and how can it be self-optimized." In essence, it is merely an "implementer of contingency plans" rather than a "builder of contingency plans."

[0005] In summary, both current technologies suffer from a key drawback: existing systems lack the ability to automatically complete the process of "deep understanding—pattern summarization—continuous evolution" from multi-source heterogeneous data. This has resulted in emergency knowledge management remaining reliant on manual intervention and stagnating at a static stage. Therefore, this field urgently needs an innovative solution that can drive emergency response plan knowledge from "relying on manual solidification" to "automatic construction and continuous evolution." Summary of the Invention

[0006] In view of the above problems, the present invention is proposed to provide a method for generating rail transit emergency plans based on large model intelligent agents to overcome or at least partially solve the above problems.

[0007] This invention discloses a method for generating emergency response plans for rail transit based on a large-scale intelligent agent model, the method comprising: The emergency response data of rail transit is automatically analyzed by a self-learning intelligent agent of the response module logic, and a logic graph of the response module is established. Receive information on rail transit emergency events and generate emergency plans based on the logic diagram of the handling module and the information on rail transit emergency events using an emergency plan generation model; If the user modifies the emergency plan, the modification operation is recorded, and the modified emergency plan is used to incrementally train the logic self-learning agent of the disposal module and the emergency plan generation model. The logic graph of the disposal module is also optimized based on the emergency plan modification operation.

[0008] Optionally, an automated analysis of rail transit emergency response data is performed using a self-learning intelligent agent for the response module logic, establishing a logic graph of the response module, including: The self-learning intelligent agent of the handling module identifies multiple types of handling units from the emergency handling data of rail transit, and performs atomization processing on the action-type handling units to obtain the action handling module; the types of handling units include at least condition-type, principle clause-type, and judgment logic-type; the condition-type includes trigger conditions and constraint conditions; Each action handling module is labeled with features by a self-learning intelligent agent that performs logic processing module self-learning, resulting in action handling modules with contextual feature vectors and parameter sets. By using triggering conditions as event nodes and constraint conditions as constraint nodes, and based on the context feature vectors and parameter sets of each handling unit and action handling module, we can mine the logical relationships between action handling modules, between action handling modules and event nodes, and between action handling modules and constraint nodes. We can then construct a graph with action handling modules, event nodes, and constraint nodes as graph nodes and weighted logical relationships as directed edges, thus obtaining the logical graph of the handling modules.

[0009] Optionally, a self-learning intelligent agent for the handling module identifies multiple types of handling units from rail transit emergency handling data, and atomizes the action-type handling units to obtain an action handling module, including: A hybrid analytical model was used to analyze the chapter structure of emergency response data for rail transit and segment it into semantic block sequences. Based on sequence labeling models or large language models, named entity recognition and classification are performed on semantic block sequences to obtain multiple processing units; Dependency parsing is performed on action-type processing units to identify semantic structures centered on predicate verbs. An action boundary detection algorithm guided by knowledge of the rail transit domain is used to automatically delineate the boundaries of atomic modules based on changes in the action implementer, processing object, and operation tool corresponding to the semantic structure centered on the predicate verb. For each atomic module, a standard name is generated using a standardized template based on a verb-object structure. Semantic deduplication verification is performed on all atomic modules, and modules with equivalent functions are merged. A unique identifier is assigned to the retained atomic modules to obtain the action processing module.

[0010] Optionally, each action handling module is characterized by feature labeling through a self-learning agent of the handling module logic, resulting in action handling modules with contextual feature vectors and parameter sets, including: Based on a pre-defined multi-dimensional feature labeling system, the text content of the action handling module is labeled with tags by matching keywords and rules, and the corresponding explicit contextual feature labels are marked for the action handling module. The text content of the action handling module is converted into a semantic vector and input into a text classification model that has been adaptively trained in the field of rail transit to predict and label the implicit contextual feature labels of the action handling module. Numerical parameters are identified and extracted from the text content of the action processing module using regular expressions and information extraction models. Integrate explicit contextual feature labels, implicit contextual feature labels, and numerical parameters to form a contextual feature vector and parameter set for the action handling module.

[0011] Optionally, based on the context feature vectors and parameter sets of each handling unit and action handling module, the logical relationships between action handling modules, between action handling modules and event nodes, and between action handling modules and constraint nodes are mined. A graph is constructed with action handling modules, event nodes, and constraint nodes as graph nodes, and weighted logical relationships as directed edges, resulting in a handling module logical graph, including: Define logical relationship types, which include at least triggering relationships, sequential relationships, dependency relationships, and mutual exclusion relationships; Based on the context feature vectors and parameter sets of each processing unit and action processing module, the co-occurrence patterns of nodes are analyzed through association rule mining algorithms to identify the triggering relationships between nodes, the execution order of nodes is analyzed through sequence pattern analysis algorithms to identify the temporal relationships between nodes, and the semantic logic between node content is analyzed through semantic relationship extraction algorithms to identify the dependency and mutual exclusion relationships between nodes. By using the action handling module, event nodes, and constraint nodes as graph nodes, and the identified logical relationships as directed edges connecting the nodes, and assigning weights to each edge based on data mining confidence, the logic graph of the handling module is obtained.

[0012] Optionally, receiving rail transit emergency event information, and using an emergency plan generation model to generate an emergency plan based on the logic diagram of the handling module and the rail transit emergency event information, including: The emergency plan generation model searches for event nodes in the logic graph of the handling modules that match the information of rail transit emergency events, and executes a graph traversal algorithm. Starting from the matched event nodes, it retrieves all relevant action handling modules based on the triggering relationship between nodes. Based on the temporal relationship, dependency relationship and mutual exclusion relationship between nodes, it performs topological sorting on the retrieved action handling modules to obtain an ordered sequence of action handling modules. Finally, it fills the ordered sequence of action handling modules into the plan template to generate the emergency plan.

[0013] Optionally, the correction types include adding nodes and node logical relationships, deleting nodes and node logical relationships, modifying logical relationships between nodes, confirming logical relationships between nodes, and adjusting the weights of logical relationships between nodes. Based on the emergency plan correction operation optimization and handling module logic graph, it includes: Based on the addition or removal of nodes and logical relationships during the emergency response plan modification operation, and the changes in node logical relationships, add or remove nodes and logical relationship edges, and modify the logical relationship edges between nodes in the logic graph of the handling module; Based on the frequency of confirmation of logical relationships between nodes, adjustment of the weight of logical relationships between nodes, addition or subtraction of nodes and logical relationships between nodes, and changes in logical relationships between nodes during the emergency response plan modification operation, the weight of the logical relationship edges between nodes is updated in the logic graph of the handling module.

[0014] This invention also discloses a rail transit emergency response plan generation system based on a large-scale intelligent agent model, the system comprising: The logic graph construction module for the handling module is used to automatically analyze rail transit emergency handling data through a logic self-learning intelligent agent of the handling module and establish a logic graph of the handling module. The emergency plan generation module is used to receive information on rail transit emergency events and generate emergency plans based on the logic diagram of the handling module and the information on rail transit emergency events using the emergency plan generation model. The continuous optimization module records the emergency plan modification operation if the user modifies the emergency plan, and uses the modified emergency plan to incrementally train the logic self-learning agent of the disposal module and the emergency plan generation model, as well as optimize the logic graph of the disposal module based on the emergency plan modification operation.

[0015] This invention has the following advantages: This invention utilizes a self-learning intelligent agent to deeply analyze unstructured data from multiple sources, including historical plans and case reports. It automatically extracts atomic emergency response modules and mines complex relationships such as triggering, timing, dependencies, and mutual exclusions, thereby automatically constructing a structured logic graph of the response modules. This enables the explicit and structured storage of emergency response logic. Furthermore, upon receiving information about rail transit emergency events, the system uses this graph in conjunction with the event information. Through context mapping, subgraph activation, and logical constraint reasoning, it dynamically generates logically consistent, complete, and realistic emergency plans, ensuring that the plan generation process is driven by logic. The system also constructs a learning loop of "generation—verification—feedback—optimization." When a user modifies a plan, the system records the modification and uses the revised plan to incrementally train the agent and the generation model. Simultaneously, it optimizes the node relationships and connection weights in the logic graph of the response modules, enabling the system to continuously evolve and autonomously improve through practical feedback. Attached Figure Description

[0016] Figure 1 This is a flowchart of the rail transit emergency plan generation method based on a large model intelligent agent provided by the present invention; Figure 2 This is a schematic diagram of the logic of the handling module constructed using the principle of clearing passengers from a train as an example, provided by the present invention. Figure 3 This is a schematic diagram of the emergency response plan list provided by the present invention; Figure 4 This is a schematic diagram of the emergency plan modification interface 1 provided by the present invention; Figure 5 This is a schematic diagram of the emergency plan modification interface 2 provided by the present invention. Detailed Implementation

[0017] To make the above-mentioned objects, features and advantages of the present invention more apparent and understandable, the present invention will be further described in detail below with reference to the accompanying drawings and specific embodiments.

[0018] Reference Figure 1 The flowchart illustrates a method for generating rail transit emergency plans based on a large-model intelligent agent, as provided in an embodiment of the present invention. Specifically, it may include the following steps: S1. Automated Logic Construction Process The intelligent agent automatically analyzes raw documents (such as historical contingency plans and response reports) and outputs a logical graph G=(V,E) of the response modules, where V is the set of nodes (response modules) and E is the set of edges (logical relationships). This process includes: S1.1 Atomized Module Decomposition: Unstructured text is decomposed into indivisible processing modules through a hybrid parsing model (rules + deep learning), ensuring that each module describes a complete action.

[0019] S1.2 Intelligent Feature Labeling: Each module is labeled with a multi-dimensional contextual label (such as event type and response level) to form a feature vector that can be understood by the machine.

[0020] S1.3 Logical Relationship Self-Learning: Integrating association rule mining (FP-Growth), sequence pattern analysis (PrefixSpan), and semantic relation extraction (BERT) algorithms, it automatically mines the triggering, temporal, dependency, and mutual exclusion relationships between modules to construct a graph.

[0021] S2. Intelligent Contingency Plan Generation Process The intelligent agent receives natural language queries from users and dynamically generates contingency plans based on the logic graph of the processing modules. S2.1 Contextualized Vectorization Mapping: Parses the query into feature vectors and matches event nodes in the graph.

[0022] S2.2 Graph Traversal and Matching: Retrieve relevant module sets using graph traversal algorithms (such as BFS).

[0023] S2.3 Logical Sorting and Assembly: Based on topological sorting and constraint satisfaction, an ordered processing sequence is generated.

[0024] S3. Continuously optimize the learning process Intelligent agents achieve self-evolution through feedback loops: S3.1 Feedback Data Collection: Record experts' feedback on the draft plan and convert it into structured training data.

[0025] S3.2 Incremental Model Update: Fine-tuning the text parsing model and the contingency plan generation model to reduce contingency plan errors.

[0026] S3.3 Graph Dynamic Optimization: Adjust edge weights based on correction frequency, and add or delete logical relationships.

[0027] Through the above solutions, this invention achieves automation and intelligence in the full lifecycle management of emergency plans. It can autonomously complete the entire process from historical document parsing, extraction of disposal modules, and logical correlation mining to dynamic synthesis of plans and application feedback optimization. This upgrades the plan system from a static document library that relies on manual maintenance by experts to an intelligent plan system that can learn from data, reason logically, and continuously optimize in practice. It realizes a fundamental shift from manual compilation to automatic machine compilation and optimization.

[0028] The following section uses the "On-site Handling Plan of a Metro Control Center in a Certain City" as an example to illustrate how this invention transforms unstructured text plans into structured emergency response module logic diagrams and how it achieves intelligent generation and continuous optimization of plans.

[0029] S1: Automated logic construction process The input for this process is a set of emergency response plan documents for rail transit. D This includes various emergency response plan documents (unstructured data) for events such as large-scale power outages, flooding, station fires, and passenger panic stampedes, and the output is a structured logic diagram of the response modules. G=(V, E) ,in V It is a set of nodes. E It is a set of edges. The specific steps are as follows: S1.1: Atomization Module Decomposition This step parses, identifies, and atomizes unstructured text, breaking down the contingency plan into indivisible atomized processing modules.

[0030] Input: Original documents such as "On-site Handling Plan for Metro Control Center in a Certain City" .

[0031] Processing steps: 1. Text Structure Analysis: Using a rule-based + deep learning segmentation model , will document Separated into semantic blocks by chapter and clause. .

[0032] Function / Formula Expression: Its internal logic is a hybrid parsing process aimed at identifying and segmenting document structure. First, based on predefined domain rules and regular expressions, it scans explicit markers in the document, such as chapter numbers and heading formats, to create an initial outline. Then, it invokes a semantic segmentation model to analyze the text content in depth, detecting paragraph boundaries that, while lacking explicit formatting markers, are semantically self-contained units. Finally, the system merges these two analysis results, supplemented by heuristic rules such as block length, to optimize and correct the initial structure, ultimately outputting a well-structured sequence of semantic blocks with clear hierarchy and semantic coherence.

[0033] Application scenario: The intelligent agent identifies macro-level concepts such as "clearance principle" and "evacuation process".

[0034] 2. Processing Unit Identification and Boundary Delineation: For each semantic block Named entity recognition and classification are performed using sequence labeling models or large language models to identify processing units. Its types include principle clauses, triggering conditions, specific actions, judgment logic, and constraints.

[0035] Application scenario: In the "evacuation process" case, the intelligent agent identifies the trigger condition handling unit. For "during evacuation within the execution area", and action units The driver should lower the bow.

[0036] 3. Atomized Module Generation and Naming: Atomize (i.e., modularize) the action-type handling units to ensure that each module... It describes a complete and indivisible disposal action and generates a unique identifier. Standardized names and core content .

[0037] Function / Formula Expression: Its internal logic is as follows: First, it performs dependency parsing on the input action units to identify the semantic structure centered on the predicate verb; then, it uses an action boundary detection algorithm guided by knowledge of the rail transit domain to automatically delineate the boundaries of atomic modules based on changes in the action implementer, the object of disposal, and the operating tool; next, it adopts a templated naming strategy, combined with verb-object phrase standardization and a domain terminology library, to generate a standard name for each atomic module with a "verb + object" structure; finally, it performs semantic deduplication verification to merge modules with equivalent functions but different expressions, ensuring the uniqueness and reusability of the actions in the knowledge base.

[0038] Application scenarios: ①Module M001: Module Name: Train Pantograph Lowering Action taken: The driver lowered the pantograph. ②Module M002: Module Name: Overhead Contact Line Power Outage Emergency Response: The equipment dispatcher will cut off power to the up and down overhead contact lines in the corresponding section. S1.2: Intelligent Feature Tagging This step applies to each processing module. Assigning machine-understandable contextual feature vectors .

[0039] Input: The set of atomization processing modules output from S1.1 .

[0040] Processing steps: 1. Application of the pre-defined labeling system: Define a multi-dimensional feature space. Each dimension represents a feature label. For predefined, explicit labels (such as execution roles), use keyword matching functions. Perform rapid annotation.

[0041] Function / Formula Expression: Its internal logic involves first loading a tag-keyword mapping library built from domain knowledge, then performing lexical analysis and pattern scanning on the input text. Through precise keyword matching, regular expression rules, and contextual feature detection, it identifies content patterns corresponding to a preset tag system. When multiple tags are triggered, conflicts are resolved according to predefined priorities, ultimately outputting a standardized tag set, with each tag assigned a confidence weight based on its matching position.

[0042] Preset tagging system: ①Event types: fire, flooding, large passenger flow, vehicle breakdown, power outage... ② Response levels: Level 1 response, Level 2 response, Level 3 response... ③ Roles: Dispatchers, station staff, train attendants, drivers, maintenance professionals... ④ Station structure: underground, ground level, elevated ⑤ Date characteristics: weekdays, non-working days ⑥ Weather characteristics: heavy rain, sunny weather, snow, typhoon... ⑦ Interval parameters: Upward and downward ⑧ Station parameters: Equipment area, concourse, platform, entrances / exits... etc.

[0043] Application scenarios: For module M002 "Contact network power outage", the agent marks it using rule matching as follows: Event type: ["Flooding", "Fire", "Evacuation"]; Execution role: [“Equipment Scheduling”]; Response level: "Level 1 Response"; Equipment type: "Overhead contact wire".

[0044] 2. Deep Mining of Latent Features: For complex, latent features (such as trigger conditions and security levels), a text classification model is used. Make predictions. The model's input is the semantic vector of the module's content. (Generated by models such as Sentence-BERT).

[0045] Function / Formula Expression: Its internal logic is as follows: First, semantic vectors are input into a multilayer perceptron for high-dimensional feature transformation, and key semantic segments are focused through an attention mechanism. Then, the activation probabilities of all preset labels are calculated in parallel using the sigmoid output layer, combined with the decision boundary learned in domain-adaptive training. Finally, the output probabilities are adaptively thresholded to generate the final label set. The entire process automatically captures the complex mapping relationship between semantic features and latent labels through end-to-end learning.

[0046] Application scenario: For the same module "Execute interval evacuation authorization", the agent discovers key hidden features such as "Trigger condition: Station personnel need to be in place to guide" and "Safety constraint: The overhead contact line must be de-energized".

[0047] 3. Numerical Feature Extraction: For explicitly defined numerical parameters in the document (such as rescue time thresholds) Speed ​​limit Use regular expressions or information extraction models Perform precise extraction.

[0048] Function / Formula Expression: Its internal logic is as follows: First, it performs precise matching through a predefined regular expression pattern library, and combines dependency parsing to determine the unit of measurement and the object of modification of the numerical value; then, it uses a conditional rule library to perform contextual verification, excluding numerical values ​​in negative sentences and hypothetical contexts; finally, it converts the extracted results into structured key-value pairs through unit normalization and standard formatting, ensuring that parameters such as time, speed, and capacity are accurately parsed and associated with the corresponding business entities.

[0049] Application scenarios: The following parameter set was precisely extracted from the "High Water Level Alarm of Interval Pumps" clause: { "Water level threshold": "30cm" Response time: 3 minutes Number of water pumps: 2 units } Output example: Each disposal module It is represented as an eigenvector and a set of parameters .

[0050] S1.3: Self-learning of logical relationships After extracting and annotating the contextual features of the atomic disposal modules (S1.1 and S1.2), this step automatically mines the logical relationships between modules using a data-driven approach to construct a structured "disposal module logic graph" G. This graph is represented as a directed graph, with nodes representing disposal modules, events / conditions, and constraints, and edges representing weighted and parameterized logical relationships (triggering, timing, dependency, mutual exclusion). The core of the construction process is the self-learning mining of logical relationships, which requires no manual pre-setting of rules but is automatically completed based on sequence patterns, co-occurrence frequencies, and semantic context in historical contingency plans and disposal reports. The specific steps are as follows: 1. Definition of logical relation types: Define a set of edge relation types R = {triggers, precedes, requires, excludes, ...}, where: (1) Triggers: indicates that when a certain condition or event is met, a specific action should be initiated (e.g., "train malfunction" triggers "clearing passengers").

[0051] (2) Precedes: indicates that there is a time requirement between two actions (e.g., "stopping the train" must be performed before "organizing the evacuation").

[0052] (3) Dependency (requires): indicates that the execution of an action requires another action or state as a prerequisite (e.g., "the overhead contact line is de-energized" depends on "confirming the train lowers its pantograph").

[0053] (4) Mutual exclusion: indicates that two types of actions cannot be performed simultaneously in the same situation (e.g., "adjustment of major and minor routes" and "clearing passengers at a specific station" are mutually exclusive).

[0054] 2. Automatic logical relationship mining algorithm: The system integrates multiple machine learning algorithms to mine the above relationships from historical data: (1) Association rule mining (for triggering relationships): The FP-Growth algorithm was used to analyze the co-occurrence patterns of the disposal modules. For the modules... and Calculate co-occurrence frequency and confidence level ,in This represents the probability of a module occurring. The confidence level serves as the weight for the triggering relationship. For example, if the co-occurrence frequency of "train malfunction" and "passenger evacuation" is high in historical data and the confidence level is greater than a threshold (e.g., 0.8), then a [system / mechanism] is established. side.

[0055] Formula example:

[0056] Support is calculated based on the number of times a document appears in its history.

[0057] The FP-Growth algorithm (Frequent Pattern Growth Algorithm) is preferred because it is suitable for processing sparse matrices and high-dimensional data, and does not require the generation of candidate sets, making it more efficient than the Apriori algorithm.

[0058] (2) Sequence pattern analysis (for temporal relationships): The PrefixSpan algorithm is used to discover frequent sequence patterns from ordered disposal sequences (such as action flows in historical reports). For example, pattern recognition. express exist Executed previously, thus establishing The algorithm filters noise using a minimum support threshold to ensure the reliability of temporal relationships.

[0059] Application scenario: In the "interval evacuation" process, the system extracts the time sequence chain of "stopping the train" → "authorizing evacuation" → "organizing and guiding" from the sequence.

[0060] (3) Semantic relation extraction (for dependency and mutual exclusion relations): A semantic encoder implementation based on large language models (such as BERT). For modules... and Using relation extraction functions Make a prediction: Input: Semantic vector of module content and (Generated via Sentence-BERT).

[0061] Processing: The model captures interaction features through a cross-attention mechanism, combines dependency parsing (such as subject-verb-object structure) to identify logical patterns, and finally the classifier outputs the relation type.

[0062] Output: Relation r∈R and confidence score. For example, extract the edge (execute clearance, require, security confirmation) from the text "Safety confirmation is required before clearing out customers".

[0063] 3. Graph Construction and Weight Calculation: (1) Node generation: The processing module output from S1.2 As nodes, each node contains a unique ID, a standardized name, and a feature vector. (e.g., context labels) and parameter sets (e.g., time thresholds).

[0064] (2) Edge Relationship Generation: Based on the above mining results, directed edges are added between nodes, and weights (such as confidence scores) are assigned. The system maintains a weight table. ,in Dynamic updates (see S3 optimization process).

[0065] (3) Atlas structure: Atlas It is a directed graph, where It is a set of nodes. It is an edge set. Subsequent plan generation (S2) is supported by graph traversal algorithms (such as BFS).

[0066] 4. Example of self-learning logical relationships: Train passenger clearance decision network Taking the "train passenger evacuation principle" in the "On-site handling plan of a certain city's subway control center" as an example, the system automatically constructs the following logical diagram (e.g.) Figure 2 ): (1) Trigger relationship mining: From the clause "Organize passenger clearing when the train is unable to carry passengers due to malfunction", identify the trigger condition node C001 (train malfunction) and the action node D001 (execute passenger clearing), and establish the (C001, triggerers, D001) edge, with the weight set to 0.95 based on the historical co-occurrence frequency.

[0067] (2) Dependency mining: From “interval equipment abnormality requires clearing passengers into the interval for confirmation”, semantic extraction reveals that D001 (execute clearing passengers) depends on D002 (stop subsequent trains), and the edge (D001, require, D002) is established.

[0068] (3) Mutual exclusion relationship mining: From "Cancel passenger clearing when changing from large and small routes to single route", identify that action node D003 (execute route adjustment) and D001 are mutually exclusive, and establish the edge (D003, excludes, D001).

[0069] To clearly illustrate the structure of the logic graph, taking the "train passenger clearing" scenario as an example, the graph constructed by the system is as follows: Figure 2 (Note: Nodes in the figure represent action handling modules, events, and constraints; edges are labeled with relationship types and weights.) Furthermore, based on the S3 steps (see below for details), weights can be dynamically updated. The weight of edge 1 (0.95) can be optimized based on feedback; edges are removed when their weights fall below a threshold.

[0070] S2: Intelligent Contingency Plan Generation Process The contingency plan generation process will incorporate user queries. Q As input, in the already constructed logic graph of the processing module G This is a contextualized graph traversal and constraint satisfaction reasoning performed on this dedicated inference engine.

[0071] Input: User query Q It describes the context of the target event, for example Q= "A fire broke out on a Line 2 train in the section."

[0072] Processing flow: S2.1. Contextualized Vectorization Mapping: Transforming the query Q Mapping to feature space F , obtain the query vector .

[0073] S2.2. Graph Traversal and Matching: In the processing module logic graph In the middle, find the query vector Best matching event node Execute a graph traversal algorithm (such as BFS) from... Starting from the beginning, along the edges of relationships such as triggers, retrieve the set of all relevant disposal module nodes. .

[0074] S2.3. Logical sorting and assembly: For The modules within the module logic graph handle the constraints of the precedence and require relationships, perform topological sorting, and form an ordered sequence of actions. .

[0075] Output: The pre-planned synthesis engine will generate the sequence Fill into the contingency plan template T Generate digital contingency plan draft The draft is logically clear and automatically includes key steps such as "stopping the train", "powering off the overhead contact line", and "organizing evacuation". Figure 3 This is a schematic diagram of the list of contingency plans.

[0076] S3: Continuously optimize the learning process This step is the core of the system's self-evolution. Through a closed-loop learning mechanism of "generation-review-feedback-optimization," it dynamically improves the quality of the generated contingency plan and the accuracy of the logic graph. The system receives feedback from users (such as domain experts) on the draft contingency plan, transforms it into supervisory signals, drives incremental training of the text parsing model and the contingency plan generation model, and updates the node relationships and edge weights in the logic graph of the handling module. The specific process is as follows: S3.1. Feedback Data Collection When experts reviewed the draft plan generated by the system When making corrections, the system records the correction operation. And transform it into structured training data: (1) Correct type recognition: Add modules (such as adding) Experts added a step of "confirming the train lowers its pantograph" before "power outage of the overhead contact line".

[0077] Delete module (e.g., delete) Experts removed redundant "duplicate confirmation" actions.

[0078] Adjusting the sequence (e.g., modifying timing relationships): Experts require that "stopping trains" must be executed before "evacuation authorization".

[0079] Confirmation of node logical relationships: Directly confirm the logical relationships of nodes that have been constructed in the graph.

[0080] Directly adjust the weights of logical relationship edges: Directly adjust the weights of the logical relationships between nodes that have already been constructed in the graph.

[0081] (2) Data encoding: The revised plan Encoded as a standard action sequence and the original sequence Compare and generate a difference set. .

[0082] Example: Figure 4 and Figure 5 The interface for experts to revise the draft plan was displayed, and the system automatically captured the revisions and generated a record of the differences.

[0083] S3.2 Incremental Model Update Based on the feedback data, the system performs supervised fine-tuning on the following models: (1) Fine-tuning of the text parsing model (corresponding to S1.1 and S1.2): Objective: To improve the accuracy of atomic module decomposition and feature annotation.

[0084] Method: The segmentation model was fine-tuned using the revised proposed text as training samples. and classification models The loss function is defined as the cross-entropy between the prediction module and the expert annotations:

[0085] Results: For example, after experts frequently revised the triggering conditions of the "security confirmation" module, the model more accurately identified similar contexts.

[0086] (2) Fine-tuning of the contingency plan generation model (corresponding to S2): Objective: To optimize the logical rationality of the generated contingency plan sequence.

[0087] Method: Use a sequence-to-sequence (Seq2Seq) model, input query Q, output target sequence. The loss function is based on edit distance:

[0088] Results: The model gradually learns the preferred order of actions by experts, such as "lowering the pantograph before cutting off the power".

[0089] S3.3 Dynamic Optimization of the Graph The system updates the logic diagram of the processing module based on the correction operation Δ. Edge weights and relationships in the equation: (1) Weight update algorithm: For the edge Its weight w is adjusted based on the correction frequency and expert confidence level:

[0090] Where α is the learning rate (default 0.1). This is a conflict indicator (1 if the expert correction conflicts with the original relationship, otherwise 0).

[0091] Example: If experts repeatedly confirm that "passengers must be cleared before the train can be stopped," then... The weight was increased from 0.90 to 0.96.

[0092] (2) Rules for adding and deleting relationships: Adding edges: When a new relationship is introduced through a correction (such as adding a dependency), the system adds an edge to the graph and initializes the weight (e.g., 0.8).

[0093] Deleting an edge: when the weight is below a threshold When necessary, edges (such as outdated mutual exclusion relationships) are automatically removed.

[0094] Optimization Learning Example: Correction of Overhead Contact Line Power Outage Procedure Taking the "overhead contact line power outage" scenario as an example, the closed-loop learning process is as follows: Initial plan: The system generates a draft containing sequences. .

[0095] Expert correction: The expert added a module "Confirm Train Pantograph Lowering", and the corrected sequence is as follows: .

[0096] System optimization: Model fine-tuning: The driving contingency plan generation model learns new sequences.

[0097] Graph update: Add edge (Power outage authorization, require, confirm bow reduction), weight initialized to 0.85.

[0098] Effect: In subsequent similar queries, the system automatically includes a "confirm bow lowering" step, improving the accuracy of the contingency plan.

[0099] Compared with existing technologies, this invention keyly solves the problem that relying on manually preset classification labels and static plan libraries makes it impossible to automatically extract logical relationships from data, resulting in delayed plan updates and poor adaptability. It also solves the problems of relying on a minimal task item library but lacking self-learning ability regarding logical relationships, and plan generation depending on fixed template combinations. Specifically, this invention has the following technical effects: 1. Automated Construction of Digital Emergency Response Plans Based on Large Models: This approach moves away from the traditional reliance on manual, line-by-line analysis and annotation. Through intelligent agents, it deeply analyzes unstructured data from multiple sources, including historical plans and case reports, automatically extracting atomic emergency response modules. It then autonomously uncovers the complex relationships between these modules, such as triggering, timing, dependencies, and mutual exclusion, thereby automatically constructing a structured "response module logic graph." This graph makes the previously scattered response logic within text and experience explicit and structured, laying the foundation for subsequent intelligent reasoning.

[0100] 2. Achieving Dynamic Generation of Targeted Contingency Plans Based on Logical Reasoning: Unlike keyword-based retrieval or fixed template filling, the system can leverage a pre-constructed "disposal module logic graph" and combine it with specific emergency scenarios (including multi-dimensional features such as event type, location, environment, and resources). Through scenario mapping, subgraph activation, logical constraint satisfaction, and reasoning, it dynamically generates logically consistent, step-by-step, and practical contingency plans. This approach ensures that the plan generation process is driven by logic, rather than simple matching, thereby significantly improving the rationality and operability of the plans.

[0101] 3. Achieving a Closed-Loop Cognitive System and Continuous Evolution: Constructing a complete learning closed loop of "generation—verification—feedback—optimization." The intelligent agent can transform the review and correction of the generated plan by domain experts, as well as the feedback during the actual handling process, into supervisory signals, continuously fine-tuning its internal semantic understanding model, and dynamically optimizing the node relationships and connection weights in the "handling module logic graph." This enables the system to continuously learn from practice and evolve through continuous iteration, thereby achieving autonomous adaptation and continuous improvement of the emergency plan knowledge system and handling logic.

[0102] It should be noted that, for the sake of simplicity, the method embodiments are all described as a series of actions. However, those skilled in the art should understand that the embodiments of the present invention are not limited to the described order of actions, because according to the embodiments of the present invention, some steps can be performed in other orders or simultaneously. Furthermore, those skilled in the art should also understand that the embodiments described in the specification are preferred embodiments, and the actions involved are not necessarily essential to the embodiments of the present invention.

[0103] The rail transit emergency response plan generation system based on a large-scale intelligent agent provided in this embodiment of the invention may specifically include the following modules: The logic graph construction module for the handling module is used to automatically analyze rail transit emergency handling data through a logic self-learning intelligent agent of the handling module and establish a logic graph of the handling module. The emergency plan generation module is used to receive information on rail transit emergency events and generate emergency plans based on the logic diagram of the handling module and the information on rail transit emergency events using the emergency plan generation model. The continuous optimization module records the emergency plan modification operation if the user modifies the emergency plan, and uses the modified emergency plan to incrementally train the logic self-learning agent of the disposal module and the emergency plan generation model, as well as optimize the logic graph of the disposal module based on the emergency plan modification operation.

[0104] In an optional embodiment of the present invention, the processing module logic graph construction module is further configured to: The self-learning intelligent agent of the handling module identifies multiple types of handling units from the emergency handling data of rail transit, and performs atomization processing on the action-type handling units to obtain the action handling module; the types of handling units include at least condition-type, principle clause-type, and judgment logic-type; the condition-type includes trigger conditions and constraint conditions; Each action handling module is labeled with features by a self-learning intelligent agent that performs logic processing module self-learning, resulting in action handling modules with contextual feature vectors and parameter sets. By using triggering conditions as event nodes and constraint conditions as constraint nodes, and based on the context feature vectors and parameter sets of each handling unit and action handling module, we can mine the logical relationships between action handling modules, between action handling modules and event nodes, and between action handling modules and constraint nodes. We can then construct a graph with action handling modules, event nodes, and constraint nodes as graph nodes and weighted logical relationships as directed edges, thus obtaining the logical graph of the handling modules.

[0105] In an optional embodiment of the present invention, the processing module logic graph construction module is further configured to: A hybrid analytical model was used to analyze the chapter structure of emergency response data for rail transit and segment it into semantic block sequences. Based on sequence labeling models or large language models, named entity recognition and classification are performed on semantic block sequences to obtain multiple processing units; Dependency parsing is performed on action-type processing units to identify semantic structures centered on predicate verbs. An action boundary detection algorithm guided by knowledge of the rail transit domain is used to automatically delineate the boundaries of atomic modules based on changes in the action implementer, processing object, and operation tool corresponding to the semantic structure centered on the predicate verb. For each atomic module, a standard name is generated using a standardized template based on a verb-object structure. Semantic deduplication verification is performed on all atomic modules, and modules with equivalent functions are merged. A unique identifier is assigned to the retained atomic modules to obtain the action processing module.

[0106] In an optional embodiment of the present invention, the processing module logic graph construction module is further configured to: Based on a pre-defined multi-dimensional feature labeling system, the text content of the action handling module is labeled with tags by matching keywords and rules, and the corresponding explicit contextual feature labels are marked for the action handling module. The text content of the action handling module is converted into a semantic vector and input into a text classification model that has been adaptively trained in the field of rail transit to predict and label the implicit contextual feature labels of the action handling module. Numerical parameters are identified and extracted from the text content of the action processing module using regular expressions and information extraction models. Integrate explicit contextual feature labels, implicit contextual feature labels, and numerical parameters to form a contextual feature vector and parameter set for the action handling module.

[0107] In an optional embodiment of the present invention, the processing module logic graph construction module is further configured to: Define logical relationship types, which include at least triggering relationships, sequential relationships, dependency relationships, and mutual exclusion relationships; Based on the context feature vectors and parameter sets of each processing unit and action processing module, the co-occurrence patterns of nodes are analyzed through association rule mining algorithms to identify the triggering relationships between nodes, the execution order of nodes is analyzed through sequence pattern analysis algorithms to identify the temporal relationships between nodes, and the semantic logic between node content is analyzed through semantic relationship extraction algorithms to identify the dependency and mutual exclusion relationships between nodes. By using the action handling module, event nodes, and constraint nodes as graph nodes, and the identified logical relationships as directed edges connecting the nodes, and assigning weights to each edge based on data mining confidence, the logic graph of the handling module is obtained.

[0108] In an optional embodiment of the present invention, the emergency response plan generation module is further configured to: The emergency plan generation model searches for event nodes in the logic graph of the handling modules that match the information of rail transit emergency events, and executes a graph traversal algorithm. Starting from the matched event nodes, it retrieves all relevant action handling modules based on the triggering relationship between nodes. Based on the temporal relationship, dependency relationship and mutual exclusion relationship between nodes, it performs topological sorting on the retrieved action handling modules to obtain an ordered sequence of action handling modules. Finally, it fills the ordered sequence of action handling modules into the plan template to generate the emergency plan.

[0109] In an optional embodiment of the present invention, the correction type includes adding nodes and node logical relationships, deleting nodes and node logical relationships, modifying logical relationships between nodes, confirming logical relationships between nodes, and adjusting the weights of logical relationships between nodes. The continuous optimization module is also used for: Based on the addition or removal of nodes and logical relationships during the emergency response plan modification operation, and the changes in node logical relationships, add or remove nodes and logical relationship edges, and modify the logical relationship edges between nodes in the logic graph of the handling module; Based on the frequency of confirmation of logical relationships between nodes, adjustment of the weight of logical relationships between nodes, addition or subtraction of nodes and logical relationships between nodes, and changes in logical relationships between nodes during the emergency response plan modification operation, the weight of the logical relationship edges between nodes is updated in the logic graph of the handling module.

[0110] As the system implementation is basically similar to the method implementation, it is described in a relatively simple way. For relevant details, please refer to the description of the method implementation.

[0111] It should be noted that, in this document, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Unless otherwise specified, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

[0112] The various embodiments in this specification are described in a related manner. The same or similar parts between the various embodiments can be referred to each other. Each embodiment focuses on describing the differences from other embodiments.

[0113] The above description is merely a preferred embodiment of the present invention and is not intended to limit the scope of protection of the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention are included within the scope of protection of the present invention.

Claims

1. A method for generating emergency response plans for rail transit based on a large-scale intelligent agent model, characterized in that, The method includes: The emergency response data of rail transit is automatically analyzed by a self-learning intelligent agent of the response module logic, and a logic graph of the response module is established. Receive information on rail transit emergency events and generate emergency plans based on the logic diagram of the handling module and the information on rail transit emergency events using an emergency plan generation model; If the user modifies the emergency plan, the modification operation is recorded, and the modified emergency plan is used to incrementally train the logic self-learning agent of the disposal module and the emergency plan generation model, and the logic graph of the disposal module is optimized based on the emergency plan modification operation. The system utilizes a self-learning intelligent agent to automate the analysis of rail transit emergency response data, establishing a logical graph of the response module, including: The self-learning intelligent agent of the handling module identifies multiple types of handling units from the emergency handling data of rail transit, and performs atomization processing on the action-type handling units to obtain the action handling module; the types of handling units include at least condition-type, principle clause-type, and judgment logic-type; the condition-type includes trigger conditions and constraint conditions; Each action handling module is labeled with features by a self-learning intelligent agent that performs logic processing module self-learning, resulting in action handling modules with contextual feature vectors and parameter sets. By using triggering conditions as event nodes and constraint conditions as constraint nodes, and based on the context feature vectors and parameter sets of each handling unit and action handling module, we can mine the logical relationships between action handling modules, between action handling modules and event nodes, and between action handling modules and constraint nodes. We can then construct a graph with action handling modules, event nodes, and constraint nodes as graph nodes and weighted logical relationships as directed edges, thus obtaining the logical graph of the handling modules.

2. The method according to claim 1, characterized in that, The intelligent agent, through logical self-learning of the handling module, identifies multiple types of handling units from rail transit emergency handling data, and atomizes the action-type handling units to obtain the action handling module, including: A hybrid analytical model was used to analyze the chapter structure of emergency response data for rail transit and segment it into semantic block sequences. Based on sequence labeling models or large language models, named entity recognition and classification are performed on semantic block sequences to obtain multiple processing units; Dependency parsing is performed on action-type processing units to identify semantic structures centered on predicate verbs. An action boundary detection algorithm guided by knowledge of the rail transit domain is used to automatically delineate the boundaries of atomic modules based on changes in the action implementer, processing object, and operation tool corresponding to the semantic structure centered on the predicate verb. For each atomic module, a standard name is generated using a standardized template based on a verb-object structure. Semantic deduplication verification is performed on all atomic modules, and modules with equivalent functions are merged. A unique identifier is assigned to the retained atomic modules to obtain the action processing module.

3. The method according to claim 2, characterized in that, Each action handling module is characterized by feature labeling through a self-learning agent that performs logic processing on the handling module, resulting in action handling modules with contextual feature vectors and parameter sets, including: Based on a pre-defined multi-dimensional feature labeling system, the text content of the action handling module is labeled with tags by matching keywords and rules, and the corresponding explicit contextual feature labels are marked for the action handling module. The text content of the action handling module is converted into a semantic vector and input into a text classification model that has been adaptively trained in the field of rail transit to predict and label the implicit contextual feature labels of the action handling module. Numerical parameters are identified and extracted from the text content of the action processing module using regular expressions and information extraction models. Integrate explicit contextual feature labels, implicit contextual feature labels, and numerical parameters to form a contextual feature vector and parameter set for the action handling module.

4. The method according to claim 1, characterized in that, Based on the contextual feature vectors and parameter sets of each handling unit and action handling module, the logical relationships between action handling modules, between action handling modules and event nodes, and between action handling modules and constraint nodes are mined. A graph is constructed with action handling modules, event nodes, and constraint nodes as graph nodes and weighted logical relationships as directed edges, resulting in a handling module logical graph, including: Define logical relationship types, which include at least triggering relationships, sequential relationships, dependency relationships, and mutual exclusion relationships; Based on the context feature vectors and parameter sets of each processing unit and action processing module, the co-occurrence patterns of nodes are analyzed through association rule mining algorithms to identify the triggering relationships between nodes, the execution order of nodes is analyzed through sequence pattern analysis algorithms to identify the temporal relationships between nodes, and the semantic logic between node content is analyzed through semantic relationship extraction algorithms to identify the dependency and mutual exclusion relationships between nodes. By using the action handling module, event nodes, and constraint nodes as graph nodes, and the identified logical relationships as directed edges connecting the nodes, and assigning weights to each edge based on data mining confidence, the logic graph of the handling module is obtained.

5. The method according to claim 1, characterized in that, Upon receiving information about rail transit emergency incidents, an emergency plan is generated based on the logic diagram of the response module and the rail transit emergency incident information using an emergency plan generation model. This includes: The emergency plan generation model searches for event nodes in the logic graph of the handling modules that match the information of rail transit emergency events, and executes a graph traversal algorithm. Starting from the matched event nodes, it retrieves all relevant action handling modules based on the triggering relationship between nodes. Based on the temporal relationship, dependency relationship and mutual exclusion relationship between nodes, it performs topological sorting on the retrieved action handling modules to obtain an ordered sequence of action handling modules. Finally, it fills the ordered sequence of action handling modules into the plan template to generate the emergency plan.

6. The method according to claim 1, characterized in that, The correction types include adding nodes and node logical relationships, deleting nodes and node logical relationships, modifying logical relationships between nodes, confirming logical relationships between nodes, and adjusting the weights of logical relationships between nodes. Based on the emergency plan, the correction operation optimization and handling module logic graph includes: Based on the addition or removal of nodes and logical relationships during the emergency response plan modification operation, and the changes in node logical relationships, add or remove nodes and logical relationship edges, and modify the logical relationship edges between nodes in the logic graph of the handling module; Based on the frequency of confirmation of logical relationships between nodes, adjustment of the weight of logical relationships between nodes, addition or subtraction of nodes and logical relationships between nodes, and changes in logical relationships between nodes during the emergency response plan modification operation, the weight of the logical relationship edges between nodes is updated in the logic graph of the handling module.

7. A rail transit emergency response plan generation system based on a large-scale intelligent agent model, characterized in that, The system includes: The logic graph construction module for the handling module is used to automatically analyze rail transit emergency handling data through a logic self-learning intelligent agent of the handling module and establish a logic graph of the handling module. The emergency plan generation module is used to receive information on rail transit emergency events and generate emergency plans based on the logic diagram of the handling module and the information on rail transit emergency events using the emergency plan generation model. The continuous optimization module is used to record emergency plan modification operations if users modify the emergency plan, and to incrementally train the self-learning agent of the handling module logic and the emergency plan generation model using the modified emergency plan, as well as optimize the logic graph of the handling module based on the emergency plan modification operations. The logic graph construction module for the processing module is also used for: The self-learning intelligent agent of the handling module identifies multiple types of handling units from the emergency handling data of rail transit, and performs atomization processing on the action-type handling units to obtain the action handling module; the types of handling units include at least condition-type, principle clause-type, and judgment logic-type; the condition-type includes trigger conditions and constraint conditions; Each action handling module is labeled with features by a self-learning intelligent agent that performs logic processing module self-learning, resulting in action handling modules with contextual feature vectors and parameter sets. By using triggering conditions as event nodes and constraint conditions as constraint nodes, and based on the context feature vectors and parameter sets of each handling unit and action handling module, we can mine the logical relationships between action handling modules, between action handling modules and event nodes, and between action handling modules and constraint nodes. We can then construct a graph with action handling modules, event nodes, and constraint nodes as graph nodes and weighted logical relationships as directed edges, thus obtaining the logical graph of the handling modules.

8. The system according to claim 7, characterized in that, The logic graph construction module for the processing module is also used for: A hybrid analytical model was used to analyze the chapter structure of emergency response data for rail transit and segment it into semantic block sequences. Based on sequence labeling models or large language models, named entity recognition and classification are performed on semantic block sequences to obtain multiple processing units; Dependency parsing is performed on action-type processing units to identify semantic structures centered on predicate verbs. An action boundary detection algorithm guided by knowledge of the rail transit domain is used to automatically delineate the boundaries of atomic modules based on changes in the action implementer, processing object, and operation tool corresponding to the semantic structure centered on the predicate verb. For each atomic module, a standard name is generated using a standardized template based on a verb-object structure. Semantic deduplication verification is performed on all atomic modules, and modules with equivalent functions are merged. A unique identifier is assigned to the retained atomic modules to obtain the action processing module.

Images