Large-scale knowledge graph construction system based on graph neural network

Abstract

The invention relates to the technical field of data processing, in particular to a graph neural network-based large-scale knowledge graph construction system, which comprises a node increment receiver, a historical embedded memory, a dynamic neighbor sampler, a local sub-graph generator, a quantum state aggregator, a spatio-temporal topology checker, an embedded propagation controller and a graph updater. A time sequence control closed loop adopts a time window to process new nodes in batches, a historical embedding memory aligns version snapshots and multiplexes historical embedding, and a dynamic neighbor sampler optimizes sampling resources according to time sequence density; a precision adjustment closed loop triggers relation weight correction and quantum line parameter updating, and an embedded propagation controller freezes an inactive node gradient to focus key changes; resource optimization chain adjustment reduces neighborhood complexity, time attenuation coefficient compresses adjacency matrix scale, and historical embedded memory pointer call eliminates vector replication overhead. According to the method, computing resource consumption in the dynamic updating process is remarkably reduced, and knowledge graph representation quality is maintained.

Description

Technical Field

[0001] The present invention relates to the field of data processing technology, and in particular to a large-scale knowledge graph construction system based on graph neural networks. Background Art

[0002] Large-scale knowledge graphs model complex entities and relationships as heterogeneous graph structures; when the graph scale is large, the increased complexity of relationships leads to limitations in reasoning efficiency and information integration of traditional methods; graph neural networks introduce a message passing framework to solve the challenge, iteratively aggregates neighborhood features through nodes and updates low-dimensional embedding representations; this embedding captures graph topology patterns and supports tasks such as link prediction or entity classification; when applied to information retrieval or recommendation systems, graph neural networks directly process large-scale data, improve the accuracy of knowledge reasoning and optimize computing resource consumption to meet the performance requirements of modern digital systems.

[0003] In the process of constructing large-scale knowledge graphs, graph neural networks face the pain point of high computational complexity in efficiently processing heterogeneous relationships. The reason is that the graph is huge in scale and the relationships are rich in diversity. When nodes iteratively aggregate neighborhood features, the message passing mechanism causes the computational overhead to grow exponentially, and memory usage increases significantly. For example, when the information retrieval system is running, to integrate new entities such as e-commerce product attributes, the existing technology deployment requires retraining the embedding representation of the entire graph, resulting in increased system latency and decreased resource utilization, affecting user experience and platform performance. Summary of the Invention

[0004] In response to the shortcomings of the existing technology, the present invention provides a large-scale knowledge graph construction system based on graph neural network to solve the technical problem of excessive consumption of computing resources when graph neural network processes large-scale knowledge graphs to dynamically update new node embeddings.

[0005] In order to solve the above technical problems, the specific technical solutions of the present invention are as follows: The present invention provides a large-scale knowledge graph construction system based on graph neural network, including: Node increment receiver, which receives external real-time entity attribute stream data, parses entity type identifiers and relationship attribute sets, aggregates and generates batched new node sets according to fixed time windows, outputs the new node sets to the dynamic neighbor sampler, and sends the window boundary time identifier to the historical embedding memory; The historical embedding memory stores the full node embedding vector and its time version snapshot, responds to the neighbor node query request of the dynamic neighbor sampler and returns the feature vector pointer, receives the incremental embedding update package of the graph updater to cover the historical snapshot, calculates the Euclidean distance difference between the new and old versions of the embedding vector as the node version difference value, and outputs it to the embedding propagation controller; The dynamic neighbor sampler generates a sampling priority sequence based on the timestamp density of new nodes, receives weight correction instructions from the spatiotemporal topology verifier to update the relationship type weight matrix, dynamically adjusts the sampling depth based on memory usage, and outputs the neighbor node set and relationship weight matrix to the local subgraph generator; The local subgraph generator integrates the new node set and the neighbor node set to construct a vertex set, requests the neighbor node feature vector pointer from the historical embedding memory, calculates the relationship time decay coefficient by adding an exponential decay function based on the time difference, generates a weighted adjacency relationship matrix, and outputs the isolated subgraph structure to the quantum state aggregator; The quantum state aggregator maps the neighbor node feature vector components to quantum state amplitude values, loads the parameterized quantum circuit structure of the space-time topology verifier, performs quantum state entanglement operations to fuse the features, and then outputs the node embedded in the space-time topology verifier; The spatiotemporal topology verifier parses the isolated subgraph structure to generate an adjacency tensor representation, calculates the difference between the adjacency tensor and the feature distribution of the quantum node embedding, and sends a weight correction instruction to the dynamic neighbor sampler and a parameter update instruction to the quantum state aggregator when the difference exceeds the threshold. The verified node vector is output to the embedding propagation controller; The embedding propagation controller filters out nodes whose vector change in the adjacent tensor exceeds the threshold to form an activation set, loads the node version difference value output by the historical embedding memory, freezes the gradient calculation of inactive nodes and dynamically sets the gradient clipping threshold, and outputs the propagated embedding vector to the spatiotemporal topology verifier for secondary verification; The graph updater receives the embedded vector set that has passed the secondary verification of the spatiotemporal topology verifier, writes the newly added node vector directly into the storage, generates the incremental update package of the old node and the global consistency log and sends them to the historical embedding storage to complete the dynamic expansion.

[0006] Furthermore, in the large-scale knowledge graph construction system based on graph neural network described in the present invention, the dynamic neighbor sampler includes: The timing control module counts the distribution density of timestamps generated by new nodes and generates a sequence that prioritizes sampling in high-density areas; The accuracy feedback module receives and parses the weight correction instructions sent by the spatiotemporal topology verifier, and updates the weight parameters of the corresponding categories in the relationship type weight matrix in the dynamic neighbor sampler; The resource monitoring module obtains the system memory usage in real time, reduces the preset sampling depth level when the usage exceeds the set threshold, and restores the original level when the usage drops.

[0007] Furthermore, in the large-scale knowledge graph construction system based on graph neural network of the present invention, the resource monitoring module is configured as follows: Periodically monitor the memory usage change curve; When the memory usage exceeds the first critical value for two consecutive monitoring cycles, the neighbor sampling depth is reduced from the default level 3 to level 2; When the memory usage drops below the second critical value for three consecutive monitoring cycles, the sampling depth is restored to level three; When the memory warning of the resource monitoring module is still triggered after the sampling depth is adjusted, the spare buffer area is started to allocate the process to the local sub-graph generator.

