Method for rapidly generating multi-source heterogeneous character event graph facing burst situation awareness

Abstract

The application discloses a kind of multi-source heterogeneous character event graph rapid generation methods for burst situation awareness, belong to emergency management technical field. Including: real-time access multi-source heterogeneous data stream and standardization processing;Adopt distillation BERT light weight model pipeline extraction character, event and its relationship;Based on hybrid storage structure, with node and edge as granularity incremental update graph;Through evolution stage identification model, determine the incubation period, outbreak period, duration or subsidence period of event, configure priority weight and schedule;Build complete and approximate double-path reasoning engine, switch reasoning path by time threshold constraint self-adaptive;After formatting processing, push to front end display.The application reduces graph generation delay effectively by streaming computing, model light weight, fine-grained incremental update and double-path self-adaptive reasoning, priority guarantee key event response, meet the real-time and accuracy requirements of burst situation awareness.

Description

Technical Field

[0001] This application relates to the field of emergency management technology, specifically to a method for rapidly generating multi-source heterogeneous person and event maps for emergency situation awareness. Background Technology

[0002] Knowledge graphs, through structured semantic networks, formally describe entities, concepts, and their relationships in the objective world, and have become a key technology in big data analytics and situational awareness. For situational awareness scenarios such as public safety emergencies and emergency management, the rapid generation of person-event graphs is a core means of supporting real-time decision-making. These scenarios require that the graph generation speed must match the speed of situational evolution; any significant processing delay will lead to outdated graph information and a loss of its value in assisting decision-making.

[0003] Existing knowledge graph construction methods primarily focus on extraction accuracy and reasoning completeness in static or quasi-static scenarios, exhibiting the following technical shortcomings when handling sudden events. First, event extraction typically employs batch processing, using batches rather than individual data points as the processing granularity, and lacks effective model lightweighting techniques. This results in long end-to-end latency from data input to event element output, failing to meet millisecond-level real-time response requirements. Second, incremental updates to the graph are usually at the subgraph or fixed time window granularity, easily triggering full recalculation when high-frequency data arrives, leading to low update efficiency and excessive resource consumption. Third, task scheduling often uses first-in-first-out (FIFO) or simple time priority strategies, failing to dynamically adjust processing priorities based on event evolution stages such as outbreak and decline phases, or whether key figures are involved, resulting in delayed responses to critical event nodes. Finally, inference engines generally employ a uniform, precise inference path, which is excessively time-consuming when rules are complex or data volumes are large. The lack of a mechanism for adaptively switching inference paths based on time constraints makes it difficult to balance inference efficiency and accuracy under strict timeliness requirements.

[0004] The aforementioned shortcomings lead to common problems in existing methods during emergency situation awareness scenarios, such as high latency in knowledge graph generation, untimely response to critical events, and difficulty in balancing reasoning efficiency and timeliness. These limitations restrict the real-time decision support role of knowledge graphs in emergency response. Therefore, there is an urgent need for a rapid generation solution for person-event knowledge graphs that takes a holistic approach and addresses emergency situations. Summary of the Invention

[0005] The purpose of this invention is to provide a method for rapidly generating multi-source heterogeneous person and event maps for emergency situation awareness, which can effectively solve the problems in the background technology mentioned above.

[0006] To achieve the above objectives, the technical solution adopted by the present invention is as follows: A method for rapidly generating multi-source heterogeneous person and event maps for emergency situation awareness includes the following specific steps: Step S1: Based on the event-driven architecture, real-time access to multi-source heterogeneous data streams is performed, and standardized data units are output from the received data. Step S2: The Distilled BERT lightweight entity recognition model is used to perform fast reasoning on the standardized data units, and the event element objects containing person entities, event entities and their relationships are extracted through pipelined parallel processing. Step S3: Maintain the character event graph based on the hybrid storage structure, execute the graph change propagation algorithm, and perform incremental updates at the granularity of nodes and edges; Step S4: Input the extracted events into the event evolution stage identification model to determine the evolution stage, configure priority weights according to the determination results, and send them into the priority queue for scheduling and management. Step S5: Construct a dual-path inference engine that includes a complete inference path and an approximate inference path. Monitor processing time through a time threshold constraint model and adaptively switch inference paths. Step S6: Format the updated character event graph data and push it to the front-end interface for rendering and display.

[0007] In summary, this application includes at least one of the following beneficial technical effects: 1. This invention upgrades event extraction from the traditional batch processing mode to a streaming processing mode by combining a streaming computing architecture with the distilled BERT lightweight model. The processing flow is triggered immediately upon data arrival, avoiding the waiting delay in the batch processing mode. The number of parameters in the distilled BERT model is significantly reduced compared to the standard BERT model. Combined with a multi-layer Transformer structure and dynamic quantization technology, the end-to-end latency from data input to event element output is controlled within a preset range, meeting the rapid response requirements in sudden situational awareness scenarios. It has significant advantages over the long processing latency of existing technologies.

[0008] 2. This invention replaces the coarse-grained update method with subgraph or time window granularity in the prior art by designing a fine-grained incremental update mechanism at the node and edge levels. The graph change propagation algorithm only performs correlation calculation and edge creation operations on the affected local nodes. The semantic correlation threshold control mechanism avoids the generation of invalid edges. The hybrid storage structure of adjacency list and inverted index ensures that the graph query performance is not affected after incremental update. In high-frequency data arrival scenarios, it effectively avoids full recalculation, significantly reduces computing resource consumption, and significantly improves update efficiency.

[0009] 3. This invention achieves intelligent perception of the importance and evolution stage of events through the collaborative design of an event evolution stage identification model and a dynamic priority scheduling algorithm. The differentiated weight vectors of the four stages ensure that events involving key figures during the outbreak period receive the highest processing priority. The forced priority enhancement mechanism for key figures ensures immediate response to key targets. The priority queue, combined with the timeout degradation strategy, maintains system throughput while ensuring priority processing of key events, avoiding the problem of delayed response to key events caused by the first-in-first-out scheduling strategy in the prior art.

[0010] 4. This invention achieves an adaptive selection mechanism for inference paths through the design of a dual-path inference engine and a time threshold constraint model. The complete inference path ensures the accuracy of the inference results, while the approximate inference path achieves fast inference through graph neural network encoding and vector similarity calculation. The time threshold constraint model dynamically switches inference paths based on real-time processing time, ensuring that usable graphs can still be output under strict timeliness requirements. The confidence label mechanism provides users with an intuitive reference for the reliability of inference results, taking into account both the timeliness and accuracy requirements of inference. Attached Figure Description

[0011] Figure 1 This is a schematic diagram of the overall technical architecture for a method to rapidly generate multi-source heterogeneous person and event maps for emergency situation awareness.

[0012] Figure 2 This is a schematic diagram illustrating the principle of event element extraction based on distillation BERT in a method for rapidly generating multi-source heterogeneous person event maps for emergency situation awareness.

[0013] Figure 3 A schematic diagram of the logical flow for incremental map updates and association construction.

[0014] Figure 4 A schematic diagram of the logical flow for identifying and prioritizing event evolution stages.

[0015] Figure 5 This is a schematic diagram illustrating the core principles of dual-path reasoning and time threshold constraints. Detailed Implementation

[0016] To make the objectives, technical solutions, and advantages of this invention clearer, the following description is provided in conjunction with the appendix. Figure 1 To be continued Figure 5 The present invention will be further described in detail below with reference to specific embodiments.

