A large-scale knowledge graph construction system based on a graph neural network

Abstract

The present application relates to the technical field of data processing, and more particularly to a large-scale knowledge graph construction system based on a graph neural network, comprising a node incremental receiver, a historical embedding memory, a dynamic neighbor sampler, a local subgraph generator, a quantum state aggregator, a space-time topology verifier, an embedding propagation controller and a graph updater. The time sequence control closed loop adopts time window batch processing of new nodes, the historical embedding memory aligns version snapshots and reuses historical embeddings, and the dynamic neighbor sampler optimizes sampling resources according to time sequence density; the precision adjustment closed loop triggers relationship weight correction and quantum circuit parameter updating, the embedding propagation controller freezes the gradient of non-activated nodes to focus on key changes; the resource optimization chain adjusts to reduce neighborhood complexity, the time decay coefficient compresses the size of the adjacency matrix, and the historical embedding memory pointer call eliminates vector copy overhead. The present application significantly reduces the computational resource consumption of the dynamic updating process and maintains the quality of the knowledge graph representation.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of data processing, and in particular to a large-scale knowledge graph construction system based on a graph neural network. BACKGROUND

[0002] Large-scale knowledge graph modeling complex entities and relationships as heterogeneous graph structures; when the graph scale is large, the complexity of the relationship increases, which limits the traditional method in reasoning efficiency and information integration; the graph neural network introduces a message passing framework to solve the challenge, which iteratively aggregates neighborhood features and updates low-dimensional embedding representations by nodes; such embedding captures the graph topology pattern, supports link prediction or entity classification tasks; when applied to information retrieval or recommendation systems, the graph neural network directly processes large-scale data, improves knowledge reasoning accuracy and optimizes computing resource consumption, and meets the performance requirements of modern digital systems.

[0003] In the process of constructing a large-scale knowledge graph, the graph neural network faces the pain point of high computational complexity in efficiently processing heterogeneous relationships, because the graph scale is large and the relationship diversity is rich, and the message passing mechanism causes the geometric level growth of the computing overhead when iteratively aggregating neighborhood features by nodes, and the memory occupation significantly increases; for example, when an information retrieval system is running, integrating new entities such as e-commerce commodity attributes, the existing technology deployment needs to retrain the embedding representation of the whole graph, which increases the system delay and reduces the resource utilization, affecting the user experience and platform performance. SUMMARY

[0004] In view of the deficiencies of the prior art, the present application provides a large-scale knowledge graph construction system based on a graph neural network, which solves the technical problem of high computing resource consumption of the graph neural network in processing dynamic update of new nodes embedding of a large-scale knowledge graph.

[0005] To solve the above technical problems, the specific technical solutions of the present application are as follows:

[0006] The present application provides a large-scale knowledge graph construction system based on a graph neural network, which comprises:

[0007] A node increment receiver receives external real-time entity attribute stream data, parses entity type identifiers and relationship attribute sets, aggregates and generates a batch of new node sets according to a fixed time window, outputs the new node set to a dynamic neighbor sampler, and sends a window boundary time identifier to a historical embedding memory at the same time;

[0008] The historical embedding memory stores full node embedding vectors and time version snapshots thereof, returns a feature vector pointer in response to a neighbor node query request of the dynamic neighbor sampler, receives an incremental embedding update package covering the historical snapshot from the graph updater, calculates the Euclidean distance difference value of the new and old version embedding vectors as the node version difference value, and outputs it to the embedding propagation controller;

[0009] The dynamic neighbor sampler generates a sampling priority sequence according to a new node timestamp density, receives a weight correction instruction of the spatiotemporal topology verifier to update a relationship type weight matrix, dynamically adjusts a sampling depth according to a memory occupancy rate, and outputs a neighbor node set and a relationship weight matrix to the local subgraph generator;

[0010] The local subgraph generator integrates the new node set and the neighbor node set to construct a vertex set, requests a neighbor node feature vector pointer from a historical embedding memory, calculates a relationship time decay coefficient by appending an exponential decay function based on a time difference value, generates a weighted adjacency relationship matrix, and then outputs an isolated subgraph structure to the quantum state aggregator;

[0011] The quantum state aggregator maps neighbor node feature vector components into quantum state amplitude values, loads a parameterized quantum circuit structure of the spatiotemporal topology verifier, performs quantum state entanglement operations to fuse features, and then outputs node embeddings to the spatiotemporal topology verifier;

[0012] The spatiotemporal topology verifier analyzes the isolated subgraph structure to generate an adjacency tensor representation, calculates a feature distribution difference value of the adjacency tensor and the quantum node embedding, sends a weight correction instruction to the dynamic neighbor sampler and a parameter update instruction to the quantum state aggregator when the difference value exceeds a threshold value, and outputs a verified node vector to the embedding propagation controller;

[0013] The embedding propagation controller selects nodes with a vector change degree exceeding a threshold value in the adjacency tensor to form an active set, loads a node version difference value output by the historical embedding memory, freezes gradient calculation of non-active nodes and dynamically sets a gradient clipping threshold value, and outputs a propagated embedding vector to the spatiotemporal topology verifier for secondary verification;

[0014] The graph updater receives an embedding vector set that passes the secondary verification of the spatiotemporal topology verifier, directly writes new node vectors into storage, generates an old node incremental update package and a global consistency log, and sends them to the historical embedding memory to complete dynamic expansion.