[0008] Furthermore, in the large-scale knowledge graph construction system based on graph neural network described in the present invention, the time decay coefficient calculation in the local subgraph generator is: Get the latest interaction timestamp of the node corresponding to the relationship from the historical embedding memory; Calculate the time difference between the timestamp and the current system time; The time difference is mapped to the attenuation coefficient in the (0,1) interval through the negative exponential function; The adjacency matrix weight value is generated by multiplying the decay coefficient with the original relationship type weight in the relationship weight matrix output by the dynamic neighbor sampler.

[0009] Furthermore, in the large-scale knowledge graph construction system based on graph neural network described in the present invention, the quantum state aggregator is configured as follows: An amplitude compression unit normalizes the feature vector components returned by the history embedding memory and limits the upper limit of the absolute value of the amplitude; The quantum circuit loading module loads the parameterized quantum circuit structure of the space-time topology verifier and initializes the quantum bit entanglement path; Feature fusion unit, which aggregates the amplitude values ​​of neighboring nodes through controlled quantum gate operations; The classical space converter inversely encodes the quantum state measurement results and outputs them to the node embedding vector of the space-time topology verifier.

[0010] Furthermore, in the large-scale knowledge graph construction system based on graph neural network described in the present invention, the feature distribution difference value calculation in the spatiotemporal topology verifier is: Adjacency tensor analyzer, which extracts the topological features of the isolated subgraph structure output by the quantum state aggregator to construct a multinomial distribution model; Quantum feature analyzer, which converts the node embedding vector output by the quantum state aggregator into a Gaussian mixture distribution model; KL divergence calculation module, which measures the difference between the aforementioned multinomial distribution model and the Gaussian mixture distribution model; Correction trigger, when the KL divergence value exceeds the preset tolerance threshold, sends a weight correction instruction to the dynamic neighbor sampler and a parameter update instruction to the quantum state aggregator.

[0011] Furthermore, in the large-scale knowledge graph construction system based on graph neural network of the present invention, the embedded propagation controller includes: The change detection unit obtains the previous version vector of the node from the historical embedding memory and compares it with the node's current adjacent vector; the similarity calculation module uses the cosine similarity algorithm to measure the degree of difference between the two vectors; an activation determiner, which adds a node to an activation set when the change value output by the similarity calculation module exceeds a set threshold; The gradient clipping module linearly adjusts the gradient threshold according to the node version difference value output by the historical embedding memory.

[0012] Furthermore, in the large-scale knowledge graph construction system based on graph neural network described in the present invention, the gradient clipping module dynamically adjusts the rules: The embedding propagation controller establishes a mapping table of the positive proportional relationship between the node version difference value output by the historical embedding memory and the clipping threshold; When the difference between the current version and the previous cycle increases by more than 10%, the gradient clipping threshold is increased by 20% to 50%; When the gradient values ​​of two consecutive propagation processes do not exceed the current gradient clipping threshold, the clipping threshold is lowered by 10% to 15%.

[0013] Furthermore, in the large-scale knowledge graph construction system based on graph neural network described in the present invention, the graph updater includes: The incremental analysis unit compares the new embedding vector in the embedding vector set that has passed the secondary verification with the old embedding vector of the old node stored in the historical embedding memory, and calculates the coordinate offset; The transaction encapsulation module encapsulates the newly added node vector and the old node coordinate offset into an atomic transaction package; Log generator, which records the timestamp of each vector change event and the version dependency chain between nodes; The consistency write module synchronously sends the transaction package and log to the historical embedded storage through atomic write operations.

[0014] Furthermore, the large-scale knowledge graph construction system based on graph neural network described in the present invention also includes: Timing control closed-loop module: The node increment receiver sends the window boundary time identifier to the historical embedding memory. The historical embedding memory aligns the version snapshot according to the time identifier. The dynamic neighbor sampler samples according to the time sequence density based on the new node timestamp density. The graph updater generates a version log to update the historical snapshot and trigger the historical embedding memory snapshot to overwrite. Precision adjustment closed-loop module: The spatiotemporal topology verifier detects feature distribution difference values, the dynamic neighbor sampler responds to weight correction instructions to correct relationship weights, the quantum state aggregator responds to parameter update instructions to update line parameters, and the spatiotemporal topology verifier secondary verifies the correction effect of the embedded vector after propagation; Resource optimization chain module: The dynamic neighbor sampler dynamically adjusts the sampling depth based on the output of the resource monitoring module. The local subgraph generator simplifies the size of the adjacency matrix by calculating the time decay coefficient. The historical embedding memory reduces memory copy overhead by pointer calls when querying neighbor nodes.

[0015] Beneficial effects of the present invention: The present invention significantly reduces resource consumption and maintains the quality of knowledge graph representation through a triple collaboration mechanism. The timing control closed loop uses a fixed time window to batch process new nodes, eliminating the fragmented computing load generated by streaming updates; the version snapshot reuse mechanism of the historical embedded memory avoids recalculation of all nodes; the dynamic neighbor sampler allocates sampling resources based on the timestamp density, reducing the computing overhead of low-value areas. The precision adjustment closed loop realizes directional optimization through feature distribution difference value detection, and the spatiotemporal topology verifier triggers the modification of the relationship weight matrix and the update of quantum circuit parameters to suppress invalid computing cycles; the embedded propagation controller freezes the gradient calculation of inactive nodes and focuses on computing resources in key change areas. The resource optimization chain implements a multi-dimensional compression strategy, and the dynamic sampling depth adjustment controls the complexity of the neighborhood search; the time decay coefficient compresses the effective element scale of the adjacency matrix; the pointer call mechanism of the historical embedded memory eliminates the vector copy overhead, forming a computing-storage joint decompression path. The present invention balances computing accuracy and resource efficiency through a modular collaborative architecture to support the real-time dynamic expansion of large-scale knowledge graphs. BRIEF DESCRIPTION OF THE DRAWINGS

[0016] In order to more clearly illustrate the technical solution of the present invention, the following is a brief introduction to the drawings required for use in the embodiments. Obviously, for ordinary technicians in this field, other drawings can be obtained based on the drawings without paying any creative labor.

[0017] Figure 1 A system architecture diagram of a large-scale knowledge graph construction system based on graph neural networks provided in an embodiment of the present invention. DETAILED DESCRIPTION