[0017] This invention discloses a method for rapidly generating multi-source heterogeneous person and event maps for emergency situation awareness. Through the collaborative design of core modules such as streaming computing architecture, distilled BERT lightweight model, incremental map update mechanism, event evolution stage identification and priority scheduling algorithm, and dual-path inference engine, it achieves end-to-end latency compression from multi-source heterogeneous data input to person and event map output, ensuring that the map generation speed matches the speed of emergency situation evolution. The specific implementation is carried out according to the following steps.

[0018] The first step, S1, is the streaming data reception and preprocessing step, responsible for the data entry of the entire map generation process, realizing real-time access and standardized processing of multi-source heterogeneous data streams. This method, through the coordinated operation of a parser component, a standardization processing module, a quality assessment rule engine, a data cleaning module, and a message queue buffering mechanism, transforms the raw data into high-quality data units in a unified format, providing stable and reliable data input for subsequent event element extraction. The specific implementation steps are as follows.

[0019] Step S101: Configure the streaming data receiving module as the data entry point for the entire map generation process, responsible for real-time access to multi-source heterogeneous data streams. The streaming data receiving module supports parsing plain text format, log file format, speech recognition-transcribed text format, structured event stream format, network protocol data packet format, and database change capture format. For different data formats, this method calls the corresponding parser component to perform semantic parsing, extracting key data elements such as the original text content, timestamp information, data source identifier, and original data structured fields.

[0020] Step S102: After data parsing is completed, the standardization process begins. First, a unified character encoding conversion is performed, converting all character encoding formats to UTF-8 encoding to ensure the text content is correctly parsed.

[0021] Step S103: Next, text normalization is performed. Text normalization includes unifying capitalization, converting full-width and half-width characters, filtering special characters, and standardizing whitespace characters to eliminate redundant variations at the text level.

[0022] Step S104, followed by date and time format standardization. Date and time format standardization converts various time expression formats into two unified representations: Unix timestamps and ISO8601 standard time strings, ensuring consistency in time information processing.

[0023] In step S105, the data field mapping module maps the field names and values ​​of the original data to standardized field identifiers and standardized field values ​​according to the preset field mapping rule table.

[0024] Step S106: After data standardization, quality control is performed by the data quality assessment rule engine. Based on preset data quality assessment rules, the data quality assessment rule engine performs integrity verification, validity verification, and consistency verification on each standardized data item.

[0025] Integrity checks are used to verify if required fields are missing; when the missing field rate exceeds a preset threshold, the data is marked as low-quality data. Validity checks are used to verify if the range and format of field values ​​meet expectations; for example, whether the timestamp field value is within a reasonable time interval, or whether the numeric field value exceeds the valid range. Consistency checks are used to verify if there are inconsistencies in the attribute descriptions of the same entity across different data sources.

[0026] When the data quality assessment result fails to meet the preset quality threshold, the data is marked as invalid and enters the data cleaning stage.

[0027] Step S107: The data cleaning module is responsible for processing invalid or low-quality data. The data cleaning module provides three cleaning strategies.

[0028] The first strategy is the direct discard strategy. The direct discard strategy is suitable for scenarios where the amount of data is sufficient and the impact of a single data record is limited, and data records with severely insufficient integrity are directly discarded.

[0029] The second strategy is the default value filling strategy. The default value filling strategy is suitable for scenarios where some fields are missing but the core fields are complete. It uses preset default values ​​to fill the missing fields, ensuring that the data can continue to flow to subsequent processing stages.

[0030] The third strategy is the manual review queue strategy. This strategy is suitable for scenarios where the data is critical but there are quality disputes. This method pushes the data to the manual review queue, waiting for human confirmation before deciding whether to continue processing.

[0031] After the data cleaning is completed, the data units that pass the quality verification enter the processing stage of step S2, while the data units that fail the quality verification are recorded in the abnormal data log.

[0032] Step S108: This method configures a message queue buffering mechanism to achieve asynchronous data decoupling and traffic shaping. The message queue buffering mechanism adopts a producer-consumer pattern: the data preprocessing module acts as the producer, pushing processed data to the message queue; the event extraction module in step S2 acts as the consumer, pulling data from the message queue for subsequent processing.

[0033] The message queue's buffer capacity can dynamically adjust according to the load: it automatically expands the buffer capacity to accommodate more data to be processed when the load is high, and automatically shrinks the buffer capacity to release computing resources when the load decreases. The message queue's persistence mechanism ensures that data is not lost in the event of an abnormal restart, and it also supports a message acknowledgment mechanism to ensure that each piece of data is processed at least once.

[0034] Step S109: The real-time receiving capability of the streaming data receiving module is implemented based on an event-driven architecture. When new data is generated by an external data source, this method obtains the data in real time through the push interface or polling interface provided by the data source and pushes the data to the internal processing pipeline.

[0035] The data push interface supports multiple access methods, including HTTP Webhook, gRPC streaming interface, and message middleware subscription. The internal processing pipeline adopts an asynchronous non-blocking processing mode, triggering the processing flow immediately upon data arrival without waiting for the previous data to complete, thus achieving streaming processing capabilities.

[0036] Step S1 constitutes the complete workflow of the streaming data reception and preprocessing stage. This stage uses a parser component to adapt the format of multi-source heterogeneous data, standardizes the data into an internal standard format, filters low-quality data through quality assessment and cleaning, smooths traffic fluctuations through a message queue buffering mechanism, and finally achieves real-time data access based on an event-driven architecture. After this step, the method outputs standardized data units that meet quality requirements, providing a unified and reliable input foundation for event element extraction in step S2.

[0037] The next step, S2, employs the distilled BERT lightweight entity recognition model to quickly extract event elements from the preprocessed text data. This will be explained step-by-step from three aspects: model training, model structure, inference optimization, and pipeline processing.

[0038] Step S201: Construct the distilled BERT student model and perform knowledge distillation training. The training data is divided into two parts. The first part is a large-scale unlabeled corpus used by the teacher model to generate soft labels. The second part is a manually labeled entity recognition dataset, containing text and its corresponding BIO label sequences. In the BIO labeling system, the B label represents the starting position of the entity, the I label represents the continuation position of the entity, and the O label represents the non-entity position. Entity types include person entity type, location entity type, organization entity type, time entity type, event action type, and event object type.

[0039] The teacher model uses a standard 12-layer BERT model. The student model is designed with a 6-layer Transformer structure, and its parameter count is 40% of that of the teacher model. The training process is as follows: First, the teacher model is used to perform inference on a large-scale unlabeled corpus, generating a soft-label probability distribution for each corpus entry. The soft-label probability distribution refers to the probability vector of each token output by the teacher model belonging to each category. Then, the joint loss function is defined:

[0040] in, This represents the hard-label cross-entropy loss, calculated based on manually labeled data. The soft-label distillation loss is calculated based on the KL divergence between the soft-label probability distribution output by the teacher model and the probability distribution output by the student model. This is the weight coefficient, with a value of 0.7. The training objective is to minimize the joint loss function. This allows the student model to maintain high recognition accuracy while reducing the number of parameters and computational complexity.

[0041] Step S202: Construct the distilled BERT model structure, which includes an input layer, multiple Transformer encoding layers, and an output layer. The input layer is responsible for converting the segmented text token sequence into an embedded representation. Specifically, it performs an addition operation on the three types of embedding vectors: token embedding, position embedding, and paragraph embedding.