[0015] Further, the large-scale knowledge graph construction system based on a graph neural network provided by the application comprises:

[0016] The timing control module counts a new node generation timestamp distribution density and generates a sequence for preferential sampling in a high-density area;

[0017] The precision feedback module receives and analyzes the weight correction instruction sent by the spatiotemporal topology verifier, and updates the weight parameters of the corresponding category in the relationship type weight matrix in the dynamic neighbor sampler;

[0018] The resource monitoring module acquires a system memory occupancy rate in real time, reduces a preset sampling depth level when the occupancy rate exceeds a set threshold value, and restores the original level when the occupancy rate falls back.

[0019] Further, the large-scale knowledge graph construction system based on a graph neural network provided by the present application, the resource monitoring module is configured to:

[0020] Periodically monitor the memory occupancy rate change curve;

[0021] When the memory occupancy rate breaks through the first critical value in two consecutive monitoring periods, the neighbor sampling depth is reduced from the default three levels to two levels;

[0022] When the memory occupancy rate drops below the second critical value for three monitoring periods, the sampling depth is restored to three levels;

[0023] When the sampling depth is adjusted and the memory warning of the resource monitoring module is still triggered, start the backup cache area allocation process to the local subgraph generator.

[0024] Further, the large-scale knowledge graph construction system based on a graph neural network provided by the present application, the time decay coefficient calculation in the local subgraph generator:

[0025] Get the latest interaction timestamp of the node corresponding to the relationship from the historical embedding memory;

[0026] Calculate the time difference between the timestamp and the current system time;

[0027] Map the time difference value to a decay coefficient in the interval (0, 1) through a negative exponential function;

[0028] Multiply the decay coefficient and the original relationship type weight in the relationship weight matrix output by the dynamic neighbor sampler to generate the adjacency matrix weight value.

[0029] Further, the large-scale knowledge graph construction system based on a graph neural network provided by the present application, the quantum state aggregator is configured to:

[0030] The amplitude compression unit normalizes and limits the upper limit of the absolute value of the feature vector component returned by the historical embedding memory;

[0031] The quantum circuit loading module loads the parameterized quantum circuit structure of the space-time topology verifier and initializes the quantum bit entanglement path;

[0032] The feature fusion unit aggregates the neighbor node amplitude value through a controlled quantum gate operation;

[0033] The classical space converter inversely encodes the quantum state measurement result and outputs it to the node embedding vector of the space-time topology verifier.

[0034] Further, the large-scale knowledge graph construction system based on a graph neural network provided by the present application, the feature distribution difference value calculation in the space-time topology verifier:

[0035] An adjacency tensor analyzer constructs a multinomial distribution model by extracting topological features of the isolated subgraph structure output by the quantum state aggregator;

[0036] A quantum feature analyzer converts the node embedding vector output by the quantum state aggregator into a Gaussian mixture distribution model;

[0037] A KL divergence calculation module measures the difference value between the aforementioned multinomial distribution model and the Gaussian mixture distribution model;

[0038] A correction trigger sends a weight correction instruction to the dynamic neighbor sampler and a parameter update instruction to the quantum state aggregator when the KL divergence value exceeds a preset tolerance threshold.

[0039] Further, the large-scale knowledge graph construction system based on a graph neural network provided by the present application comprises an embedding propagation controller, which comprises:

[0040] A change detection unit obtains the last version vector of a node from the historical embedding memory and compares it with the current adjacency vector of the node; and a similarity calculation module measures the difference degree of the two vectors using a cosine similarity algorithm;

[0041] An activation determiner adds the node to an activation set when the change value output by the similarity calculation module exceeds a set threshold;

[0042] A gradient clipping module linearly adjusts the gradient threshold value according to the node version difference value output by the historical embedding memory.

[0043] Further, the large-scale knowledge graph construction system based on a graph neural network provided by the present application, the gradient clipping module dynamically adjusts the rules:

[0044] The embedding propagation controller establishes a positive proportional relationship mapping table between the node version difference value output by the historical embedding memory and the clipping threshold value;

[0045] When the increase amplitude of the current version difference value compared with the last period exceeds 10%, the gradient clipping threshold value is increased by 20% to 50%;

[0046] When the gradient value does not exceed the current gradient clipping threshold value in two consecutive propagation processes, the clipping threshold value is lowered by 10% to 15%.

[0047] Further, the large-scale knowledge graph construction system based on a graph neural network provided by the present application, the graph updater comprises:

[0048] An incremental analysis unit compares the new embedding vector in the embedding vector set that passes the secondary verification with the old embedding vector of the old node stored in the historical embedding memory, and calculates the coordinate offset;

[0049] A transaction encapsulation module encapsulates the new node vector and the old node coordinate offset into an atomic transaction package;

[0050] A log generator records the timestamp of each vector change event and the version dependency chain between nodes;

[0051] A consistency writing module synchronously sends the transaction package and the log to the historical embedded memory through an atomic writing operation.

[0052] Further, the large-scale knowledge graph construction system based on the graph neural network provided by the present application further comprises:

[0053] A timing control closed loop module: the node increment receiver sends a window boundary time identifier to the historical embedded memory, the historical embedded memory aligns the version snapshot according to the time identifier, the dynamic neighbor sampler samples according to the time sequence density according to the new node timestamp density, and the graph updater generates a version log to update the historical snapshot and triggers the historical embedded memory snapshot coverage;