[0018] In order to make the purpose, technical solutions and advantages of the present invention clearer, the technical solutions of the present invention will be clearly and completely described below in conjunction with the specific embodiments of the present invention and the corresponding drawings. Obviously, the embodiments described are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative work are within the scope of protection of the present invention. The technical solutions provided by each embodiment of the present invention are described in detail below in conjunction with the drawings. In order to better understand the purpose of the present invention, the present invention is further described in detail below.

[0019] See also Figure 1 The present invention provides a large-scale knowledge graph construction system based on graph neural network, including: Node increment receiver, which receives external real-time entity attribute stream data, parses entity type identifiers and relationship attribute sets, aggregates and generates batched new node sets according to fixed time windows, outputs the new node sets to the dynamic neighbor sampler, and sends the window boundary time identifier to the historical embedding memory; The historical embedding memory stores the full node embedding vector and its time version snapshot, responds to the neighbor node query request of the dynamic neighbor sampler and returns the feature vector pointer, receives the incremental embedding update package of the graph updater to cover the historical snapshot, calculates the Euclidean distance difference between the new and old versions of the embedding vector as the node version difference value, and outputs it to the embedding propagation controller; The dynamic neighbor sampler generates a sampling priority sequence based on the timestamp density of new nodes, receives weight correction instructions from the spatiotemporal topology verifier to update the relationship type weight matrix, dynamically adjusts the sampling depth based on memory usage, and outputs the neighbor node set and relationship weight matrix to the local subgraph generator; The local subgraph generator integrates the new node set and the neighbor node set to construct a vertex set, requests the neighbor node feature vector pointer from the historical embedding memory, calculates the relationship time decay coefficient by adding an exponential decay function based on the time difference, generates a weighted adjacency relationship matrix, and outputs the isolated subgraph structure to the quantum state aggregator; The quantum state aggregator maps the neighbor node feature vector components to quantum state amplitude values, loads the parameterized quantum circuit structure of the space-time topology verifier, performs quantum state entanglement operations to fuse the features, and then outputs the node embedded in the space-time topology verifier; The spatiotemporal topology verifier parses the isolated subgraph structure to generate an adjacency tensor representation, calculates the difference between the adjacency tensor and the feature distribution of the quantum node embedding, and sends a weight correction instruction to the dynamic neighbor sampler and a parameter update instruction to the quantum state aggregator when the difference exceeds the threshold. The verified node vector is output to the embedding propagation controller; The embedding propagation controller filters out nodes whose vector change in the adjacent tensor exceeds the threshold to form an activation set, loads the node version difference value output by the historical embedding memory, freezes the gradient calculation of inactive nodes and dynamically sets the gradient clipping threshold, and outputs the propagated embedding vector to the spatiotemporal topology verifier for secondary verification; The graph updater receives the embedded vector set that has passed the secondary verification of the spatiotemporal topology verifier, writes the newly added node vector directly into the storage, generates the incremental update package of the old node and the global consistency log and sends them to the historical embedding storage to complete the dynamic expansion.

[0020] The node increment receiver processes real-time entity attribute streams from external input. This component first parses the entity type identifiers and relationship attribute sets in the data stream to identify entity categories and relationship characteristics. It then aggregates the data in batches using a fixed time window mechanism to form a new structured node set. This new node set is then output to the dynamic neighbor sampler for further processing. The window boundary time identifiers are also sent to the historical embedding memory to provide a reference for time version alignment.

[0021] The historical embedding memory maintains the full set of node embedding vectors and their historical version snapshots. When the dynamic neighbor sampler initiates a neighbor node query request, it returns a feature vector pointer rather than a full data copy, reducing memory transfer overhead. Upon receiving the incremental embedding update package generated by the graph updater, it overwrites the stored historical snapshot and retains the version track. The Euclidean distance difference between the new and old embedding vectors is calculated and quantized into node version differences, which are then output to the embedding propagation controller to provide a quantitative basis for gradient control.

[0022] The dynamic neighbor sampler generates a sampling priority sequence based on the density of new node timestamps, assigning higher sampling weights to time-dense areas. It receives weight correction instructions from the spatiotemporal topology verifier and updates the category weight parameters in the relationship type weight matrix. It monitors system memory usage in real time and dynamically adjusts the sampling depth. When memory usage exceeds a threshold, it reduces the sampling level to reduce computational load. It then outputs the neighbor node set and relationship weight matrix to the local subgraph generator, forming the foundation of the topological structure.

[0023] The local subgraph generator integrates the new node set with the sampled neighbor nodes to construct a vertex set. It then requests neighbor node feature vector pointers from the historical embedding memory to obtain feature data. An exponential decay function based on time differences is applied to calculate the relationship time decay coefficient to reflect the impact of timeliness. The time decay coefficient is multiplied by the relationship type weight matrix to generate a weighted adjacency relationship matrix. The isolated subgraph structure is then output to the quantum state aggregator for feature fusion.

[0024] The quantum state aggregator maps neighbor node feature vector components to quantum state amplitude values. It then loads the parameterized quantum circuit structure configured by the space-time topology verifier and initializes the qubit entanglement path. Quantum state entanglement is performed through controlled quantum gate operations, fusing neighbor node feature information. The quantum state measurement results are inversely encoded in classical space, and the output node embedding vector is fed into the space-time topology verifier for topology verification.

[0025] The spatiotemporal topology verifier analyzes the isolated subgraph structure input by the quantum state aggregator and generates an adjacency tensor representation. It calculates the difference in feature distribution between the adjacency tensor and the quantum node embedding vector to quantify the degree of topological consistency. When the difference exceeds a tolerance threshold, it sends a weight correction instruction to the dynamic neighbor sampler to adjust the sampling strategy and a parameter update instruction to the quantum state aggregator to optimize feature fusion. The verified node vector is output to the embedding propagation controller for selective update.

[0026] The embedding propagation controller selects nodes whose vector change in the adjacent tensor exceeds a threshold to form an active set. It loads node version differences from the historical embedding memory as a reference for adjustment. It freezes gradient calculations on inactive nodes to prevent invalid operations and dynamically sets a gradient clipping threshold based on the version difference to control the update amplitude. The propagated embedding vector is then output to the spatiotemporal topology verifier for secondary verification to ensure update quality.