[0042] The multi-layer Transformer encoding layer employs a self-attention mechanism and a feedforward neural network structure, stacking a total of 6 layers. Each layer includes: a multi-head self-attention sublayer followed by residual connections and layer normalization, and a feedforward neural network sublayer followed by residual connections and layer normalization. The calculation formula for the self-attention mechanism is as follows:

[0043] in, Represents the query vector matrix. Represents the key vector matrix, Represents a value vector matrix. This represents the dimension of the key vector. This represents the output matrix of the self-attention mechanism. The multi-layer Transformer encoding layer achieves deep semantic modeling of the input text by stacking six layers of self-attention structure.

[0044] The output layer uses a Conditional Random Field (CRF) algorithm to output the corresponding entity label for each token in the input sequence. The CRF layer learns the transition probabilities and emission probabilities between the label sequences to output the globally optimal entity label sequence. The emission probabilities are provided by distilling the output of the last layer of the BERT model, while the transition probabilities are learned by the CRF layer during training.

[0045] Step S203: In the model inference stage, dynamic quantization and inference optimization techniques are employed. Dynamic quantization reduces the precision of model weights from 32-bit floating-point to 16-bit floating-point or 8-bit integer representation to improve inference speed. Inference optimization techniques include the following:

[0046] Operator fusion: Combines multiple consecutive computational operations into a single computational kernel, reducing memory accesses and kernel startup overhead.

[0047] Memory reuse: By pre-allocating a fixed-size GPU memory pool, the performance overhead caused by repeatedly allocating and releasing memory during inference is avoided.

[0048] Batch processing optimization: Multiple data entries are merged into batches for parallel inference, leveraging the parallel computing capabilities of the GPU.

[0049] Step S204: Construct an event extraction pipeline and control end-to-end latency. The event extraction pipeline decomposes the text data processing flow from input to output into 4 serial stages. Each stage is set up with an independent message queue buffer to achieve asynchronous decoupling between stages.

[0050] The first stage is the data preprocessing stage, which performs word segmentation, stop word filtering, and named entity recognition preprocessing operations on the input text.

[0051] The second stage is the entity recognition stage, which inputs the segmented text sequence into the distillation BERT model and outputs entity boundaries and entity type labels.

[0052] The third stage is the relationship extraction stage, which extracts the types of relationships between entities based on the identified person entities and event entities.

[0053] The fourth stage is the event element assembly stage, which assembles the identified person entities, relationship types, and event information into structured event element objects.

[0054] The four stages work together using parallel computing and pipeline technology: when the first stage processes the Nth data, the second stage processes the (N-1)th data simultaneously, and so on, to achieve instruction-level pipeline parallelism.

[0055] The distillation-based BERT lightweight entity recognition model maintains an end-to-end latency of less than 200 milliseconds from data input to event element output. The latency breakdown is as follows: data preprocessing (20 milliseconds), model inference (80 milliseconds), relation extraction (30 milliseconds), event element assembly (20 milliseconds), message queue transmission (30 milliseconds), and other overhead (20 milliseconds). Through meticulous management and optimization of the time consumed at each stage, the entire pipeline is ensured to operate stably under stringent timeliness requirements.

[0056] In summary, step S2 constitutes the event element extraction stage based on BERT distillation. This stage trains a lightweight student model using knowledge distillation technology, combines dynamic quantization and inference optimization techniques to reduce computational overhead, and then compresses end-to-end latency through a four-stage pipeline parallel processing, ultimately achieving high-speed conversion from text data to structured event elements. After this step, the method outputs event element objects containing person entities, event entities, and their relationships, providing structured input data for the incremental graph update in step S3.

[0057] The next step, S3, involves incrementally adding the event elements extracted in step S2 to the existing graph structure and constructing semantic association edges between the new nodes and existing nodes. The core design principle of incremental updates is to update only the local graph regions affected by the new data, avoiding a full recalculation of the entire graph, thereby reducing the computational overhead and response latency of the update operation. This is implemented according to the following steps.

[0058] Step S301: Design the graph storage structure, adopting a hybrid structure of adjacency list and inverted index. The adjacency list is used to maintain the direct neighbor information of each node in the graph. This method uses a fragmented storage strategy to divide the entire graph into multiple graph fragments, with each graph fragment stored on an independent storage node.

[0059] The sharding strategy is implemented based on a consistent hashing algorithm: a hash value is calculated based on the unique identifier of each node, and the hash value is mapped to a shard number from 0 to N-1, ensuring that newly added nodes can be automatically routed to the corresponding graph shard for storage. Each record in the adjacency list contains the source node identifier, the target node identifier, edge attribute information, and edge weight information, and a doubly linked list is used to realize the bidirectional association between the source node and the target node, as well as between the target node and the source node.

[0060] Inverted indexes are used to support fast queries based on attributes and types. An inverted index uses the attribute name and attribute value as the index key, and a list of all node identifiers containing the attribute value as the index value.

[0061] When querying nodes that satisfy specific attribute conditions, the corresponding index key is first located in the inverted index. Then, all node identifiers contained in the index value list are retrieved to achieve attribute retrieval. The inverted index supports both range queries and fuzzy queries of attribute values: range queries are implemented by constructing a B-tree index structure, and fuzzy queries are implemented by using a prefix tree index structure or a suffix tree index structure.

[0062] Step S302: Execute the graph change propagation algorithm to locate candidate affected nodes and calculate semantic relevance. When a new event element arrives, the graph change propagation algorithm performs an update operation according to the following process: First, locate the set of existing nodes that may be affected by the new node in the graph index structure.

[0063] The index structure employs a two-level structure: a global view index and a sharded local index. The global view index records the graph shard number to which each node belongs, while the sharded local index records the spatial location information and semantic clustering information of nodes within a graph shard. Based on the semantic features of a new node, existing nodes with semantically similar characteristics to the new node are retrieved from the sharded local index as candidate influential nodes.

[0064] Next, the semantic association degree between the newly added node and each candidate influencing node is calculated. The semantic association degree calculation uses a pre-trained language model encoder to encode both the newly added node and existing nodes as dense vector representations. The language model encoder is based on a Transformer architecture, and the pre-training process is as follows: unsupervised training is performed using a large-scale general text corpus such as Wikipedia or news corpora, employing a masked language model task.

[0065] Specifically, 15% of the tokens in the input text are randomly masked, and the training objective is to predict the masked tokens based on the context. The loss function is cross-entropy loss. After pre-training, the language model encoder can learn the deep semantic information of the node text descriptions. The formula for calculating semantic relevance is as follows:

[0066] in, This represents the semantic vector of the newly added node A. This represents the semantic vector of an existing node B. Semantic vectors The length of the mold, Semantic vectors The length of the mold, Semantic vectors With semantic vectors dot product, This represents the cosine similarity between the new node A and the existing node B. The semantic relevance ranges from -1 to 1. The closer the value is to 1, the higher the semantic relevance between the two nodes. The closer the value is to -1, the lower the semantic relevance or the negative correlation between the two nodes.

[0067] A new edge is created between a new node and an existing node only when the semantic relevance exceeds a preset threshold of 0.7. The semantic relevance threshold of 0.7 has been validated through multiple comparative experiments, achieving a balance between recall and precision. Setting the semantic relevance threshold too low will generate a large number of edges with low semantic relevance, leading to increased graph noise and decreased query efficiency; setting it too high will miss some valid semantic relationships, resulting in incomplete graph information.