[0054] A precision adjustment closed loop module: the space-time topology verifier detects a feature distribution difference value, the dynamic neighbor sampler corrects the relationship weight in response to a weight correction instruction, the quantum state aggregator updates the line parameters in response to a parameter update instruction, and the space-time topology verifier verifies the propagation of the corrected embedded vector again;

[0055] A 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 calculates the size of the simplified adjacency matrix through a time decay coefficient, and the historical embedded memory reduces the memory copy overhead when querying the neighbor nodes through a pointer call.

[0056] The present application has the following beneficial effects:

[0057] The present application significantly reduces resource consumption and maintains knowledge graph representation quality through a triple synergistic 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 embedding memory avoids full node recalculation; and the dynamic neighbor sampler allocates sampling resources according to 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 relationship weight matrix correction and quantum circuit parameter update to suppress invalid calculation cycles; the embedding propagation controller freezes the gradient calculation of inactive nodes and focuses computing resources on key change areas. The resource optimization chain implements multi-dimensional compression strategies, dynamically adjusts the sampling depth to control neighborhood search complexity; the time decay coefficient compresses the size of the adjacency matrix effective elements; and the pointer calling mechanism of the historical embedding memory eliminates vector copy overhead, forming a computing-storage joint decompression path. The present application balances computing accuracy and resource efficiency through a modularized synergistic architecture, supporting real-time dynamic expansion of large-scale knowledge graphs. BRIEF DESCRIPTION OF DRAWINGS

[0058] In order to more clearly illustrate the technical solutions of the present application, the following will briefly introduce the drawings needed in the embodiments. Obviously, for those skilled in the art, other drawings can also be obtained without creative labor based on the drawings.

[0059] Figure 1 A system architecture diagram of a large-scale knowledge graph construction system based on a graph neural network provided by an embodiment of the present application. DETAILED DESCRIPTION

[0060] In order to make the purpose, technical solutions and advantages of the present application clearer, the following will combine specific embodiments of the present application and corresponding drawings to clearly and completely describe the technical solutions of the present application. Obviously, the described embodiments are only some of the embodiments of the present application, not all the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without creative labor are within the scope of protection of the present application. The following will combine the drawings to specifically describe the technical solutions provided by the embodiments of the present application. In order to better understand the purpose of the present application, the following will further describe the present application in detail.

[0061] Please refer to Figure 1 The present application provides a large-scale knowledge graph construction system based on a graph neural network, which comprises:

[0062] A node delta receiver receives external real-time entity attribute stream data, parses entity type identifiers and relationship attribute sets, aggregates and generates a batch of new node sets according to a fixed time window, and outputs the new node sets to a dynamic neighbor sampler, and sends a window boundary time identifier to a historical embedding memory;

[0063] The historical embedding memory stores full-amount node embedding vectors and their time version snapshots, returns a feature vector pointer in response to a neighbor node query request of the dynamic neighbor sampler, receives an incremental embedding update package of the graph update to cover the historical snapshot, calculates the Euclidean distance difference value of the new and old version embedding vectors as the node version difference value, and outputs it to the embedding propagation controller;

[0064] The dynamic neighbor sampler generates a sampling priority sequence according to the density of new node timestamps, receives a weight correction instruction from the spatio-temporal topology verifier to update the relationship type weight matrix, dynamically adjusts the sampling depth according to the memory occupancy rate, and outputs the neighbor node set and the relationship weight matrix to the local subgraph generator;

[0065] The local subgraph generator integrates the new node set and the neighbor node set to construct a vertex set, requests a neighbor node feature vector pointer from the historical embedding memory, calculates a relationship time decay coefficient based on an exponential decay function of the time difference value, generates a weighted adjacency relationship matrix, and then outputs an isolated subgraph structure to the quantum state aggregator;

[0066] The quantum state aggregator maps the neighbor node feature vector components to quantum state amplitude values, loads the parameterized quantum circuit structure of the spatio-temporal topology verifier, performs quantum state entanglement operations to fuse the features, and then outputs the node embedding to the spatio-temporal topology verifier;

[0067] The spatio-temporal topology verifier analyzes the isolated subgraph structure to generate an adjacency tensor representation, calculates the feature distribution difference value of the adjacency tensor and the quantum node embedding, and when the difference value exceeds a threshold, sends a weight correction instruction to the dynamic neighbor sampler and a parameter update instruction to the quantum state aggregator. The verified node vector is output to the embedding propagation controller;

[0068] The embedding propagation controller selects the nodes with a vector change degree exceeding a threshold in the adjacency tensor to form an active set, loads the node version difference value output by the historical embedding memory, freezes the gradient calculation of non-active nodes and dynamically sets a gradient clipping threshold, and outputs the propagated embedding vector to the spatio-temporal topology verifier for secondary verification;

[0069] The graph updater receives the embedding vector set that passes the secondary verification of the spatio-temporal topology verifier, directly writes the new node vector into storage, generates an old node incremental update package and a global consistency log, and sends them to the historical embedding memory to complete dynamic expansion.

[0070] The node delta receiver is responsible for processing the real-time entity attribute stream data input from the outside. This component first parses the entity type identifier and the relationship attribute set in the data stream to identify the entity category and the association relationship characteristics. Through the fixed time window mechanism, the data is batch aggregated to form a structured new node set. The new node set is output to the dynamic neighbor sampler for subsequent processing, and the window boundary time identifier is sent to the historical embedding memory to provide a reference for time version alignment.