[0027] The graph updater receives the set of embedding vectors that have passed secondary verification and performs storage updates. New node vectors are directly written to the historical embedding memory for expansion. The new and old embedding vectors of existing nodes are compared to calculate coordinate offsets, generating incremental update packages for the old nodes. The vector change timestamps and version dependency chains are recorded to form a globally consistent log. Atomic write operations are used to synchronize transaction packages and logs to the historical embedding memory, completing the dynamic expansion and version management of the knowledge graph.

[0028] Specifically, in the large-scale knowledge graph construction system based on graph neural network described in the present invention, the dynamic neighbor sampler includes: The timing control module counts the distribution density of timestamps generated by new nodes and generates a sequence that prioritizes sampling in high-density areas; The accuracy feedback module receives and parses the weight correction instructions sent by the spatiotemporal topology verifier, and updates the weight parameters of the corresponding categories in the relationship type weight matrix in the dynamic neighbor sampler; The resource monitoring module obtains the system memory usage in real time, reduces the preset sampling depth level when the usage exceeds the set threshold, and restores the original level when the usage drops.

[0029] The timing control module performs statistical analysis of the timestamp distribution density of new nodes. This module divides fixed time intervals into statistically significant node generation frequencies, identifying high-density clusters along the temporal dimension. When generating a sampling priority sequence, it assigns higher sampling weights to high-density regions, focusing subsequent neighbor sampling operations on topological regions with greater timeliness. This mechanism optimizes sampling resource allocation and enhances the timeliness of dynamic graph representations.

[0030] The accuracy feedback module processes weight adjustment commands sent by the spatiotemporal topology verifier. It parses the relationship type identifier and weight adjustment parameter contained in the command to locate the corresponding entry in the relationship type weight matrix within the dynamic neighbor sampler. Based on the adjustment, the weight parameter for the specific relationship type in the matrix is ​​updated, adjusting the influence weights of different relationship types in the neighbor sampling process. This closed-loop control enables real-time optimization of the sampling strategy.

[0031] The resource monitoring module establishes a real-time monitoring mechanism for system memory usage. It periodically obtains memory usage data through the operating system interface and dynamically compares it with pre-set safety thresholds. If the monitored usage continuously exceeds the threshold, it triggers sampling depth reduction control, reducing the topological depth of neighbor sampling to control memory consumption. Once memory usage falls back to a safe range, the original sampling depth is restored to maintain computational accuracy. This module achieves a dynamic balance between computing resources and model accuracy.

[0032] Three modules form a cascaded control logic: the timing control module prioritizes the spatial and temporal sampling ranges, the accuracy feedback module optimizes relationship weight parameters based on topology verification results, and the resource monitoring module ensures that the computation process operates within controllable resource boundaries. These modules collaborate through data and instruction flows, supporting the adaptive operation mechanism of the dynamic neighbor sampler.

[0033] Specifically, in the large-scale knowledge graph construction system based on graph neural network described in the present invention, the resource monitoring module is configured as follows: Periodically monitor the memory usage change curve; When the memory usage exceeds the first critical value for two consecutive monitoring cycles, the neighbor sampling depth is reduced from the default level 3 to level 2; When the memory usage drops below the second critical value for three consecutive monitoring cycles, the sampling depth is restored to level three; When the memory warning of the resource monitoring module is still triggered after the sampling depth is adjusted, the spare buffer area is started to allocate the process to the local sub-graph generator.

[0034] The resource monitoring module establishes a periodic memory usage monitoring mechanism. It regularly collects memory usage data through a system-level interface and records usage changes to form a time series. This monitoring frequency is synchronized with the knowledge graph processing window, providing a data foundation for dynamic resource regulation.

[0035] If the memory usage exceeds the first critical value for two consecutive monitoring periods, the sampling depth reduction strategy is triggered. The neighbor sampling depth is reduced from the default three levels to two, reducing the recursive sampling range of neighbor nodes. This operation reduces the computational complexity of the local subgraph construction process and keeps memory usage within a safe threshold.

[0036] When the memory usage drops below the second critical value for three consecutive monitoring cycles, the sampling depth recovery process is initiated. The neighbor sampling depth is restored from level 2 to the default level 3, expanding the sampling coverage of neighbor nodes. This recovery operation must meet continuous stability requirements to prevent memory state fluctuations from causing frequent system switching.

[0037] If a memory warning is still triggered after adjusting the sampling depth, the backup buffer allocation process is executed. Independent memory buffer areas are dynamically allocated to local subgraph generators, isolating the memory usage boundaries of the subgraph construction process. This emergency mechanism prevents memory overflows from causing abnormal system terminations, maintaining the continuity of the knowledge graph construction process.

[0038] The module employs a hierarchical response strategy: routine monitoring maintains baseline operational status; first-level response controls resource consumption through sampling and degradation; and second-level response utilizes isolated caching to ensure system robustness. Each response level is triggered by trends in the memory change curve, forming a progressive resource control chain.

[0039] Specifically, in the large-scale knowledge graph construction system based on graph neural network described in the present invention, the time decay coefficient calculation in the local subgraph generator is: Get the latest interaction timestamp of the node corresponding to the relationship from the historical embedding memory; Calculate the time difference between the timestamp and the current system time; The time difference is mapped to the attenuation coefficient in the (0,1) interval through the negative exponential function; The adjacency matrix weight value is generated by multiplying the decay coefficient with the original relationship type weight in the relationship weight matrix output by the dynamic neighbor sampler.

[0040] The local subgraph generator uses the historical embedding memory to obtain the latest interaction timestamp for the nodes corresponding to the relationship. This timestamp records the moment of the most recent interaction between nodes and characterizes the timeliness of the topological connection. The timestamp data is derived from the version snapshot metadata in the historical embedding memory, ensuring that the time base is synchronized with the global system state.

[0041] Based on the obtained timestamp, the difference between the obtained timestamp and the current system time is calculated. The system clock is used as the current time reference, and the difference is calculated with millisecond granularity. This time difference quantifies the duration of the relationship from the last interaction to the current moment, reflecting the degree of time decay of the topological connection.

[0042] A time decay coefficient is generated by processing the time difference using a negative exponential function. This function maps any time difference to a continuous coefficient between 0 and 1, where smaller time differences correspond to higher decay coefficients and larger time differences correspond to lower decay coefficients. This coefficient represents the degree to which the temporality of the relationship affects the strength of the topological connection.