[0068] Step S303: Perform edge creation operation and update the shard index. The edge creation operation only updates the adjacency list and inverted index of the corresponding graph shard, avoiding access to and modification of other graph shards. The graph change propagation algorithm updates the graph shard adjacency list of the source node and the graph shard adjacency list of the target node simultaneously when creating a new edge, ensuring the bidirectional consistency of the graph.

[0069] Meanwhile, the inverted index needs to add index records for new edges to support subsequent edge-based attribute query operations. The hybrid storage structure of adjacency list and inverted index ensures that graph query performance is not affected after incremental updates. Query operations can directly use the inverted index to quickly locate the target node without traversing the entire graph.

[0070] Step S304: Configure the incremental update checkpoint mechanism and graph version management. The incremental update checkpoint mechanism is used to record the version status of the graph and supports fast backtracking operations based on version numbers. After each incremental update is completed, this method automatically generates a new version snapshot, recording the current graph's topology and node attribute information.

[0071] Version snapshots employ an incremental storage strategy, saving only the differences from the previous version. These differences include lists of newly added nodes, newly added edges, deleted nodes, and deleted edges. The differences are stored in a compact binary encoding format to reduce storage overhead. Version snapshots also record creation timestamps, version numbers, and snapshot checksums, supporting historical graph queries and backtracking operations based on time ranges or version numbers.

[0072] The graph version management module supports multi-version storage and fast retrieval of historical graph states. Users can query the graph structure of any historical version, trace the graph state at a specific point in time, and compare the differences between two historical versions to analyze the graph's evolution. The graph version management module also supports graph branching, allowing users to create new graph branches from any historical version and make experimental modifications on the branches without affecting the main graph structure.

[0073] Step S3 constitutes the incremental graph update and association construction phase. This phase supports efficient querying through a hybrid storage structure of adjacency lists and inverted indexes, achieves localized incremental updates through a graph change propagation algorithm, controls the accuracy of edge creation through semantic relevance thresholds, and supports historical backtracking through an incremental update checkpoint mechanism and graph version management.

[0074] After this step, the method integrates event elements into the existing graph and outputs an updated character event graph, providing graph data to be processed for event evolution stage identification and priority scheduling in step S4.

[0075] The next step is step S4 of the method in this embodiment: event evolution stage identification and priority scheduling. The event evolution stage identification and priority scheduling module is responsible for determining the evolution stage of the extracted events and dynamically adjusting the processing priority of the events according to the determination results, so as to ensure that key personnel event nodes get priority processing resources and are displayed on the screen. Specifically, it is carried out according to the following steps.

[0076] Step S401: Construct the training dataset for the event evolution stage identification model. The dataset consists of event sequence samples with stage labels. Each sample contains time-series features and content features of the same event within a continuous time window. The time-series features specifically include the event's occurrence timestamp, the duration from occurrence to the current moment, the rate of change of the number of news reports per unit time (i.e., frequency change), and the change in sentiment intensity rating (i.e., intensity change).

[0077] The content features specifically include word vector representations of the event summary text, the number of different individuals involved in the event description, the number of different organizations involved, and event type encodings determined according to a pre-defined classification system. The dataset is labeled with manually annotated event evolution stages, divided into four categories: latent period, outbreak period, duration period, and decline period.

[0078] When labeling, the stage where the event initially takes shape and the amount of media coverage is less than 30% of the daily average is marked as the incubation period; the stage where the event's spread speed, i.e., the hourly growth rate of the number of news items, first exceeds 50% and the social attention index continues to rise is marked as the outbreak period; the stage where the growth rate of the number of news items falls back to less than 10% but the daily average news volume is still more than twice the level before the event is marked as the duration period; and the stage where the number of news items related to the event declines for three consecutive time windows and the total amount is less than 20% of the peak is marked as the decline period.

[0079] Step S402: Design the network structure and loss function of the event evolution stage recognition model. The model in this step adopts a recurrent neural network structure, specifically using gated recurrent units as the core computational units. The model input layer receives an event feature sequence with a fixed time window length T, and the feature vector dimension of each time step is D.

[0080] The gated recurrent unit layer contains a single-layer network with a hidden state dimension of H. It processes the input sequence step by step, and finally outputs the hidden state of the last time step as the temporal encoding vector of the event. A fully connected classification layer is then connected after the temporal encoding vector. The output dimension of the fully connected classification layer is 4, corresponding to the 4 evolution stages, and the output is converted into a probability distribution using a softmax activation function. The model's loss function uses the cross-entropy loss commonly used in classification tasks, and its calculation formula is as follows:

[0081] in, This represents the stage classification loss value for a single sample. This is the category index for the evolutionary stage, with values ​​ranging from 1 to 4. Let be the value of the one-hot encoded vector of the sample's true label in the c-th category, where 1 represents the category corresponding to the true label and 0 represents other categories. Let c be the probability value of the c-th class in the model's predicted output. Let represent the logarithmic function with the natural constant e as the base. The goal of model training is to minimize the average cross-entropy loss over the entire training dataset, enabling the model to identify the evolutionary stage of an event based on its time-series and content features.

[0082] Step S403: Use the trained event evolution stage identification model to determine the stage of the current event. The model receives the time series features and content features extracted from the event elements in step S2, outputs the probability distribution of the event belonging to four stages: incubation period, outbreak period, duration period, and decline period, and selects the stage with the highest probability value as the result of determining the evolution stage of the current event.

[0083] Step S404: Configure the corresponding priority weight vector based on the determination results of the event evolution stage. The four stages correspond to different priority weights: Events involving key figures during the outbreak phase are weighted at 1.0, the highest priority, ensuring that such events receive immediate processing resources; events during the duration phase are weighted at 0.7, the second highest priority, ensuring timely processing; events during the incubation phase are weighted at 0.4, a medium priority, as their processing priority is lower but processing opportunities are still retained; and events during the decline phase are weighted at 0.2, the lowest priority, as their processing resource allocation is most limited.

[0084] Step S405: Perform key person identification and forced priority elevation. This embodiment maintains a preset person database, which records the entity identifiers, attribute information, and attention level labels of persons requiring special attention. The preset person database supports dynamic expansion: new key person entries can be added through a configuration interface, or frequently occurring persons can be automatically added to the preset person database based on event correlation frequency learning.

[0085] When the current event is detected to involve a key figure in the preset person database, this step automatically forces the priority weight of the event to be increased to 1.0, overriding the original weight determined according to the evolution stage in step S404, to ensure an immediate response to events related to key figures.

[0086] Key person matching employs two modes: exact matching and fuzzy matching. Exact matching requires that the name of the person extracted from the event be completely consistent with the record in the preset person database. Fuzzy matching allows for minor character differences, but can still identify the same person through the edit distance algorithm.

[0087] Step S406: Send the events and their priority weights into the priority queue for scheduling management. The priority queue is the core data structure of the scheduler, implemented using a max-heap. The top element of the max-heap is always the event with the highest current priority weight, ensuring that high-priority events are retrieved first and allocated processing resources.