[0071] The historical embedding memory maintains the full node embedding vector and its historical version snapshots. When the dynamic neighbor sampler initiates a neighbor node query request, it returns a feature vector pointer instead of a complete data copy, reducing memory transmission overhead. After receiving the incremental embedding update package generated by the graph update generator, the stored historical snapshots are overwritten and the version track is preserved. The Euclidean distance difference value of the new and old version embedding vectors is calculated and quantized as the node version difference value output to the embedding propagation controller to provide a quantitative basis for gradient control.

[0072] The dynamic neighbor sampler generates a sampling priority sequence based on the density of new node timestamp distribution, and assigns higher sampling weight to time-intensive areas. Receive the weight correction instruction issued by the spatio-temporal topology verifier, update the class weight parameter in the relationship type weight matrix. Real-time monitoring of system memory occupancy dynamically adjusts the sampling depth, reduces the sampling level and reduces the computational load when the memory exceeds the threshold. Output the neighbor node set and the relationship weight matrix to the local subgraph generator to form the topology structure basis.

[0073] The local subgraph generator integrates the new node set and the neighbor nodes obtained by sampling to construct the vertex set. Request the neighbor node feature vector pointer from the historical embedding memory to obtain the feature data. Append the exponential decay function based on the time difference value to calculate the relationship time decay coefficient to reflect the timeliness influence. Multiply the time decay coefficient with the relationship type weight matrix to generate a weighted adjacency relationship matrix, and output the isolated subgraph structure to the quantum state aggregator for feature fusion.

[0074] The quantum state aggregator maps the neighbor node feature vector components to quantum state amplitude values. Load the parameterized quantum circuit structure configured by the spatio-temporal topology verifier, initialize the quantum bit entanglement path. Perform quantum state entanglement through controlled quantum gate operations to fuse neighbor node feature information. Perform classical space inverse coding on the quantum state measurement results, and output the node embedding vector to the spatio-temporal topology verifier for topology verification.

[0075] The spatio-temporal topology verifier parses the isolated subgraph structure input by the quantum state aggregator to generate an adjacency tensor representation. The difference value between the characteristic distribution of the adjacency tensor and the quantum node embedding vector is calculated to quantify the degree of topology consistency. When the difference value exceeds the tolerance threshold, a weight correction instruction is sent to the dynamic neighbor sampler to adjust the sampling strategy, and a parameter update instruction is sent to the quantum state aggregator to optimize feature fusion. The verified node vector is output to the embedding propagation controller for selective update.

[0076] The embedding propagation controller selects the node group with a vector change degree exceeding the threshold value in the adjacency tensor to form an active set. The node version difference value provided by the historical embedding memory is loaded as the adjustment reference. The gradient calculation of the non-active node is frozen to avoid invalid operation, and the gradient clipping threshold is dynamically set based on the version difference value to control the update amplitude. The propagated embedding vector is output to the spatio-temporal topology verifier for secondary verification to ensure the update quality.

[0077] The atlas updater receives the embedding vector set that passes the secondary verification to perform storage update. The new node vector is directly written into the historical embedding memory to achieve expansion. The coordinate offset is calculated by comparing the old and new embedding vectors of the old node to generate an incremental update package for the old node. The vector change timestamp and version dependency chain are recorded to form a global consistency log. The transaction package and the log are synchronously sent to the historical embedding memory through atomic write operation to complete the dynamic expansion and version management of the knowledge graph.

[0078] Specifically, the large-scale knowledge graph construction system based on the graph neural network comprises a dynamic neighbor sampler.

[0079] A timing control module, which calculates the timestamp distribution density of new nodes to generate a sequence of preferential sampling of high-density areas;

[0080] An accuracy feedback module, which receives and analyzes the weight correction instruction sent by the spatio-temporal topology verifier to update the weight parameters of the corresponding categories in the relationship type weight matrix in the dynamic neighbor sampler;

[0081] A resource monitoring module, which acquires the system memory occupancy rate in real time, reduces the preset sampling depth level when the occupancy rate exceeds the set threshold, and restores the original level when the occupancy rate falls.

[0082] The timing control module performs statistical analysis of the timestamp distribution density of new nodes. This module calculates the node generation frequency in fixed time intervals to identify high-density aggregation areas in the time dimension. When generating the sampling priority sequence, higher sampling weight coefficients are assigned to high-density areas to focus the subsequent neighbor sampling operation on topological areas with stronger timeliness. This mechanism optimizes the allocation of sampling resources and improves the timeliness representation capability of the dynamic graph.

[0083] The precision feedback module processes the weight correction instruction sent by the spatio-temporal topology verifier. The relationship type identifier and weight adjustment parameter in the instruction are analyzed, and the corresponding entry of the relationship type weight matrix in the dynamic neighbor sampler is located. The weight parameter of a specific relationship category in the matrix is updated according to the correction amount, and the influence weight of different relationship types in the neighbor sampling process is adjusted. The closed-loop control realizes the real-time optimization of the sampling strategy.

[0084] The resource monitoring module establishes a real-time monitoring mechanism for system memory occupancy rate. The memory usage rate data is periodically obtained through the operating system interface, and is dynamically compared with the preset safety threshold. When it is monitored that the occupancy rate continuously exceeds the threshold, the sampling depth level reduction control is triggered, and the topological range depth of neighbor sampling is reduced to control the memory consumption. After the memory occupancy rate falls back to the safety interval, the original sampling depth level is restored to maintain the calculation precision. The module realizes the dynamic balance between the calculation resources and the model precision.