[0043] The time decay coefficient is combined with the relationship type weights output by the dynamic neighbor sampler. The relationship type weight matrix contains the inherent weight parameters of different relationship categories, representing the semantic importance of the relationships. The time decay coefficient acts as a multiplier on the original relationship type weights to generate relationship connection weights that incorporate temporal features.

[0044] The fused weights are stored as elements of an adjacency matrix. Each element of the adjacency matrix corresponds to a relationship between nodes, and its weights encode both the semantic importance of the relationship type and its temporal impact. This matrix serves as the foundation for a topological structure with time-decay properties and is output to the quantum state aggregator for subsequent feature processing.

[0045] The module implements a three-step logical progression: timestamp acquisition establishes a timeliness benchmark, time difference quantifies the degree of attenuation, and function mapping generates coefficient values. Ultimately, by integrating the coefficients with relationship weights, a unified representation of topological structure and timeliness characteristics is achieved in the adjacency matrix.

[0046] Specifically, in the large-scale knowledge graph construction system based on graph neural network described in the present invention, the quantum state aggregator is configured as follows: An amplitude compression unit normalizes the feature vector components returned by the history embedding memory and limits the upper limit of the absolute value of the amplitude; The quantum circuit loading module loads the parameterized quantum circuit structure of the space-time topology verifier and initializes the quantum bit entanglement path; Feature fusion unit, which aggregates the amplitude values ​​of neighboring nodes through controlled quantum gate operations; The classical space converter inversely encodes the quantum state measurement results and outputs them to the node embedding vector of the space-time topology verifier.

[0047] The amplitude compression unit processes the eigenvector components returned by the historical embedding memory. It normalizes the vector components across all dimensions to eliminate differences in characteristic scales. It also sets an upper threshold for the absolute value of the amplitude, truncating any components that exceed the threshold to a specified range. This preprocessing prevents numerical overflow in the subsequent quantum state mapping process, ensuring the stability of quantum computation.

[0048] The quantum circuit loading module receives the parameterized quantum circuit structure description from the space-time topology verifier. It analyzes the number of qubits and gate operation sequence in the circuit structure and initializes quantum registers of the corresponding size. Based on the entanglement path configuration in the circuit description, it establishes entanglement relationships between qubits. This process transforms the abstract circuit description into an executable quantum computing framework.

[0049] The feature fusion unit aggregates the quantum states of neighbor node features. It maps the compressed feature vector components to quantum bit amplitude values, encoding classical features into quantum states. Through controlled quantum gate operations, entangled superposition of amplitude values ​​is achieved on the quantum circuit, generating a quantum superposition state that incorporates neighbor node features. This quantum operation simulates the message passing mechanism in graph neural networks.

[0050] The classical space converter processes the quantum state measurement results to achieve inverse spatial transformation. Projection measurements are performed on the qubits to obtain probability distribution data. An inverse encoding algorithm is used to map the probability distribution back to classical vector space, reconstructing the node feature representation. The reconstructed node embedding vector is output to the spacetime topology verifier, completing the closed-loop quantum-classical space transformation.

[0051] The modular processing flow forms a closed technical loop: amplitude compression ensures input stability; quantum circuit loading establishes the computational framework; feature fusion aggregates quantum state information; and classical transformation reconstructs usable feature vectors. Each step efficiently integrates graph topological features through quantum states, providing optimized node embedding for spatiotemporal topology verification.

[0052] Specifically, in the large-scale knowledge graph construction system based on graph neural network described in the present invention, the feature distribution difference value calculation in the spatiotemporal topology verifier is: Adjacency tensor analyzer, which extracts the topological features of the isolated subgraph structure output by the quantum state aggregator to construct a multinomial distribution model; Quantum feature analyzer, which converts the node embedding vector output by the quantum state aggregator into a Gaussian mixture distribution model; KL divergence calculation module, which measures the difference between the aforementioned multinomial distribution model and the Gaussian mixture distribution model; Correction trigger, when the KL divergence value exceeds the preset tolerance threshold, sends a weight correction instruction to the dynamic neighbor sampler and a parameter update instruction to the quantum state aggregator.

[0053] The adjacency tensor analyzer processes the isolated subgraph structure output by the quantum state aggregator. This structure consists of a set of nodes and weighted adjacency relationships. It extracts topological characteristic parameters from the adjacency tensor, including high-dimensional features such as node connectivity distribution, edge weight distribution, and clustering coefficient. Based on the extracted topological features, a discrete multinomial distribution model is constructed to characterize the distribution of the subgraph's topological characteristics.

[0054] The Quantum Feature Analyzer processes the node embedding vectors output by the Quantum State Aggregator. It performs cluster analysis on the vector set to identify the characteristic distribution pattern and fits a continuous Gaussian mixture distribution model. This model consists of multiple Gaussian distribution components and their mixing weight coefficients, describing the probability density distribution of node embeddings in the feature space.

[0055] The KL divergence calculation module receives the aforementioned multinomial distribution model and Gaussian mixture distribution model. It calculates the KL divergence between the two probability distribution models to quantify the difference between the topological feature distribution and the node embedding feature distribution. This divergence value is a unitless scalar whose value directly reflects the match between the topological structure and the node embedding.

[0056] The correction trigger monitors the real-time output of the KL divergence calculation module. It continuously compares the divergence value with a preset tolerance threshold. If the divergence value consistently exceeds the tolerance threshold, it generates a weight correction instruction and sends it to the dynamic neighbor sampler. Simultaneously, it generates a parameter update instruction and sends it to the quantum state aggregator. This process triggers the system to coordinate adjustments to the neighbor sampling strategy and quantum feature fusion parameters.

[0057] The modules form a self-checking closed loop: the adjacency tensor analyzer quantifies topological structural features, the quantum feature analyzer models node embedding distribution, the KL divergence calculation module measures differences between two feature spaces, and the correction trigger drives system parameter optimization based on the measurement results. Each link achieves quantitative consistency verification of topology and embedding through probabilistic model conversion, providing a dynamic feedback control mechanism for the system.

[0058] Specifically, the large-scale knowledge graph construction system based on graph neural network described in the present invention includes: The change detection unit obtains the previous version vector of the node from the historical embedding memory and compares it with the node's current adjacent vector; the similarity calculation module uses the cosine similarity algorithm to measure the degree of difference between the two vectors; an activation determiner, which adds a node to an activation set when the change value output by the similarity calculation module exceeds a set threshold; The gradient clipping module linearly adjusts the gradient threshold according to the node version difference value output by the historical embedding memory.