[0088] For example, when an event with a burst phase weight of 1.0 and an event with a latency phase weight of 0.4 are both waiting in the queue, the max-heap ensures that the event with weight 1.0 is always at the top of the heap and is processed first. When the queue is full, a low-priority event eviction mechanism is automatically triggered. The eviction strategy prioritizes eviction of events in the decay phase, while retaining at least one latency phase event for situational early warning, preventing the scheduling and management process from completely ignoring early signals.

[0089] Step S407: Maintain the timeout mechanism and degradation processing for pending events. The scheduler assigns a maximum waiting time threshold to each event entering the priority queue, for example, set to 500 milliseconds. The scheduler continuously monitors the actual waiting time of each event in the queue.

[0090] When the waiting time for an event exceeds a preset timeout threshold, the scheduler automatically performs degradation processing on the event. Degradation processing strategies include: reducing the priority weight of the event by one level, for example, from 0.7 to 0.4; reducing the computing resources allocated to the event, such as limiting the number of neural network layers used in subsequent inference stages; or delaying the event to the next processing cycle.

[0091] The timeout mechanism is designed to prevent the entire queue from stalling due to event processing blockage or long-term suppression of priority, ensuring that high-priority events can receive a capped response time even if they are delayed due to abnormal circumstances.

[0092] In summary, step S4 achieves intelligent perception of the event evolution state through the training phase classification model, configures differentiated priorities according to different stages, and introduces a mechanism for forced elevation of key personnel and timeout degradation, so that the graph generation cost method can prioritize key events in emergency situations, while maintaining the ability to continuously monitor the overall situation, providing a reasonable task scheduling basis for the inference path selection in step S5.

[0093] The next step, S5, involves dual-path reasoning and time threshold constraints, and is implemented according to the following sub-steps: Step S501: Construct a dual-path inference engine. This dual-path inference engine comprises two independent inference channels: a full inference path and an approximate inference path. The full inference path prioritizes inference accuracy and is suitable for scenarios with ample time resources; the approximate inference path prioritizes inference speed and is suitable for scenarios with stringent time constraints. The two paths work collaboratively, adaptively selected by the time threshold constraint model based on real-time processing time.

[0094] Step S502: Perform rule-based reasoning for the complete reasoning path. The complete reasoning path is based on a pre-defined knowledge reasoning rule base for precise reasoning. The rule base contains three types of reasoning rules: The first category is the rules for reasoning about interpersonal relationships, which define the deductive logic for social, professional, and kinship relationships between individuals. For example, if entity A and entity B are mentioned together in the same report and the keyword "colleague" appears, then it is inferred that entity A and entity B have a colleague relationship.

[0095] The second category is event-causal reasoning rules, which define the logical transmission of causal relationships between events. For example, if event E1 occurs and event E2 immediately follows, and the description of event E1 contains words such as "caused" or "triggered," then it is inferred that event E1 caused event E2.

[0096] The third category is time-constrained reasoning rules, which define the constraint relationships between events in the time dimension. For example, if the timestamp of event E1 is earlier than the timestamp of event E2, then it is inferred that event E1 occurred before event E2.

[0097] The execution process of the complete inference path is divided into three stages: Phase 1 is the rule matching phase, which iterates through all reasoning rules in the rule base and checks whether the triggering conditions of each rule are met. Triggering conditions include node type matching, attribute values ​​meeting thresholds, and the existence of a relational pattern.

[0098] Phase 2 is the rule application phase. When the triggering conditions of a rule are met, the reasoning actions defined by the rule are executed, generating new reasoning conclusions. These conclusions can be new character relationship edges, event causal edges, or temporal constraint edges.

[0099] Phase 3 is the result verification phase, which verifies the consistency of the reasoning conclusions. Verification includes: whether the newly generated edge logically conflicts with existing edges in the graph (e.g., simultaneously deducing that A is B's father and A is B's son); and whether the timestamp of the new edge contradicts existing time constraints. Only conclusions that pass verification are added to the graph.

[0100] Step S503: Construct a graph neural network encoder for approximate reasoning paths. This encoder uses a graph attention network structure and requires pre-training. The training dataset is constructed as follows: randomly sampled connected subgraphs of fixed size from public knowledge graphs or historically generated person / event graphs using this method. Each connected subgraph contains multiple nodes and edges; nodes have textual description attributes, and edges have relation type labels. The training task uses link prediction, i.e., randomly occluding some edges in the connected subgraphs, requiring the model to predict the existence and relation type of the occluded edges.

[0101] The graph neural network encoder takes as input an adjacency matrix and a node feature matrix of a connected subgraph. Rows in the node feature matrix correspond to nodes, and columns correspond to pre-trained word vectors describing the node's text. The encoder iteratively aggregates neighbor information, outputting a low-dimensional vector representation of each node. The encoder consists of L stacked layers, each containing message passing and neighbor aggregation operations. Message passing: Each node generates a message vector to send to each neighbor based on its current vector and the type of edges. Neighbor aggregation: Each node collects message vectors from all neighbors, calculates the weights of different neighbors using an attention mechanism, and after weighted summation and nonlinear transformation, obtains the output vector of this layer.

[0102] The training loss function is the binary cross-entropy loss, calculated as follows:

[0103] in, This represents the link prediction loss value. This represents the total number of edge prediction tasks in the training samples. For sample index, For the first The true label of each sample is set to 1 if the occluded edge actually exists, and 0 otherwise. For graph neural network encoders to predict the first... The probability value of the existence of an edge. Represented by natural constant The base is a logarithmic function. The training objective is to minimize... This allows the node vectors output by the encoder to retain local graph structure information, making it easier to quickly determine whether there is a relationship between nodes through vector similarity.

[0104] Step S504: Perform fast association reasoning for approximate reasoning paths. When it is necessary to determine whether there is an association between node A and node B, this method first uses a trained graph neural network encoder to obtain the vector representation of node A. Vector representation of node B Then, the cosine similarity between the two vectors is calculated as a measure of their relevance. The formula is as follows:

[0105] in, This represents the graph neural network encoding vector of node A. This represents the graph neural network encoding vector of node B. Representing vectors The length of the mold, Representing vectors The length of the mold, Represents the dot product of two vectors. This represents the graph neural network correlation degree between node A and node B, with a value ranging from -1 to 1. When the value exceeds a preset threshold of 0.65, a candidate association edge is created between node A and node B. The computational complexity of the approximate inference path is lower than that of the full inference path, and the time taken for a single inference is less than 10 milliseconds.

[0106] Step S505: Generate confidence labels for the inference results. Each newly generated inference edge is accompanied by a confidence label, with a value ranging from 0 to 1, representing the reliability of the inference result.

[0107] For the edges generated by the complete reasoning path, the confidence score is calculated based on three factors: rule matching degree, which is the degree of matching of the triggering rule, ranging from 0 to 1; rule credibility, which is the preset confidence value for each rule in the rule base; and reasoning path depth, which is the number of rule reasoning steps from the original facts to the conclusion. The deeper the steps, the lower the confidence score. The final confidence score is the weighted product of the three factors.

[0108] For edges generated by approximate inference paths, the confidence level is directly taken. The value is [value missing]. When the confidence level is below 0.6, it is marked with a dashed line in the graph display to remind the user that the accuracy of this side may be limited.

[0109] Step S506: Establish a time threshold constraint model and monitor the time consumption of each stage in real time. This model is the core control component for adaptive switching of the inference path. The model monitors the time consumption of each stage of the current graph generation task in real time, specifically including: data preprocessing time, event extraction time, graph update time, and the time used for the complete inference path. The model maintains a time budget pool, recording the total allowed time budget for the current task (default value is 1000 milliseconds) and the consumed time budget. The remaining available time equals the total time budget minus the consumed time.