[0085] The three modules form a cascade control logic: the timing control module determines the priority of the sampling spatio-temporal range, the precision feedback module optimizes the relationship weight parameter based on the topology verification result, and the resource monitoring module ensures that the calculation process runs within the controllable resource boundary. The modules cooperate through data flow and instruction flow, and jointly support the adaptive running mechanism of the dynamic neighbor sampler.

[0086] Specifically, the large-scale knowledge graph construction system based on a graph neural network provided by the application is characterized in that the resource monitoring module is configured to:

[0087] periodically monitor the memory occupancy rate change curve;

[0088] When the memory occupancy rate breaks through the first critical value in two consecutive monitoring periods, the neighbor sampling depth is reduced from the default three levels to two levels;

[0089] When the memory occupancy rate decreases to below the second critical value for three monitoring periods, the sampling depth is restored to three levels;

[0090] When the sampling depth is adjusted and the memory warning of the resource monitoring module is still triggered, the standby buffer area starts the process of allocating to the local subgraph generator.

[0091] The resource monitoring module establishes a periodic memory occupancy rate monitoring mechanism. The memory usage data is collected through a system-level interface at regular intervals, and the occupancy rate change curve is recorded to form a time series. The monitoring frequency is synchronized with the knowledge graph processing window, providing a data basis for dynamic resource regulation.

[0092] When the memory occupancy rate exceeds the first threshold value for two consecutive monitoring periods, the sampling depth degradation strategy is triggered. The neighbor sampling depth is reduced from the default three-level hierarchy to two levels, reducing the recursive sampling range of neighbor nodes. This operation reduces the computational complexity of the local subgraph construction process and controls the memory occupancy level within the safety threshold.

[0093] When the memory occupancy rate drops below the second threshold value and lasts for three monitoring periods, the sampling depth recovery process is started. The neighbor sampling depth is restored from two levels to the default three-level hierarchy, expanding the sampling coverage range of neighbor nodes. This recovery operation must meet the continuous stability condition to prevent memory state fluctuations from causing frequent system switching.

[0094] When the memory warning is still triggered after adjusting the sampling depth, the backup buffer allocation process is executed. A separate memory buffer area is dynamically allocated to the local subgraph generator to isolate the memory usage boundary of the subgraph construction process. This emergency mechanism prevents memory overflow from causing system abnormal termination and maintains the continuity of the knowledge graph construction process.

[0095] The module adopts a hierarchical response strategy: regular monitoring maintains the baseline running state; the first level response controls resource consumption through sampling degradation; the second level response enables isolated cache to ensure system robustness. Each response level is triggered by the trend characteristics of the memory change curve, forming a progressive resource management chain.

[0096] Specifically, the large-scale knowledge graph construction system based on a graph neural network provided by the present application, the time decay coefficient calculation in the local subgraph generator is:

[0097] Get the latest interaction timestamp of the nodes corresponding to the relationship from the historical embedding memory;

[0098] Calculate the time difference between the timestamp and the current system time;

[0099] Map the time difference value to a decay coefficient in the interval (0, 1) through a negative exponential function;

[0100] Multiply the decay coefficient with the original relationship type weight in the relationship weight matrix output by the dynamic neighbor sampler to generate the adjacency matrix weight value.

[0101] The local subgraph generator calls the historical embedding memory to obtain the latest interaction timestamp of the nodes corresponding to the relationship. This timestamp records the time of the last relationship interaction between nodes, representing the timeliness characteristics of the topology connection. The timestamp data is derived from the version snapshot metadata of the historical embedding memory, ensuring that the time reference is synchronized with the global state of the system.

[0102] A difference value is calculated based on the acquired timestamp and the current system time. The system clock is used as the current time reference, and the difference value is calculated to a millisecond level of granularity. The time difference value quantifies the duration interval from the last interaction to the current time, reflecting the degree of temporal decay of the topology connection.

[0103] A time decay coefficient is generated by processing the time difference value through a negative exponential function. The function maps any time difference value to a continuous coefficient interval of 0 to 1, where a smaller time difference corresponds to a higher decay coefficient value, and a larger time difference corresponds to a lower decay coefficient value. The coefficient represents the degree of influence of temporal relevance on the strength of the topology connection.

[0104] The time decay coefficient is fused with the relationship type weight output by the dynamic neighbor sampler. The relationship type weight matrix contains inherent weight parameters for different relationship categories, representing the importance benchmark of relationship semantics. The time decay coefficient acts as a multiplier on the original relationship type weight, generating a fused temporal feature relationship connection weight value.

[0105] The fused weight value is stored as an adjacency matrix element. Each element of the adjacency matrix corresponds to the relationship connection between nodes, and its weight value encodes the importance of relationship type semantics and the temporal influence feature. The matrix serves as a topology structure basis with time decay characteristics and is output to the quantum state aggregator for subsequent feature processing.

[0106] The module realizes a triple logic progression: the timestamp acquisition establishes a temporal benchmark, the time difference value quantifies the decay degree, and the function mapping generates a coefficient value. Finally, through the fusion calculation of the coefficient and the relationship weight, the topology structure and the temporal feature are unified in the adjacency matrix.