[0059] The change detection unit accesses the node's historical snapshot data from the historical embedding memory. It obtains the target node's previous version embedding vector as a comparison baseline and simultaneously receives the current adjacency vector representing the latest topological state. This unit establishes a correlation between the version vector and the real-time vector, providing a data foundation for change detection.

[0060] The similarity calculation module processes the vector pairs output by the change detection unit. It uses the cosine similarity algorithm to calculate the directional difference between the two vectors in the feature space and outputs a scalar similarity value between -1 and 1. This value represents the degree of shift in node embeddings due to topological changes, with negative values ​​indicating significant feature directional changes.

[0061] The activation determinator receives the change value output by the similarity calculation module and compares it in real time with the system's preset activation threshold. When the change value exceeds the threshold, it triggers an instruction to add the node to the activation set. The activation set dynamically contains a subset of nodes that require gradient updates, controlling computing resources to focus on key change areas.

[0062] The gradient clipping module loads the node version difference values ​​provided by the historical embedding memory. This value quantifies the embedding change between historical versions using Euclidean distance. A linear mapping relationship is established between the version difference value and the gradient threshold, increasing the gradient clipping threshold as the difference value increases. This mechanism dynamically controls the gradient update amplitude during backpropagation to prevent numerical oscillation during embedding vector updates.

[0063] The modules form a closed-loop update control loop: change detection identifies key nodes, similarity quantifies change intensity, activation determination selects update targets, and gradient regulation ensures update stability. Each unit is connected in series through data streams to implement a targeted optimization mechanism within the graph neural network, improving incremental update efficiency while maintaining global representation consistency.

[0064] Specifically, in the large-scale knowledge graph construction system based on graph neural network described in the present invention, the gradient clipping module dynamically adjusts the rules: The embedding propagation controller establishes a mapping table of the positive proportional relationship between the node version difference value output by the historical embedding memory and the clipping threshold; When the difference between the current version and the previous cycle increases by more than 10%, the gradient clipping threshold is increased by 20% to 50%; When the gradient values ​​of two consecutive propagation processes do not exceed the current gradient clipping threshold, the clipping threshold is lowered by 10% to 15%.

[0065] The embedding propagation controller maintains a table mapping node version difference values ​​to gradient clipping thresholds. This table records the node version difference values ​​output by the historical embedding memory. The difference values ​​reflect the historical fluctuations in the node embedding vectors. A proportional relationship model is established between the difference values ​​and the clipping thresholds. As the difference values ​​increase, the clipping thresholds increase, while as the difference values ​​decrease, the clipping thresholds decrease.

[0066] When the difference between the current version and the previous calculation cycle increases by more than a preset percentage, the gradient clipping threshold is raised. Based on the percentage increase, a specific percentage interval is added to the threshold base, widening the permitted range of gradient updates. This adjustment accommodates drastic changes in node embedding state and prevents over-suppression of valid updates.

[0067] When the gradient values ​​recorded during two consecutive graph propagation processes fall below the current clipping threshold, a threshold downgrade is performed. This reduces the fixed-ratio interval from the existing threshold base, narrowing the allowable range of gradient updates. This adjustment responds to improved system stability and enhances the refinement of gradient control.

[0068] The adjustment process adheres to a two-way dynamic balance principle: when nodes undergo significant changes, gradient constraints are relaxed to ensure update efficiency; when the system stabilizes, gradient constraints are tightened to improve accuracy. A mapping table serves as the core adjustment benchmark, enabling adaptive control by proportionally correlating difference values ​​with thresholds. Threshold adjustment operations are embedded between graph propagation iterations, forming a closed-loop feedback control mechanism.

[0069] Specifically, in the large-scale knowledge graph construction system based on graph neural network described in the present invention, the graph updater includes: The incremental analysis unit compares the new embedding vector in the embedding vector set that has passed the secondary verification with the old embedding vector of the old node stored in the historical embedding memory, and calculates the coordinate offset; The transaction encapsulation module encapsulates the newly added node vector and the old node coordinate offset into an atomic transaction package; Log generator, which records the timestamp of each vector change event and the version dependency chain between nodes; The consistency write module synchronously sends the transaction package and log to the historical embedded storage through atomic write operations.

[0070] The incremental analysis unit processes the set of embedding vectors that have passed the second validation of the spatiotemporal topology verifier. For old nodes already in the historical embedding memory, the corresponding old version of the embedding vector is extracted as a comparison baseline. The coordinate offset between the new embedding vector and the old vector is calculated. This offset quantifies the position change of the node feature space in the form of a vector difference, reflecting the incremental change characteristics of the knowledge graph.

[0071] The transaction encapsulation module receives the newly added node vector and the coordinate offset of the old node. It treats the newly added node vector as an independent data unit and the old node offset as a change unit, encapsulating them into an atomic transaction package. This package design adheres to the principles of atomic operations and supports full commit or rollback mechanisms, providing a fundamental guarantee for data consistency.

[0072] The log generator tracks metadata for vector change events. It collects precise timestamps of vector changes to mark version sequences, analyzes topological dependencies between nodes, and generates a version dependency chain. This chain describes the impact of the changed node within the knowledge graph, forming a structured basis for version backtracking.

[0073] The consistent write module performs atomic storage operations. It bundles transaction packages and associated logs into an indivisible unit and transfers them to the historical embedding memory via a synchronous write protocol. The write process follows the log-first, data-later order, maintaining the order and integrity of transaction operations at the storage level and enabling reliable updates of the knowledge graph state.

[0074] The module collaboration mechanism embodies a three-layer technical logic: incremental analysis extracts core change characteristics, transaction encapsulation builds atomic operation units, and logging establishes traceable metadata. Ultimately, consistent writes implement transactions at the storage layer, completing the closed-loop control process for dynamic knowledge graph expansion. Each step strictly adheres to the incremental update principle to avoid the resource consumption of full recalculation.