[0110] Step S507: Execute the adaptive switching logic for the inference path. When the remaining available time monitored in step S506 is less than a preset switching threshold of 500 milliseconds, the time threshold constraint model automatically triggers a path switch, switching from the full inference path to an approximate inference path. The path switching logic consists of three sub-steps: Step S5071: Save the current inference state. Save the intermediate results and partial inference conclusions generated for the complete inference path to the shared memory area, including the matched rule set, the generated intermediate edge list, and the vector cache of the current node.

[0111] Step S5072: Approximate inference engine activated. The approximate inference path from step S504 is initiated, and the graph neural network encoder is used to quickly generate candidate edges and inference conclusions for node pairs that have not yet completed inference.

[0112] Step S5073: Merge the inference results. The conclusions of the complete inference path saved in step S5071 are merged with the approximate inference conclusions generated in step S5072. The merging strategy is as follows: prioritize retaining conclusions with a confidence level higher than 0.7 from the complete inference path, and add conclusions from the approximate inference path as supplementary information; for cases where two inference conclusions exist for the same node pair, retain the one with the higher confidence level.

[0113] Step S508: Dynamically adjust the switching threshold of the time threshold constraint model. The default value of the switching threshold is 500 milliseconds, which can be dynamically adjusted according to the actual application scenario. This method uses a reinforcement learning algorithm to achieve adaptive threshold optimization. The reinforcement learning state includes the current system load, the average inference time of the most recent 100 tasks, and the integrity score fed back by the graph quality assessment module.

[0114] The action can be to increase the threshold, decrease the threshold, or keep the threshold unchanged. The reward function comprehensively considers the task completion rate, average inference latency, and the confidence level of the final graph. Through continuous online learning, the model automatically finds the optimal switching threshold to balance inference accuracy and timeliness.

[0115] Step S509: Perform a graph quality assessment and feed the results back to the scheduler. The quality assessment module evaluates the generated person-event graph from three dimensions: Dimension 1 is completeness, and the calculation formula is: The number of entities covered refers to the number of people, events, and locations successfully extracted and added to the graph. The total number of entities in the original data is calculated from the preprocessing stage in step S1. A higher score indicates more comprehensive information coverage.

[0116] Dimension 2 is consistency, which uses a consistency rule base to detect logical conflicts in the graph. The rule base includes rules for mutual exclusion and time inversion. For each conflict found, the consistency score is reduced by 0.05, with an initial score of 1.0. The lower the score, the fewer the logical conflicts.

[0117] Dimension 3 is freshness, calculated using the following formula: ,in This is the difference between the latest update timestamp and the current timestamp of the map, in seconds. A higher score indicates more timely map information.

[0118] The evaluation results are fed back to the scheduler in step S4 in real time. When the integrity score is below 0.7, the scheduler increases the processing priority of newly arrived data; when the consistency score is below 0.8, the scheduler prioritizes conflict detection and repair tasks; when the freshness score is below 0.5, the scheduler forcibly switches to an approximate inference path to ensure response speed.

[0119] Step S5 constructs a dual-path inference engine, providing two modes: high-precision rule-based inference and high-efficiency vector-based inference. It monitors processing time in real time through a time threshold constraint model and adaptively switches inference paths. At the same time, it introduces confidence labels, dynamic threshold adjustment, and quality assessment feedback mechanisms to meet the stringent timeliness requirements of emergency situation awareness scenarios while ensuring the accuracy of graph inference. This provides complete inference results for the graph output and visualization in step S6.

[0120] Finally, step S6, outputting and visualizing the graph, is carried out according to the following steps.

[0121] Step S601: Format the graph data. Formatting converts the graph's internal storage format into the rendering format required by the visualization engine. Node formatting includes extracting the following information: node identifier, node type, node attributes, node importance weight, and node spatial coordinates. Edge formatting includes extracting the following information: edge identifier, source node identifier, target node identifier, edge type, edge weight, and edge confidence.

[0122] During the formatting process, the layout information of the graph is generated simultaneously. This step uses a force-directed layout algorithm to calculate the position coordinates of each node in two-dimensional or three-dimensional space. The force-directed layout algorithm treats nodes as charged particles, and there are attractive and repulsive forces between nodes. Through iterative calculation, it minimizes the system energy, ultimately achieving a reasonable distribution of nodes and the minimum number of edge intersections.

[0123] Step S602: Visualize the edges based on their confidence level labels. This step determines the confidence level of each edge: when the confidence level is greater than or equal to 0.6, the edge is drawn as a solid line, indicating that the edge is generated based on a relatively reliable reasoning conclusion; when the confidence level is less than 0.6, the edge is drawn as a dashed line, indicating that the edge is generated based on approximate reasoning and has relatively low reliability. The transparency of the dashed edges is dynamically adjusted according to the confidence level value: the lower the confidence level, the higher the transparency, further reminding the user of the differences in edge reliability.

[0124] Step S603: Provide interactive functionality for the graph on the front-end interface. The visual front-end interface supports the following interactive operations: The zoom and pan functions allow users to view the overall structure or local details of the map.

[0125] The node click function displays a detailed information card for the node when the user clicks on it. The card includes all the node's attributes and the edge information associated with that node.

[0126] The edge hover feature displays a detailed description and confidence information of the edge when the user hovers the mouse over it.

[0127] The filtering function allows users to filter the displayed graph content based on conditions such as node type, edge type, and confidence threshold.

[0128] The search function allows users to quickly locate target nodes using keywords such as node name or attribute value.

[0129] The legend feature displays the visual encoding rules for various nodes and edges, helping users understand the semantic information of the graph.

[0130] Step S604: Establish a map push mechanism. This push mechanism adopts a hybrid mode combining real-time push and active retrieval.

[0131] The real-time push mode is implemented based on WebSocket long connection: when the graph is updated, the server actively pushes the updated content to the client to realize the real-time refresh of the graph.

[0132] The proactive pull mode is implemented based on HTTP polling: the client periodically requests updated graph content from the server. This mode is suitable for scenarios where WebSocket connections are unstable or the server is under heavy load.

[0133] In hybrid mode, this step automatically selects the appropriate push mode based on network conditions and load. The selection logic is as follows: it prioritizes attempting to establish a WebSocket connection; if the connection is successful, it uses the real-time push mode; if the connection fails or excessive network latency is detected, it automatically switches to the active pull mode.

[0134] Step S605: Push the formatted map data to the front-end interface. The pushed data includes: a list of nodes and their spatial coordinates and style attributes, a list of edges and their connection relationships and line styles, and legend information. The pushing process uses an incremental update method, that is, only the parts that have changed since the last push are pushed, rather than pushing the entire map each time, in order to reduce the amount of data transmission.

[0135] Step S606: Render the graph on the front-end interface and respond to user interactions. After receiving the pushed data, the front-end rendering engine draws nodes and edges on the canvas according to the layout coordinates generated in step S601 and the edge styles determined in step S602. Simultaneously, the front-end engine listens for various interactive events defined in step S603 and executes corresponding response logic when an event is triggered, such as displaying detailed information cards, filtering nodes, and highlighting search results.