[0107] Specifically, the large-scale knowledge graph construction system based on a graph neural network according to the present application, the quantum state aggregator is configured to:

[0108] The amplitude compression unit normalizes and limits the upper limit of the absolute value of the amplitude of the feature vector component returned by the historical embedding memory;

[0109] The quantum circuit loading module loads the parameterized quantum circuit structure of the space-time topology verifier and initializes the entanglement path of the quantum bits;

[0110] The feature fusion unit aggregates the amplitude values of the neighbor nodes through controlled quantum gate operations;

[0111] 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.

[0112] The amplitude compression unit processes the feature vector components returned by the historical embedding memory. A normalization operation is performed on each dimension component of the vector to eliminate the difference in feature scale. An upper threshold value of the absolute value of the amplitude is set, and the component values exceeding the threshold value are truncated to a limited range. This preprocessing prevents numerical overflow in the subsequent quantum state mapping process and ensures the stability of quantum computing.

[0113] The quantum circuit loading module obtains the parameterized quantum circuit structure description issued by the spatio-temporal topology verifier. The number of quantum bits and the sequence of gate operations in the circuit structure are analyzed, and a quantum register of corresponding size is initialized. According to the entanglement path configuration of the circuit description, the entanglement association relationship between quantum bits is established. This process converts the abstract circuit description into an executable quantum computing framework.

[0114] The feature fusion unit performs a quantum state aggregation operation on the neighbor node features. The compressed feature vector components are mapped to quantum bit amplitude values, completing the encoding of classical features into quantum states. The amplitude value entanglement superposition is realized on the quantum circuit through controlled quantum gate operations, generating a quantum superposition state that fuses the neighbor features. This quantum operation simulates the message passing mechanism in a graph neural network.

[0115] The classical space converter processes the quantum state measurement results to realize space inversion. The quantum bits are projected and measured to obtain probability distribution data. An inverse encoding algorithm is used to map the probability distribution back to the classical vector space, reconstructing the node feature representation. The reconstructed node embedding vector is output to the spatio-temporal topology verifier, completing the closed-loop conversion between quantum and classical spaces.

[0116] The module processing flow forms a technical closed loop: amplitude compression ensures input stability; quantum circuit loading establishes a computing framework; feature fusion realizes quantum state information aggregation; classical conversion reconstructs available feature vectors. Each link realizes efficient fusion of graph topology features through quantum states, providing optimized node embeddings for spatio-temporal topology verification.

[0117] Specifically, the large-scale knowledge graph construction system based on a graph neural network according to the present application, the feature distribution difference value calculation in the spatio-temporal topology verifier is:

[0118] 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;

[0119] The quantum feature analyzer converts the node embedding vector output by the quantum state aggregator into a Gaussian mixture distribution model;

[0120] The KL divergence calculation module measures the difference value between the aforementioned multinomial distribution model and the Gaussian mixture distribution model;

[0121] The correction trigger sends a weight correction instruction to the dynamic neighbor sampler and a parameter update instruction to the quantum state aggregator when the KL divergence value exceeds the preset tolerance threshold.

[0122] The adjacency tensor analyzer processes the isolated subgraph structure output by the quantum state aggregator. The structure includes a set of nodes and weighted adjacency relationships. Topological feature parameters in the adjacency tensor are extracted, including node connectivity distribution, edge weight distribution, clustering coefficient, and other high-dimensional features. A discrete multinomial distribution model is constructed based on the extracted topological features to represent the distribution of the topological properties of the subgraph structure.

[0123] The quantum feature analyzer processes the node embedding vector output by the quantum state aggregator. Cluster analysis is performed on the vector set to identify feature distribution patterns, and a continuous Gaussian mixture distribution model is fitted. The model includes multiple Gaussian distribution components and their mixing weight coefficients, describing the probability density distribution state of the node embedding in the feature space.

[0124] The KL divergence calculation module receives the aforementioned multinomial distribution model and the Gaussian mixture distribution model. The KL divergence value between the two probability distribution models is calculated to quantify the difference between the topological feature distribution and the node embedding feature distribution. The divergence value is a unitless scalar, and the numerical value directly reflects the matching degree of the topological structure and the node embedding.

[0125] The correction trigger monitors the real-time value output by the KL divergence calculation module. The divergence value is continuously compared with the preset tolerance threshold. When the divergence value continuously exceeds the tolerance threshold, a weight correction instruction is generated and sent to the dynamic neighbor sampler, and a parameter update instruction is generated and sent to the quantum state aggregator. This process triggers the system to adjust the neighbor sampling strategy and the quantum feature fusion parameters cooperatively.

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

[0127] Specifically, the large-scale knowledge graph construction system based on the graph neural network includes an embedding propagation controller, which includes:

[0128] The change detection unit obtains the last version vector of the node from the historical embedding memory and compares it with the current adjacency vector of the node. The similarity calculation module uses the cosine similarity algorithm to measure the difference between the two vectors.

[0129] The activation determiner adds the node to the active set when the change value output by the similarity calculation module exceeds the set threshold.

[0130] The gradient clipping module linearly adjusts the gradient threshold value according to the node version difference value output by the historical embedding memory.

[0131] The change degree detection unit calls the node historical snapshot data of the historical embedding memory. The embedding vector of the last version of the target node is obtained as a comparison reference, and the current adjacency vector representing the latest topology state is synchronously received. The unit establishes a comparison relationship between the version vector and the real-time vector, providing a data basis for change detection.