[0075] Specifically, the large-scale knowledge graph construction system based on graph neural network described in the present invention also includes: Timing control closed-loop module: The node increment receiver sends the window boundary time identifier to the historical embedding memory. The historical embedding memory aligns the version snapshot according to the time identifier. The dynamic neighbor sampler samples according to the time sequence density based on the new node timestamp density. The graph updater generates a version log to update the historical snapshot and trigger the historical embedding memory snapshot to overwrite. Precision adjustment closed-loop module: The spatiotemporal topology verifier detects feature distribution difference values, the dynamic neighbor sampler responds to weight correction instructions to correct relationship weights, the quantum state aggregator responds to parameter update instructions to update line parameters, and the spatiotemporal topology verifier secondary verifies the correction effect of the embedded vector after propagation; Resource optimization chain module: The dynamic neighbor sampler dynamically adjusts the sampling depth based on the output of the resource monitoring module. The local subgraph generator simplifies the size of the adjacency matrix by calculating the time decay coefficient. The historical embedding memory reduces memory copy overhead by pointer calls when querying neighbor nodes.

[0076] The timing control closed-loop module establishes a system-level time synchronization mechanism. The node increment receiver transmits window boundary time identifiers to the historical embedding memory, which marks the timing split point for batch processing. The historical embedding memory aligns version snapshots based on the time identifiers, ensuring that the storage state is strictly synchronized with the data input window. The dynamic neighbor sampler analyzes the density distribution of new node timestamps and increases sampling intensity in areas of high time density. The graph updater generates a version log to record incremental change information, triggering the historical embedding memory to perform a snapshot overwrite operation, forming a complete timing closed loop from data input to storage update.

[0077] The precision control closed-loop module implements a feature expression optimization mechanism. The spatiotemporal topology verifier continuously monitors feature distribution discrepancies, which reflect the mismatch between the topological structure and node embeddings. When these discrepancies exceed the tolerance range, it sends weight correction instructions to the dynamic neighbor sampler to adjust the parameters of the relationship type weight matrix. The synchronized vector quantum state aggregator then sends parameter update instructions to optimize the quantum circuit feature fusion process. The spatiotemporal topology verifier performs a secondary verification of the corrected vectors output by the embedding propagation controller, evaluating the effect of parameter adjustments on embedding quality, thus forming a feedback loop for precision control.

[0078] The resource optimization chain module builds a multi-level resource management and control system. The dynamic neighbor sampler dynamically adjusts the neighbor sampling depth level based on real-time memory usage data from the resource monitoring module to control the scale of topological data. The local subgraph generator compresses the number of valid elements in the adjacency matrix by calculating the time decay coefficient, reducing matrix storage and computational overhead. The historical embedding memory uses a feature vector pointer transfer mechanism when processing neighbor node queries, avoiding large-scale vector data copying operations and significantly reducing memory bandwidth consumption. This three-level optimization approach forms a resource optimization chain from sampling control, matrix reduction, to storage scheduling.

[0079] This invention deeply couples data flow and control flow: a closed-loop timing system provides a time reference framework for precision adjustment, a resource optimization chain ensures resource availability during the computational process, and precision adjustment output is fed back into the timing control system to update the storage state. Through a modular collaborative architecture, the system achieves a balanced control of precision, efficiency, and resource consumption during the dynamic construction of knowledge graphs.

[0080] This invention systematically reduces computing resource consumption through a triple-cooperation mechanism. The node increment receiver uses a fixed time window to batch process new nodes, avoiding the fragmented computational overhead of streaming updates. The historical embedding memory reuses historical embedding vectors through version snapshots, eliminating duplicate computations for all nodes. The dynamic neighbor sampler dynamically allocates sampling resources based on timestamp density, reducing the computational load in low-value areas. This closed-loop timing control system enables intensive scheduling of computing resources.

[0081] A precision adjustment mechanism suppresses ineffective computation cycles. The spatiotemporal topology verifier detects discrepancies between the topological and embedded feature distributions. The dynamic neighbor sampler adjusts the relationship weight matrix accordingly, and the quantum state aggregator synchronously updates the fusion parameters, forming an adaptive closed-loop feature optimization. This mechanism triggers parameter updates only when significant deviations are detected, avoiding the resource consumption of continuous full-graph retraining. The embedding propagation controller freezes gradient computations on inactive nodes, further focusing computational resources on critical change areas.

[0082] The resource optimization chain achieves multi-dimensional compression. The dynamic neighbor sampler dynamically shrinks the sampling depth based on memory usage, reducing neighborhood search complexity. The local subgraph generator compresses the size of the effective elements in the adjacency matrix using a time decay coefficient. The history embedding memory uses a pointer call mechanism to eliminate vector copy overhead. Multi-level optimization forms a joint compute-storage decompression path, controlling the cascading resource consumption generated by the graph neural network iteration process from the data source.

Claims

1. A large-scale knowledge graph construction system based on graph neural network, characterized by: include: Node increment receiver, which receives external real-time entity attribute stream data and outputs new node sets to the dynamic neighbor sampler; The historical embedding memory receives the incremental embedding update package from the graph updater to overwrite the historical snapshot, and calculates the Euclidean distance difference between the new and old version embedding vectors as the node version difference value; The dynamic neighbor sampler receives the weight correction instruction of the spatiotemporal topology verifier to update the relationship type weight matrix, dynamically adjusts the sampling depth according to the memory usage, and outputs the neighbor node set and relationship weight matrix to the local subgraph generator; The local subgraph generator integrates the new node set and the neighbor node set to construct a vertex set, requests the neighbor node feature vector pointer from the historical embedding memory, calculates the relationship time decay coefficient by adding an exponential decay function based on the time difference, and outputs the isolated subgraph structure to the quantum state aggregator; The quantum state aggregator maps the neighbor node feature vector components to quantum state amplitude values, loads the parameterized quantum circuit structure of the space-time topology verifier, performs quantum state entanglement operations to fuse the features, and then outputs the node embedded in the space-time topology verifier; The spatiotemporal topology verifier parses the isolated subgraph structure to generate an adjacency tensor representation, calculates the difference between the adjacency tensor and the feature distribution of the quantum node embedding, and sends a weight correction instruction to the dynamic neighbor sampler and a parameter update instruction to the quantum state aggregator when the difference exceeds the threshold. The verified node vector is output to the embedding propagation controller; The embedding propagation controller filters out nodes whose vector change in the adjacent tensor exceeds the threshold to form an activation set, loads the node version difference value output by the historical embedding memory, freezes the gradient calculation of inactive nodes and dynamically sets the gradient clipping threshold, and outputs the propagated embedding vector to the spatiotemporal topology verifier for secondary verification; The graph updater receives the embedded vector set that has passed the secondary verification of the spatiotemporal topology verifier, writes the newly added node vector directly into the storage, generates the incremental update package of the old node and the global consistency log and sends them to the historical embedding storage to complete the dynamic expansion.