[0136] Step S607: Maintain consistency between the front-end graph state and the back-end data. The front-end interface periodically sends heartbeat requests to the back-end, carrying the current graph version number. The back-end compares the version numbers; if it finds that the front-end version is behind the latest version, it pushes the difference update data. After receiving the difference data, the front-end only updates the changed parts, maintaining the real-time nature of the graph while avoiding re-rendering the entire graph.

[0137] In summary, step S6 converts the internal graph data into a visual rendering format through formatting, generates a reasonable node spatial distribution using a force-directed layout algorithm, distinguishes the reliability of edges using solid or dashed lines based on confidence labels, and presents the generated character and event graph to the user intuitively with the help of a hybrid push mechanism and rich interactive functions. This allows the user to efficiently explore the graph structure, understand the event context, and complete the output stage of the entire rapid generation method.

[0138] To facilitate understanding, the workflow and operational details of the method of the present invention will be explained in detail below through a specific application scenario.

[0139] Suppose that the method in this embodiment receives news report data about a sudden public safety incident. The text content is: A gas leak and explosion occurred in a certain district of a certain city, resulting in 3 deaths and multiple injuries. After the incident, the local government immediately activated the emergency response plan, and the fire department quickly rushed to the scene to handle the situation. This data enters the system through the streaming data receiving module in step S1. After format parsing, fields such as text content, timestamp, and source identifier are extracted. The data quality assessment module checks indicators such as text integrity and named entity integrity. After confirming that the data passes the quality verification, it enters the message queue buffer.

[0140] Step S2 involves the distillation of the BERT entity recognition model to extract entities from the input text. The word segmentation module divides the text into token sequences such as: city, district, occurrence, together, gas, leak, explosion, accident, cause, 3, name, death, multiple people, injured, incident, after, local government, immediately, activate, emergency plan, fire department, quickly, rush to, scene, proceed, and handle. The entities output by the entity recognition model include organizational entities such as local government and fire department, geographical entities such as city and district, time-related entities such as after the incident, and event action entities such as gas leak and explosion accident, emergency plan activation, and on-site handling. End-to-end processing takes approximately 150 milliseconds, meeting the 200 millisecond timeliness requirement.

[0141] Step S3, the incremental graph update module, adds the extracted event elements to the graph. First, it adds event nodes and entity nodes such as the gas leak and explosion accident node, a city / district node, a local government node, and a fire department node to the newly created node set. The graph change propagation algorithm calculates the semantic correlation between the new nodes and existing nodes. The semantic correlation between the gas leak and explosion accident node and the on-site response node is 0.85, exceeding the threshold of 0.7; therefore, a causal relationship edge is created between the two nodes. The adjacency list and inverted index only update the index structure of the corresponding shards, with the update operation taking approximately 50 milliseconds.

[0142] Step S4, the event evolution stage identification model, determines the stage of the event. Based on the event's time-series and content characteristics, the model judges the event to be in its outbreak phase because it has just occurred, its spread is accelerating, and public attention is increasing. According to step S404, the basic priority weight for events in the outbreak phase is 1.0. Since the event involves important organizations such as local government and fire departments, the scheduler confirms that the event is handled with the highest priority of 1.0, ensuring it immediately enters the processing queue and receives priority processing resources.

[0143] Step S5's dual-path inference engine performs correlation inference on the event. Since there is ample processing time, the time threshold constraint model determines that the complete inference path can continue to be used. The complete inference path applies event causal inference rules to deduce the causal relationship between the gas leak explosion accident and casualties, as well as the temporal constraint relationship between the activation of the emergency plan and on-site response. The confidence levels of the inference conclusions are 0.92 and 0.95, respectively, both higher than the threshold of 0.6, and are therefore displayed as solid lines in the graph. The approximate inference path was not triggered in the current scenario.

[0144] In step S6, the graph output module pushes the updated graph data to the front-end interface. The visualization engine calculates the display coordinates of each node based on the force-directed layout algorithm. The gas leak and explosion accident node is located at the center of the graph, while derivative event nodes such as casualties and emergency response activation are distributed around the central node. Entity nodes such as local government and fire departments are connected to the event nodes through edges. Users can view the overall structure of the graph on the front-end interface, click on nodes to view detailed information, and perform zoom and pan operations on the graph.

[0145] It will be apparent to those skilled in the art that the present invention is not limited to the details of the exemplary embodiments described above, and that the present invention can be implemented in other specific forms without departing from the spirit or essential characteristics of the present invention. Therefore, the embodiments should be regarded as exemplary and non-limiting in all respects.

[0146] Furthermore, it should be understood that although this specification describes embodiments, not every embodiment contains only one independent technical solution. This narrative style is merely for clarity. Those skilled in the art should consider the specification as a whole, and the technical solutions in each embodiment can also be appropriately combined to form other embodiments that can be understood by those skilled in the art.

Claims

1. A method for rapidly generating multi-source heterogeneous person and event maps for emergency situation awareness, characterized in that, Includes the following steps: Step S1: Based on the event-driven architecture, real-time access to multi-source heterogeneous data streams is performed, and standardized data units are output from the received data. Step S2: The Distilled BERT lightweight entity recognition model is used to perform fast reasoning on the standardized data units, and the event element objects containing person entities, event entities and their relationships are extracted through pipelined parallel processing. Step S3: Maintain the character event graph based on the hybrid storage structure, execute the graph change propagation algorithm, and perform incremental updates at the node and edge granularity; Step S4: Input the extracted events into the event evolution stage identification model to determine the evolution stage, configure priority weights according to the determination results, and send them into the priority queue for scheduling and management. Step S5: Construct a dual-path inference engine that includes a complete inference path and an approximate inference path. Monitor processing time through a time threshold constraint model and adaptively switch inference paths. Step S6: Format the updated character event graph data and push it to the front-end interface for rendering and display.

2. The method for rapid generation of multi-source heterogeneous person and event maps for emergency situation awareness according to claim 1, characterized in that, The standardization process in step S1 includes: The corresponding parser component is invoked to perform semantic parsing, extracting the original text content, timestamp information, data source identifier, and original data structure fields; Perform a unified character encoding conversion to UTF-8 encoding; Perform text normalization operations, including unifying capitalization, converting full-width and half-width characters, filtering special characters, and standardizing whitespace characters; The execution date and time format is standardized to Unix timestamps and ISO 8601 standard time strings; The data field mapping module maps the fields of the original data to standardized fields. The message queue buffer mechanism enables asynchronous decoupling of data and traffic shaping. The message queue buffer adopts a producer-consumer pattern, and the buffer capacity of the message queue buffer is dynamically adjusted according to the load.

3. The method for rapid generation of multi-source heterogeneous person-event maps for emergency situation awareness according to claim 1, characterized in that, The distilled BERT lightweight entity recognition model in step S2 is constructed in the following way: A standard 12-layer BERT model was selected as the teacher model, and a 6-layer Transformer structure student model was designed. The student model is the distilled BERT lightweight entity recognition model, and the number of parameters in the student model is 40% of the number of parameters in the teacher model. Through knowledge distillation training, a joint loss function is defined. And minimize the joint loss function, where Represents the joint loss value. This represents the hard-label cross-entropy loss calculated based on manually labeled data. This represents the distillation loss calculated based on the KL divergence between the soft-label probability distribution output by the teacher model and the probability distribution output by the student model. This is a weighting coefficient, and the value of the weighting coefficient is 0.7; The fast inference uses dynamic quantization technology to reduce the precision of model weights from 32-bit floating point to 16-bit floating point or 8-bit integer representation. The pipeline parallel processing is a four-stage pipeline consisting of a data preprocessing stage, an entity recognition stage, a relation extraction stage, and an event element assembly stage. Each stage has an independent message queue buffer. When the Nth data is being processed in the i-th stage, the (N-1)th data is simultaneously being processed in the i+1-th stage, forming an instruction-level pipeline parallelism.