[0132] The similarity calculation module processes the vector pair output by the change degree detection unit. The cosine similarity algorithm is used to calculate the direction difference of the two vectors in the feature space, and a similarity scalar value between -1 and 1 is output. The value represents the degree of deviation of the node embedding caused by the change in the topology, and a negative value indicates a significant change in the feature direction.

[0133] The activation determinator receives the change value output by the similarity calculation module. The value is compared with the activation determination threshold value preset by the system in real time. When the change value exceeds the set threshold value, an operation instruction for adding the node to the active set is triggered. The active set dynamically contains a subset of nodes that need to perform gradient update, and controls the focus of computing resources on the key change area.

[0134] The gradient clipping module loads the node version difference value provided by the historical embedding memory. The value quantifies the embedding change amplitude between historical versions through the Euclidean distance. A linear mapping relationship between the version difference value and the gradient threshold value is established, and the gradient clipping threshold value is increased as the difference value increases. This mechanism dynamically controls the gradient update amplitude in the backpropagation process to prevent numerical oscillation in the embedding vector update process.

[0135] The modules form an update control closed loop: change detection identifies key nodes, similarity quantifies the change strength, activation determination selects update targets, and gradient adjustment ensures update stability. Each unit is connected through data flow to realize the directional optimization mechanism of the graph neural network, which improves the incremental update efficiency while maintaining the consistency of global representation.

[0136] Specifically, the gradient clipping module of the large-scale knowledge graph construction system based on the graph neural network dynamically adjusts the rules as follows:

[0137] The embedding propagation controller establishes a positive proportional relationship mapping table between the node version difference value output by the historical embedding memory and the clipping threshold value;

[0138] When the increase amplitude of the current version difference value compared with the last period exceeds 10%, the gradient clipping threshold value is increased by 20% to 50%;

[0139] When the gradient value of the continuous two propagation processes does not exceed the current gradient clipping threshold value, the clipping threshold value is lowered by 10% to 15%.

[0140] The embedding propagation controller maintains a mapping table of node version difference values and gradient clipping threshold values. The table records the node version difference value data output by the historical embedding memory, and the difference value reflects the historical variation amplitude of the node embedding vector. A proportional association model of the difference value and the clipping threshold value is established, and when the difference value increases, the clipping threshold value is correspondingly increased, and when the difference value decreases, the clipping threshold value is correspondingly decreased.

[0141] When it is monitored that the current version difference value increases by more than a preset percentage compared with the previous calculation period, the gradient clipping threshold value adjustment mechanism is triggered. According to the increase ratio, a specific percentage interval is added to the threshold value base to expand the allowed range of gradient update. This adjustment adapts to the state of violent change of the node embedding, and avoids excessive inhibition of effective update.

[0142] When the gradient values recorded by two consecutive graph propagation processes are both lower than the current clipping threshold value, the threshold value adjustment operation is performed. A fixed percentage interval is reduced from the existing threshold value base to reduce the allowed range of gradient update. This adjustment responds to the state of system stability improvement, and enhances the refinement degree of gradient control.

[0143] The adjustment process follows the principle of two-way dynamic balance: when the node changes violently, the gradient constraint is relaxed to ensure the update efficiency, and when the system is stable, the gradient constraint is tightened to improve the precision. The mapping table serves as the core adjustment reference, and the adaptive control is realized through the proportional association of the difference value and the threshold value. The threshold value adjustment operation is embedded between the graph propagation iteration periods to form a closed-loop feedback control mechanism.

[0144] Specifically, the large-scale knowledge graph construction system based on a graph neural network provided by the present application comprises a graph updater, and the graph updater comprises:

[0145] An incremental analysis unit compares new embedding vectors in the set of embedding vectors that pass the secondary verification with old embedding vectors of old nodes stored in the historical embedding memory, and calculates coordinate offsets;

[0146] A transaction packaging module packages the new node vector and the coordinate offset of the old node into an atomic transaction package;

[0147] A log generator records the timestamp of each vector change event and the version dependency chain between nodes;

[0148] A consistency writing module synchronously sends the transaction package and the log to the historical embedding memory through an atomic writing operation.

[0149] The incremental analysis unit processes the set of embedding vectors that pass the secondary verification of the space-time topology verifier. For the old nodes already existing in the historical embedding memory, the corresponding old version embedding vectors are extracted as a comparison reference. The coordinate offset of the new embedding vector and the old vector is calculated, which quantifies the position variation amplitude of the node feature space in the form of vector difference, and reflects the incremental change characteristics of the knowledge graph.

[0150] The transaction encapsulation module receives the new node vector and the old node coordinate offset data. The new node vector is taken as an independent data unit, and the old node offset is taken as a change unit, and is encapsulated into an atomic transaction package structure. The package body design follows the principle of atomic operation, supports full-amount submission or rollback mechanism, and provides basic guarantee for data consistency.

[0151] The log generator tracks the metadata information of the vector change event. The accurate timestamp of the vector change is collected to mark the version time sequence, and the topological dependence relationship between nodes is analyzed to generate a version dependence chain. The relationship chain describes the influence range of the changed node in the knowledge graph, and forms a structured basis for version backtracking.

[0152] The consistency writing module executes the atomized storage operation. The transaction package and the associated log are bound as an indivisible unit, and are transmitted to the historical embedded storage through a synchronous writing protocol. The writing process follows the order of log first and data second, maintains the order and integrity of the transaction operation at the storage layer, and realizes reliable update of the knowledge graph state.