2. The large-scale knowledge graph construction system based on graph neural network according to claim 1 is characterized in that: Also includes: The node increment receiver parses the entity type identifier and the relationship attribute set, aggregates and generates a batch of new node sets according to a fixed time window, obtains the new node set, and sends the window boundary time identifier to the historical embedding memory at the same time; The historical embedding memory stores the full node embedding vector and its time version snapshot, responds to the neighbor node query request of the dynamic neighbor sampler, returns the feature vector pointer, and outputs the node version difference value to the embedding propagation controller; The dynamic neighbor sampler includes: The timing control module counts the distribution density of timestamps generated by new nodes and generates a sequence that prioritizes sampling in high-density areas; The accuracy feedback module receives and parses the weight correction instructions sent by the spatiotemporal topology verifier, and updates the weight parameters of the corresponding categories in the relationship type weight matrix in the dynamic neighbor sampler; The resource monitoring module obtains the system memory usage in real time, reduces the preset sampling depth level when the usage exceeds the set threshold, and restores the original level when the usage drops.

3. The large-scale knowledge graph construction system based on graph neural network according to claim 2 is characterized in that: The resource monitoring module is configured to: Periodically monitor the memory usage change curve; When the memory usage exceeds the first critical value for two consecutive monitoring cycles, the neighbor sampling depth is reduced from the default level 3 to level 2; When the memory usage drops below the second critical value for three consecutive monitoring cycles, the sampling depth is restored to level three; When the memory warning of the resource monitoring module is still triggered after the sampling depth is adjusted, the spare buffer area is allocated to the local subgraph generator.

4. The large-scale knowledge graph construction system based on graph neural network according to claim 3 is characterized in that: The time attenuation coefficient calculation in the local subgraph generator is: Get the latest interaction timestamp of the node corresponding to the relationship from the historical embedding memory; Calculate the time difference between the timestamp and the current system time; The time difference is mapped to the attenuation coefficient in the (0,1) interval through the negative exponential function; The adjacency matrix weight value is generated by multiplying the decay coefficient with the original relationship type weight in the relationship weight matrix output by the dynamic neighbor sampler.

5. The large-scale knowledge graph construction system based on graph neural network according to claim 4 is characterized in that: The quantum state aggregator is configured to: An amplitude compression unit normalizes the feature vector components returned by the history embedding memory and limits the upper limit of the absolute value of the amplitude; The quantum circuit loading module loads the parameterized quantum circuit structure of the space-time topology verifier and initializes the quantum bit entanglement path; Feature fusion unit, which aggregates the amplitude values ​​of neighboring nodes through controlled quantum gate operations; The classical space converter inversely encodes the quantum state measurement results and outputs them to the node embedding vector of the space-time topology verifier.

6. The large-scale knowledge graph construction system based on graph neural network according to claim 5 is characterized in that: Calculation of feature distribution difference value in the spatiotemporal topology verifier: The adjacency tensor analyzer extracts the topological features of the isolated subgraph structure output by the quantum state aggregator to construct a multinomial distribution model; Quantum feature analyzer, which converts the node embedding vector output by the quantum state aggregator into a Gaussian mixture distribution model; KL divergence calculation module, which measures the difference between the aforementioned multinomial distribution model and the Gaussian mixture distribution model; Correction trigger, when the KL divergence value exceeds the preset tolerance threshold, sends a weight correction instruction to the dynamic neighbor sampler and a parameter update instruction to the quantum state aggregator.

7. The large-scale knowledge graph construction system based on graph neural network according to claim 6 is characterized in that: The embedded propagation controller includes: The change detection unit obtains the previous version vector of the node from the historical embedding memory and compares it with the node's current adjacent vector; the similarity calculation module uses the cosine similarity algorithm to measure the degree of difference between the two vectors; an activation determiner, which adds a node to an activation set when the change value output by the similarity calculation module exceeds a set threshold; The gradient clipping module linearly adjusts the gradient threshold according to the node version difference value output by the historical embedding memory.

8. The large-scale knowledge graph construction system based on graph neural network according to claim 7 is characterized in that: The gradient clipping module dynamically adjusts the rules: The embedding propagation controller establishes a mapping table of the positive proportional relationship between the node version difference value output by the historical embedding memory and the clipping threshold; When the difference between the current version and the previous cycle increases by more than 10%, the gradient clipping threshold is increased by 20% to 50%; When the gradient values ​​of two consecutive propagation processes do not exceed the current gradient clipping threshold, the clipping threshold is lowered by 10% to 15%.

9. The large-scale knowledge graph construction system based on graph neural network according to claim 8 is characterized in that: The atlas updater includes: The incremental analysis unit compares the new embedding vector in the embedding vector set that has passed the secondary verification with the old embedding vector of the old node stored in the historical embedding memory, and calculates the coordinate offset; The transaction encapsulation module encapsulates the newly added node vector and the old node coordinate offset into an atomic transaction package; Log generator, which records the timestamp of each vector change event and the version dependency chain between nodes; The consistency write module synchronously sends the transaction package and log to the historical embedded storage through atomic write operations.

10. The large-scale knowledge graph construction system based on graph neural network according to claim 9 is characterized in that: Also includes: Timing control closed-loop module: The node increment receiver sends the window boundary time identifier to the historical embedding memory. The historical embedding memory aligns the version snapshot according to the time identifier. The dynamic neighbor sampler samples according to the time sequence density based on the new node timestamp density. The graph updater generates a version log to update the historical snapshot and trigger the historical embedding memory snapshot to overwrite. Precision adjustment closed-loop module: The spatiotemporal topology verifier detects feature distribution difference values, the dynamic neighbor sampler responds to weight correction instructions to correct relationship weights, the quantum state aggregator responds to parameter update instructions to update line parameters, and the spatiotemporal topology verifier secondary verifies the correction effect of the embedded vector after propagation; Resource optimization chain module: The dynamic neighbor sampler dynamically adjusts the sampling depth based on the output of the resource monitoring module. The local subgraph generator simplifies the size of the adjacency matrix by calculating the time decay coefficient. The historical embedding memory reduces memory copy overhead by pointer calls when querying neighbor nodes.

Images