4. The method for rapid generation of multi-source heterogeneous person-event maps for emergency situation awareness according to claim 1, characterized in that, The hybrid storage structure in step S3 is a hybrid storage structure of adjacency list and inverted index: A sharded storage strategy is adopted, and the entire graph is divided into multiple graph shards based on the consistent hashing algorithm. Each graph shard is stored on an independent storage node. Each record in the adjacency list contains source node identifier, target node identifier, edge attribute information, and edge weight information, and bidirectional association between nodes is achieved through a doubly linked list; The inverted index uses the attribute name and attribute value as the index key and the list of all node identifiers containing the attribute value as the index value. The graph change propagation algorithm uses a two-level index structure of global view index and fragmented local index to locate candidate influencing nodes and calculates the semantic association between the new node and each candidate influencing node. ,in This represents the cosine similarity between the newly added node A and the existing node B. This represents the semantic vector of the newly added node A. This represents the semantic vector of an existing node B. Semantic vectors The length of the mold, Semantic vectors The length of the mold, Semantic vectors With semantic vectors The dot product is used to create new edges between nodes only when the semantic relevance exceeds a preset threshold of 0.

7.

5. The method for rapid generation of multi-source heterogeneous person and event maps for emergency situation awareness according to claim 1, characterized in that, The event evolution stage identification model in step S4 is constructed based on a gated recurrent unit: The input layer of the event evolution stage identification model receives an event feature sequence with a fixed time window length. The event feature sequence includes the event occurrence timestamp, duration, rate of change of news quantity per unit time, time series features of change of sentiment intensity score, as well as the word vector representation of the event summary text, the number of people involved, the number of organizations involved, and the content features of event type encoding. The gated recurrent unit layer outputs the hidden state of the last time step as the event's temporal encoding vector. The temporal encoding vector is then connected to a fully connected classification layer, which outputs the probability distribution of the event belonging to the latency period, burst period, duration period, and decay period through the softmax activation function. The priority weights are configured according to the judgment results as follows: the weight of character events during the outbreak period is set to 1.0, the weight of character events during the duration period is set to 0.7, the weight of events during the incubation period is set to 0.4, and the weight of events during the decline period is set to 0.

2. The priority queue is implemented based on a max-heap, where the top element of the max-heap is the event with the highest current priority weight.

6. The method for rapid generation of multi-source heterogeneous person-event maps for emergency situation awareness according to claim 5, characterized in that, Step S4 also includes key personnel identification and priority enhancement steps: Maintain a preset character database, which records the entity identifiers, attribute information, and attention level labels of characters that require special attention; When the current event is detected to involve a key figure in the preset figure database, the priority weight of the event is automatically and forcibly increased to 1.0, overriding the original weight determined according to the evolution stage; The key person matching uses two modes: exact matching and fuzzy matching. The fuzzy matching uses an edit distance algorithm to identify person names with minor character differences.

7. The method for rapid generation of multi-source heterogeneous person and event maps for emergency situation awareness according to claim 1, characterized in that, The complete reasoning path in step S5 is based on a preset knowledge reasoning rule base for precise reasoning: The knowledge reasoning rule base includes rules for reasoning about relationships between people, rules for reasoning about causal events, and rules for reasoning based on temporal constraints. The execution process of the complete reasoning path is divided into a rule matching stage, a rule application stage, and a result verification stage. The result verification stage performs consistency verification on the newly generated reasoning conclusions. The approximate inference path utilizes a pre-trained graph neural network encoder to obtain node vector representations, and calculates cosine similarity. Generate candidate associated edges, where This represents the graph neural network correlation degree between node A and node B. This represents the graph neural network encoding vector of node A. This represents the graph neural network encoding vector of node B. Representing vectors The length of the mold, Representing vectors The length of the mold, Representing vectors with vector The dot product of the cosine similarity is used to create candidate associated edges when the cosine similarity exceeds a preset threshold of 0.

65. The dual-path inference engine generates confidence labels for the inference results. For edges generated by a complete inference path, the confidence is calculated based on a combination of rule matching degree, rule credibility, and inference path depth. For edges generated by an approximate inference path, the confidence is directly taken as the value of the cosine similarity.

8. The method for rapid generation of multi-source heterogeneous person and event maps for emergency situation awareness according to claim 1, characterized in that, In step S5, the time threshold constraint model maintains a time budget pool in real time. The time budget pool is used to record the total time budget allowed for the current task and the time budget already consumed. The remaining available time is equal to the total time budget minus the consumed time. When the remaining available time is less than 500 milliseconds of the preset switching threshold, it will automatically switch from the full inference path to the approximate inference path; The switching threshold is dynamically adjusted through a reinforcement learning algorithm. The state of reinforcement learning includes the current system load, the average inference time of the last 100 tasks, and the integrity score fed back by the graph quality assessment module. The actions of reinforcement learning are to increase the threshold, decrease the threshold, or keep the threshold unchanged. The reward function of reinforcement learning comprehensively considers the task completion rate, average inference latency, and final graph confidence, and automatically finds the optimal switching threshold through continuous online learning.

9. The method for rapid generation of multi-source heterogeneous person and event maps for emergency situation awareness according to claim 1, characterized in that, The step S6 is preceded by a spectrum quality assessment step: The quality assessment of the generated person-event map evaluates it from three dimensions: completeness, consistency, and freshness. The integrity score is calculated as follows: the integrity score equals the number of covered entities divided by the total number of entities in the original data. The consistency is achieved by detecting logical conflicts in the graph using a consistency rule base, with 0.05 points deducted for each conflict found. The formula for calculating freshness is: Freshness Score = ,in This is the difference between the latest update timestamp of the graph and the current timestamp; The evaluation results are fed back to the scheduler in step S4 in real time. When the integrity score is lower than 0.7, the scheduler increases the processing priority of newly arrived data. When the consistency score is lower than 0.8, the scheduler prioritizes conflict detection and repair tasks. When the freshness score is lower than 0.5, the scheduler forces a switch to the approximate inference path.

10. The method for rapid generation of multi-source heterogeneous person-event maps for sudden situational awareness as described in claim 1, characterized in that, The formatting process in step S6 includes extracting node identifiers, node types, node attributes, node importance weights, node spatial coordinates, as well as edge identifiers, source node identifiers, target node identifiers, edge types, edge weights, and edge confidence. The force-directed layout algorithm is then used to calculate the spatial coordinates of each node. The visualization style is determined based on the confidence label of the edges generated by inference. When the confidence is greater than or equal to 0.6, it is drawn as a solid line, and when the confidence is less than 0.6, it is drawn as a dashed line. The transparency of the dashed line edges is dynamically adjusted according to the confidence value. The push to the front-end interface adopts a hybrid mode that combines real-time push and active retrieval. The real-time push mode is implemented based on WebSocket long connection, and the active retrieval mode is implemented based on HTTP polling.

Images