[0153] The module cooperation mechanism embodies three-layer technical logic: incremental analysis extracts core change features, transaction encapsulation constructs atomic operation units, and log recording establishes traceable metadata. Finally, the transaction landing at the storage layer is realized through consistency writing, and the closed-loop control process of dynamic expansion of the knowledge graph is completed. Each link strictly follows the incremental update principle to avoid resource consumption of full recalculation.

[0154] Specifically, the large-scale knowledge graph construction system based on a graph neural network disclosed in the application further comprises:

[0155] The time sequence control closed loop module: the node incremental receiver sends a window boundary time identifier to the historical embedded storage, the historical embedded storage aligns the version snapshot according to the time identifier, the dynamic neighbor sampler samples according to the time sequence density according to the new node timestamp density, and the graph updater generates a version log to update the historical snapshot and triggers the historical embedded storage snapshot coverage;

[0156] The precision adjustment closed loop module: the spatio-temporal topology verifier detects feature distribution difference values, the dynamic neighbor sampler corrects relationship weights in response to weight correction instructions, the quantum state aggregator updates line parameters in response to parameter update instructions, and the spatio-temporal topology verifier verifies the propagation of the corrected embedded vectors again;

[0157] The resource optimization chain module: the dynamic neighbor sampler dynamically adjusts the sampling depth based on the resource monitoring module output, the local subgraph generator calculates the size of the simplified adjacency matrix through a time decay coefficient, and the historical embedded storage reduces memory copy overhead when querying neighbor nodes through pointer calling.

[0158] The time sequence control closed loop module establishes a system level time synchronization mechanism. The node incremental receiver transmits a window boundary time identifier to the historical embedding memory, which marks the time segmentation point of batch processing. The historical embedding memory aligns version snapshots according to the time identifier to ensure that the stored state is strictly synchronized with the data input window. The dynamic neighbor sampler analyzes the time stamp density distribution characteristics of the new node, and enhances the sampling intensity in the time high-density area. The graph updater generates version log record incremental change information to trigger the historical embedding memory to perform snapshot overlay operation, forming a complete time sequence closed loop from data input to storage update.

[0159] The precision adjustment closed loop module implements a feature expression optimization mechanism. The space-time topology verifier continuously detects feature distribution difference values, which reflect the matching deviation of the topology structure and the node embedding. When the deviation exceeds the tolerance range, a weight correction instruction is sent to the dynamic neighbor sampler to adjust the relationship type weight matrix parameters, and a parameter update instruction is sent to the quantum state aggregator to optimize the quantum circuit feature fusion process. The space-time topology verifier performs secondary verification on the modified vector output by the embedding propagation controller, evaluates the improvement effect of parameter adjustment on embedding quality, and forms a feedback closed loop for precision control.

[0160] The resource optimization chain module constructs a multi-level resource management and control system. The dynamic neighbor sampler dynamically adjusts the neighbor sampling depth level based on the real-time memory occupation data of the resource monitoring module to control the size of the topology data. The local subgraph generator calculates the number of effective elements in the adjacency matrix by using a time decay coefficient to reduce the matrix storage and calculation overhead. The historical embedding memory uses a feature vector pointer transfer mechanism when processing neighbor node queries to avoid large-scale vector data copy operations and significantly reduce memory bandwidth consumption. The three-level optimization measures form a resource optimization chain from sampling control, matrix simplification to storage scheduling.

[0161] The present application deeply couples data flow and control flow: the time sequence closed loop provides a time reference framework for precision adjustment, the resource optimization chain provides resource guarantee for the calculation process, and the precision adjustment output feedbacks to the time sequence control to update the storage state. The system realizes the balance control of precision, efficiency and resource consumption in the dynamic construction process of the knowledge graph through the modular collaborative architecture.

[0162] The present application systematically reduces the consumption of computing resources through a triple synergy mechanism. The node incremental receiver uses fixed time window batch processing of new nodes to avoid fragmented computing overhead generated by stream updating. The historical embedding memory reuses historical embedding vectors through version snapshot to eliminate full node repeated calculation. The dynamic neighbor sampler dynamically allocates sampling resources according to the time stamp density to reduce the computing load in the low value area. The time sequence control closed loop realizes the intensive scheduling of computing resources.

[0163] The precision adjustment mechanism suppresses invalid computation cycles. The spatiotemporal topology verifier detects the difference between the topology and the embedded feature distribution, and the dynamic neighbor sampler corrects the relationship weight matrix accordingly. The quantum state aggregator synchronously updates the fusion parameters, forming an adaptive feature optimization closed loop. This mechanism only triggers parameter updates when significant deviations are detected, avoiding the resource consumption of continuous full-graph retraining; the embedding propagation controller freezes the gradient calculation of non-active nodes, further focusing the computing resources on the key change area.

[0164] The resource optimization chain realizes multi-dimensional compression. The dynamic neighbor sampler dynamically shrinks the sampling depth based on memory occupancy, reducing the complexity of neighborhood search; the local subgraph generator compresses the size of the adjacency matrix effective elements through a time decay coefficient; the historical embedding memory uses a pointer call mechanism to eliminate vector copy overhead. Multi-level optimization forms a joint computing-storage pressure relief path, controlling the cascading growth of resource consumption generated by the iterative process of the graph neural network 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 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.

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