Structured data self-learning method based on graph neural network

Abstract

The invention discloses a structured data self-learning method based on a graph neural network, and the method comprises the following steps: S1, analyzing structured data, extracting entity fields and relation fields, and constructing a structure candidate graph; s2, generating a node embedding feature matrix, and initializing and recording the adjacency relation of candidate edges; s3, constructing a graph neural network model, inputting node features and an adjacent matrix, and defining a task loss function; s4, evaluating the gradient contribution degree of edge connection by adopting a gradient sensitive sparse adjacency self-learning algorithm, and updating the graph structure representation; s5, introducing an embedded interpretability gradient backtracking mechanism, correcting an edge connection relation and enhancing interpretability; s6, training the graph neural network by using the corrected structure, and updating the node embedding and graph structure; and S7, outputting a final graph structure and an interpretability index, and generating a graph modeling visualization result. According to the method, efficient modeling and explanatory analysis of structured data are realized through a dynamic graph structure learning and gradient backtracking mechanism.

Description

Technical Field

[0001] The present invention relates to the field of graph neural network technology, and in particular to a structured data self-learning method based on graph neural network. Background Art

[0002] In recent years, graph neural networks (GNNs) have demonstrated significant advantages in processing complex structured data, becoming a key model in key areas such as recommendation systems, knowledge graphs, and financial risk management. Constructing high-quality graph structures to support downstream learning tasks in structured data, crucial for the effectiveness of GNN applications, is crucial. In practical scenarios where graph priors are lacking, graph construction relies on a data-driven approach, placing higher demands on the self-learning and interpretability of graph structures.

[0003] Existing graph structure construction methods primarily rely on manually defined rules or heuristic strategies to transform structured data into graph models. While feasible in specific domains, these methods face numerous limitations in the context of diverse data types and complex task requirements. First, traditional methods lack task adaptability to graph structures and are unable to dynamically filter and optimize edge connections based on learning objectives. This can easily introduce redundant or noisy information, impacting learning outcomes. Second, the adjacency matrix of graph neural networks is typically trained as a static input, failing to implement feedback updates during training, limiting the model's ability to deeply understand data structures. Third, current methods mostly focus on node feature propagation and lack the means to interpret the graph structure formation mechanism from task outputs. This results in insufficient transparency and poor interpretability in practical applications. Fourth, after structure learning is completed, many methods fail to provide visualization tools or explanatory metrics, hindering the further application of model results in analytical decision-making.

[0004] Furthermore, traditional graph modeling approaches struggle to handle large-scale, heterogeneous structured data. In scenarios involving multiple entity types and relationships, the graph's topology is complex and the data is high-dimensional. Without effective structural selection and pruning mechanisms, this can easily lead to wasted computing resources and performance degradation. While some current research attempts to enhance structural perception by introducing attention mechanisms or gradient signals, significant room for improvement remains in terms of accuracy control, structural robustness, and interpretability.

[0005] Therefore, how to provide a structured data self-learning method based on graph neural networks is an urgent problem that those skilled in the art need to solve. Summary of the Invention

[0006] One purpose of the present invention is to propose a structured data self-learning method based on graph neural network. The present invention makes full use of node embedding modeling, gradient-driven sparse adjacency structure learning algorithm and embedding interpretability backtracking mechanism, and describes in detail the whole process of automatically constructing graph structure and realizing high-quality interpretable modeling in the absence of graph prior conditions. It has the advantages of strong structural adaptability, precise edge connection selection, high result interpretability and support for visual output.

[0007] A structured data self-learning method based on a graph neural network according to an embodiment of the present invention includes the following steps:

[0008] S1. Parse structured data, extract entity fields to build a node set of the graph neural network, extract relationship fields to generate a candidate edge set, and build a structure candidate graph;

[0009] S2. Generate a node embedding feature matrix based on the node set, initialize the adjacency matrix to be empty and bind it to the candidate edge position in the structure candidate graph;

[0010] S3. Build a graph neural network model, take the node embedding feature matrix and adjacency matrix as input, and define the task loss function;

[0011] S4. Based on the gradient-sensitive sparse adjacency self-learning algorithm, calculate the second-order gradient contribution of the candidate edge-connected node pairs to the task loss function, update the edge connection relationship and edge weight values ​​in the adjacency matrix, and generate the initial graph structure representation;

[0012] S5. Based on the initial graph structure representation, an embedding interpretable gradient backtracking mechanism is executed to construct a gradient path from the node embedding feature to the task loss function and backtrack to the edge connection relationship. The explanatory gradient weights of the edge connection are extracted and written into the adjacency matrix, completing the structural modification of the graph neural network adjacency matrix.

[0013] S6. Use the corrected adjacency matrix and node embedding feature matrix to perform graph neural network training and update the node embedding vector and graph structure representation;

[0014] S7. After training convergence, extract the final edge connection relationship and corresponding explanatory gradient weight in the adjacency matrix, output the graph structure representation and explanatory indicator set, and generate graph modeling visualization results.

[0015] This paper proposes a structured data self-learning method based on graph neural networks, which constructs a complete process from data parsing, graph structure initialization, edge weight learning to structure correction and visualization output. The method generates nodes and candidate edge sets by parsing structured data, initializes embedded features and adjacency matrix, and constructs a graph neural network model. It combines the gradient-sensitive sparse algorithm to dynamically optimize the edge connection structure, and further introduces the embedded interpretable gradient backtracking mechanism to correct the adjacency matrix and improve structural transparency. Finally, through training convergence, the explanatory graph structure and visualization results are output, achieving the unity of adaptability and interpretability of structural modeling, enhancing the expressive power and practical application value of the model.

[0016] Optionally, the S1 specifically includes:

[0017] S11. Perform field parsing on the structured data, identifying fields in the structured data used to represent specific objects as entity fields, and identifying fields used to represent relationships between objects as relationship fields;

[0018] S12. Based on the field value of the entity field, perform a one-to-one mapping operation on each type of entity object, mapping each unique entity field value to a node in the graph neural network, where the mapping rule is: divide the node type according to the field type to which the entity field belongs, assign the node index number based on the deduplication result of the field value, and generate a node set of the graph neural network;

[0019] S13. Parse the relationship fields. For each structured data record, extract the corresponding relationship between two or more entity fields. Generate a set of candidate edge relationships based on the permutation results of the entity field combinations in the record, and establish an edge connection mapping. Each candidate edge connects two nodes in the node set, forming a candidate edge set.

[0020] S14. Assign an initial connection direction and an initial edge weight value to each candidate edge in the candidate edge set. The initial connection direction is determined according to a preset directionality field in the relationship field. The initial edge weight value can be set to a default constant or a result of a numeric field in the relationship field.

[0021] S15. Construct a structure candidate graph based on the node set and the candidate edge set, wherein a graph topology of the structure candidate graph is composed of nodes in the node set and edges in the candidate edge set, and all connection relationships in the graph structure are stored in the form of adjacency pairs;

[0022] S16. Perform a structural consistency check on the candidate structure graph, remove candidate edges that fail to match valid node numbers, delete isolated nodes with no edge connections in the node set, and complete the construction of the candidate structure graph that meets the training requirements of the graph neural network.

[0023] This paper proposes a graph construction mechanism within a self-learning method for structured data based on graph neural networks, establishing a complete automated graph construction process from field parsing, node and edge generation, to structural consistency verification. This effectively addresses the issues of existing structured data graph modeling, such as structural reliance on manual rules, inaccurate topology, and low construction efficiency. This method uniquely maps entity field values ​​to graph nodes by identifying entity and relationship fields, generates candidate edge relationships based on field combinations, and automatically assigns connection directions and initial edge weights. Furthermore, it combines structural consistency checks to eliminate abnormal connections and isolated nodes, ultimately constructing high-quality candidate structural graphs that meet the training requirements of graph neural networks.

[0024] Optionally, the S2 specifically includes:

[0025] S21. Perform a field feature collection operation on each node in the node set of the graph neural network, extract all entity field values ​​corresponding to the target node in the node set of the graph neural network from the structured data, and arrange them in a preset field order to form a node feature vector template;

[0026] S22. Numerically encode all field values ​​in the node feature vector template, keep the numeric fields in their original numeric form, convert the categorical fields into discrete integer indexes, and then uniformly convert them into fixed-dimensional numeric vectors to generate an embedded vector representation of each node in the node set of the graph neural network.

[0027] S23. Arrange the embedding vectors of all nodes in the node set of the graph neural network in order according to the node index numbers to form a node embedding feature matrix;

[0028] S24. Construct an adjacency matrix of the graph neural network, and initialize the adjacency matrix of the graph neural network to a matrix with element values ​​of zero;

[0029] S25. Traverse the candidate edge set in the structure candidate graph, read the start node index and the end node index connected to each candidate edge in the structure candidate graph, and record the row index corresponding to the start node index and the column index corresponding to the end node index in the adjacency matrix of the graph neural network as the candidate edge connection position;

[0030] S26. Input the node embedding feature matrix and the adjacency matrix of the completed candidate edge connection position records into the graph neural network.

[0031] The present invention realizes the automatic construction of the input structure of the graph neural network by establishing a set of node feature extraction and embedding initialization processes based on structured data. Specifically, it includes extracting the entity field value of each node from the structured data, forming a feature template and performing numerical encoding, generating a node embedding vector of fixed dimension, and constructing an embedding feature matrix according to the node number. At the same time, the system initializes the zero-value adjacency matrix, completes the connection position annotation through the candidate edge index, and finally inputs the node features and structural information into the graph neural network together. This method improves the adaptability of the graph neural network to structured data, ensures the consistency of feature expression and the accuracy of graph structure initialization.

[0032] Optionally, the S3 specifically includes:

[0033] S31. Construct a graph neural network model, which includes an input layer, a graph convolution calculation layer of the graph neural network, and an output layer. The input of the graph neural network model includes a node embedding feature matrix of the graph neural network and an adjacency matrix of the graph neural network.

[0034] S32. Input the node embedding feature matrix of the graph neural network as input features and the adjacency matrix of the graph neural network as structural constraints into the graph convolution computation layer of the graph neural network model. Perform feature propagation, adjacency feature aggregation, and node embedding update operations in the graph convolution computation layer to obtain the predicted embedding representation of the graph neural network output layer.

[0035] S33. Probabilistic mapping is performed on the embedding vector of each target node in the output layer of the graph neural network. The output value of each dimension in the embedding vector is nonlinearly transformed according to an exponential function. The transformation results of all dimensions are normalized so that the output value of each dimension occupies a relative proportion in the sum of all dimensions, thereby obtaining the predicted probability distribution of the target node in each category. The sum of the predicted probabilities of each category is 1, forming a normalized probability vector.

[0036] S34. Based on the difference between the predicted probability distribution of the output layer of the graph neural network and the supervision label, the task loss function of the graph neural network is defined as:

[0037]

[0038] Among them, n represents the number of target nodes of the graph neural network participating in the supervised training, C represents the total number of classification categories, and y ic represents the true label of the i-th target node in the c-th category in the graph neural network, represents the predicted probability of the i-th target node in the c-th category.

[0039] The present invention constructs a graph neural network model including an input layer, a graph convolution layer, and an output layer, takes the node embedding feature matrix as the input feature, and the adjacency matrix as the structural constraint, guides the model to realize feature propagation and adjacency feature aggregation in the graph convolution process, and outputs the updated node embedding representation. The target node embedding is then nonlinearly transformed and normalized to generate the predicted probability distribution of each category, and the difference between it and the true label is defined as the cross-entropy loss function. This method improves the model's expressive power and classification accuracy for node representation, realizes the deep integration of structural perception and label supervision, and enhances the trainability and task adaptability of the graph model.

[0040] Optionally, the S4 specifically includes:

[0041] S41. After the graph neural network model completes a round of forward propagation and calculates the task loss function based on the node embedding feature matrix and the adjacency matrix, for each candidate edge in the structural candidate graph, the index positions of the starting node and the ending node connected to it in the node embedding feature matrix are extracted, and the node embedding vector pair corresponding to the candidate edge is constructed;

[0042] S42, based on the node embedding vector pairs connected by the candidate edges, the task loss function is trained by the gradient sensitive sparse adjacency self-learning algorithm. To calculate the second-order partial derivative contribution of the node pair, the block diagonal Hessian approximation strategy is adopted and the calculation process is defined as follows:

[0043] Constructing node embedding vector sets for graph neural networks Where n is the number of nodes in the node set of the graph neural network, and d is the dimension of the embedding vector of each node;

[0044] For the node pair (i, j) connected by the candidate edge, approximately calculate its second-order gradient contribution in the loss function:

[0045]

[0046] in, are the embedding vectors of node i and node j respectively, Indicates the second-order gradient contribution of the candidate edge (i, j) to the task loss function in the t-th round of training;

[0047] S43, using the sliding average strategy Smoothing is performed to suppress training fluctuation interference and enhance the stability of adjacent structure evolution. The update formula is as follows:

[0048]

[0049] Among them, α∈(0,1) is the sliding control factor,

[0050] S44, smoothed contribution value of all outgoing edges corresponding to each node in the node set of the graph neural network Perform sorting, retain the top k candidate edges with the highest gradient contributions, normalize the gradient values ​​in the sorting results to the interval [0, 1], and write them to the corresponding edge positions in the adjacency matrix to form the initial graph structure representation of the current round;

[0051] S45. Set the adjacency matrix pruning threshold θ t =θ0·exp(-λt), where θ0 is the initial pruning threshold, λ is the threshold exponential decay coefficient, and t represents the current training round. t The edges of are removed to form a sparse structure;

[0052] S46. Input the node embedding feature matrix and sparse structure of the graph neural network into the graph neural network model, perform a complete forward propagation operation, and obtain the intermediate node embedding representation of the graph neural network model under the current structural configuration as the output of the current round of graph structure learning;

[0053] S47, based on the current round of intermediate node embedding representation and the edge connection weight information retained in the adjacency matrix, construct a graph structure triple set (i, j, a ij ), where i and j represent the connection node index, a ij ∈[0,1] represents the edge connection strength, and combined with the node embedding feature matrix of the graph neural network, the initial graph structure representation G0=(V,E0,X) is generated, where V is the node set of the graph neural network, E0 is the candidate edge set obtained by gradient-driven screening, and X is the node embedding feature matrix.

[0054] The present invention realizes dynamic optimization and sparse modeling of graph structure by introducing a gradient-sensitive sparse adjacency self-learning algorithm. After the model is forward propagated, the node embedding vector pairs connected by the candidate edges are extracted, and the block diagonal Hessian approximation is used to calculate the second-order gradient contribution to the task loss, and the contribution value is smoothed by the sliding average strategy to stabilize the training process. Subsequently, the outgoing edges of each node are sorted, the high-contribution edges are retained and normalized and written into the adjacency matrix, and the exponential decay pruning threshold is set to remove weak edges to generate a sparse graph structure. This structure and the node features are jointly input into the graph neural network to perform a new round of propagation, and finally a graph structure triple set with strong interpretability, sparseness and efficiency is constructed. This method effectively improves the adaptability and representation quality of the graph structure to the task objectives, and enhances the learnability, robustness and interpretability of the model.

[0055] Optionally, the S5 specifically includes:

[0056] S51. Take the adjacency matrix and node embedding feature matrix in the initial graph structure representation as input, perform a round of forward propagation of the graph neural network model, and obtain the prediction results and task loss function of each supervision node.

[0057] S52. Construct an embedded interpretable gradient backtracking mechanism, including the following operations:

[0058] For each target node participating in supervised training in the graph neural network, the loss function Starting from its corresponding node embedding vector h i Find the first-order gradient, denoted as

[0059] by As the starting gradient signal, it backpropagates the gradient along each layer of the neural computation graph in the graph structure, calculates the explanatory gradient transfer amount of all edges on the path connecting to the target node through the chain rule, and constructs the gradient propagation path from the target node embedding vector to the edge connection path;

[0060] S53. For each edge connection (i, j), count its frequency and contribution gradient value in all target node backtracking paths, and perform explanatory gradient contribution aggregation, which is defined as:

[0061]

[0062] Among them, r ij represents the cumulative explanatory weight of edge (i, j), n sup Indicates the number of supervisory nodes, Represents the loss function component of the lth supervisory node;

[0063] S54, explanatory weight r for all edge connections ij Perform normalization and use the normalized gradient weights Replace the edge weights of the original positions in the adjacency matrix to form an explanatory driving structure correction matrix;

[0064] S55, re-inputting the updated explanatory driving structure correction matrix and the node embedding feature matrix into the graph neural network model, and inputting the update after completing one structural correction;

[0065] S56. Connect all edges (i, j) in the current adjacency matrix to their corresponding explanatory gradient weights Export together.

[0066] The present invention realizes the semantic enhancement and interpretability optimization of the graph neural network structure by constructing an embedded interpretable gradient backtracking mechanism. Specifically, it takes the initial graph structure and node embedding as input, calculates the first-order gradient of the supervisory node, traces back the gradient path from the loss function and propagates it to the edge connection based on the chain rule, counts the frequency of occurrence and gradient contribution of each edge in all paths, aggregates to form the explanatory weight of the edge, and replaces the original adjacency matrix weight by normalization to generate a structural correction matrix. After the structure and the embedded features jointly update the graph model, the explanatory edge weight set is output. This method enhances the task relevance and transparency of the graph structure, and improves the interpretability and structural expression ability of the model.

[0067] Optionally, the S6 specifically includes:

[0068] S61. Take the adjacency matrix of the graph neural network modified by the embedded interpretable gradient backtracking mechanism and the node embedding feature matrix of the graph neural network as input at the same time to construct the current round computation graph of the graph neural network model;

[0069] S62. For each node of the graph neural network in the current round of computation, based on the edge connection relationship defined in the adjacency matrix, collect its embedded features from adjacent nodes, and form a new round of embedded feature input values ​​for the node through linear combination and normalization.

[0070] S63. Perform a matrix multiplication operation on the new embedded feature input value of each node and the weight parameters of each graph convolution layer in the graph neural network model, and combine it with a nonlinear activation function to generate a node output embedded feature vector of the current layer of the graph neural network model;

[0071] S64. Repeat the feature propagation and transformation operations on each graph convolutional layer in the graph neural network model until all network layers complete the calculation, and obtain the node embedding vector representation of the final output layer;

[0072] S65. Calculate the loss function value based on the embedded vector representation of all nodes in the output layer of the graph neural network and the preset supervision labels, using the loss calculation method corresponding to the target task;

[0073] S66. Based on the calculated loss function value, perform backpropagation operation on the parameters of the graph neural network model, update the weight parameters in each graph convolution layer, and record and save the node embedding feature matrix and adjacency matrix status of the current round.

[0074] The present invention constructs the current round calculation graph of the graph neural network based on the corrected adjacency matrix and node embedding features, performs multi-layer graph convolution calculations and node feature updates, and realizes structure-driven graph model training optimization. Specifically, it includes feature aggregation and normalization according to the adjacency relationship, performs linear transformation and nonlinear activation in combination with the network layer weights, propagates layer by layer and finally outputs the node embedding representation; then calculates the task loss between the prediction result and the supervision label, and optimizes the parameters of each layer through backpropagation, while recording the current structure and feature status. This method realizes efficient learning of graph neural networks under structure guidance, enhances the model's expressiveness and structural dynamic adaptability.

[0075] Optionally, the S7 specifically includes:

[0076] S71. After the graph neural network model completes all training rounds and the loss function value converges and stabilizes, extract the adjacency matrix and node embedding feature matrix obtained from the final training, read all non-zero edge connection relationships in the adjacency matrix, and construct a final edge connection relationship set;

[0077] S72. In the final edge connection relationship set, for each edge connection (i, j), extract the edge weight in its adjacency matrix and define it as the final explanatory gradient weight of the edge connection Construct a set of structural descriptions consisting of edge connections and corresponding explanatory weights;

[0078] S73, perform normalization operation on the explanatory gradient weight set, and all Map to the interval [0,1] and construct a graph structure to represent the triple set The edge set description as the output of the final graph neural network structure;

[0079] S74. Define a graph modeling visualization control parameter set, including edge threshold control parameters, color mapping control parameters, and node embedding projection dimension parameters, for controlling edge display, weight coloring, and low-dimensional embedding space generation during graph structure display.

[0080] S75. Based on the control parameter, remove edges whose edge weights in the graph structure triple set are lower than a threshold value, and retain significant connection relationships.

[0081] S76. Based on the node embedding vector matrix of the final output layer of the graph neural network, perform a low-dimensional projection operation and use principal component analysis to map the high-dimensional embedding vector to a two-dimensional or three-dimensional coordinate space to construct a node visualization layout.

[0082] S77. Based on the edge connection strength and control parameters, the edge color and transparency mapping rules in the graph structure are generated. Finally, the node layout, edge connection relationship and explanatory gradient weight are output to the graph modeling visualization module to generate a structural interpretable graphical display result.

[0083] The present invention extracts the final adjacency matrix and node embedding features after the graph neural network training converges, constructs a set of structural descriptions of edge connections and corresponding explanatory weights, and performs normalization on them to generate a standardized graph structure triple representation. At the same time, the graph modeling visualization control parameters are set to remove the part with edge weights below the threshold, and the node embedding is low-dimensionally projected based on the principal component analysis method to generate a visual layout; the color and transparency mapping is completed in combination with the edge weight strength, and the final output is a structural graphical display result containing node positions, edge connections and explanatory gradients. This method realizes the visualization and interpretability of the graph neural network structure learning process, and enhances the intuitiveness, transparency and analytical value of the model output.

[0084] The beneficial effects of the present invention are:

[0085] This paper introduces a gradient-sensitive sparse adjacency self-learning algorithm for the structured data graph modeling task for the first time. By calculating the second-order gradient contribution of candidate edges to the task loss function, it achieves dynamic screening, weighting, and pruning of edge connections. Combining a sliding average with an exponential decay strategy, it forms an edge stabilization mechanism for structural evolution, effectively suppressing noise interference caused by training fluctuations while also improving the sparsity and stability of graph structure evolution. This mechanism significantly differs from existing methods that rely on static structural input or heuristic rule-based graph construction, and possesses stronger task-driven structural optimization capabilities.

[0086] At the graph structure interpretation level, this paper constructs an embedded interpretable gradient backtracking mechanism. Starting from the supervised task loss function, it reversely traces the gradient transfer path between the target node and its associated edges, extracts the explanatory gradient contribution of the connection relationship, and generates an interpretive correction matrix for edge weights, ultimately achieving semantic enhancement and transparent expression of the graph structure. This mechanism effectively compensates for the shortcomings of existing graph neural networks in structural transparency and result interpretability, enhancing the model's usability and trustworthiness in practical application scenarios.

[0087] During the training and output phases, the present invention uses a structurally modified adjacency matrix and node embedding as input to a graph neural network model. After iterative training, the model extracts the final structural results and edge weight interpretation metrics, further generating a 3D visualization of the graph modeling results. Combined with adjustable edge thresholds and color mapping parameters, the modeling results support interactive visualization and analysis across multiple dimensions, demonstrating excellent potential for engineering integration. BRIEF DESCRIPTION OF THE DRAWINGS

[0088] The accompanying drawings are used to provide a further understanding of the present invention and constitute a part of the specification. Together with the embodiments of the present invention, they are used to explain the present invention and do not constitute a limitation of the present invention. In the accompanying drawings:

[0089] Figure 1 This is a flowchart of a structured data self-learning method based on graph neural network proposed by the present invention;

[0090] Figure 2 This is a processing flow chart of the gradient-sensitive sparse neighboring self-learning algorithm proposed in the present invention;

[0091] Figure 3 Schematic diagram of the embedded interpretable gradient backtracking mechanism proposed in this invention. DETAILED DESCRIPTION

[0092] The present invention will now be described in further detail with reference to the accompanying drawings, which are simplified schematic diagrams that illustrate the basic structure of the present invention in a schematic manner.

[0093] refer to Figure 1-3 , a structured data self-learning method based on graph neural network, comprising the following steps:

[0094] S1. Parse structured data, extract entity fields to build a node set of the graph neural network, extract relationship fields to generate a candidate edge set, and build a structure candidate graph;

[0095] S2. Generate a node embedding feature matrix based on the node set, initialize the adjacency matrix to be empty and bind it to the candidate edge position in the structure candidate graph;

[0096] S3. Build a graph neural network model, take the node embedding feature matrix and adjacency matrix as input, and define the task loss function;

[0097] S4. Based on the gradient-sensitive sparse adjacency self-learning algorithm, calculate the second-order gradient contribution of the candidate edge-connected node pairs to the task loss function, update the edge connection relationship and edge weight values ​​in the adjacency matrix, and generate the initial graph structure representation;

[0098] S5. Based on the initial graph structure representation, an embedding interpretable gradient backtracking mechanism is executed to construct a gradient path from the node embedding feature to the task loss function and backtrack to the edge connection relationship. The explanatory gradient weights of the edge connection are extracted and written into the adjacency matrix, completing the structural modification of the graph neural network adjacency matrix.

[0099] S6. Use the corrected adjacency matrix and node embedding feature matrix to perform graph neural network training and update the node embedding vector and graph structure representation;

[0100] S7. After training convergence, extract the final edge connection relationship and corresponding explanatory gradient weight in the adjacency matrix, output the graph structure representation and explanatory indicator set, and generate graph modeling visualization results.

[0101] In this embodiment, S1 specifically includes:

[0102] S11. Perform field parsing on the structured data, identifying fields in the structured data used to represent specific objects as entity fields, and identifying fields used to represent relationships between objects as relationship fields;

[0103] S12. Based on the field value of the entity field, perform a one-to-one mapping operation on each type of entity object, mapping each unique entity field value to a node in the graph neural network, where the mapping rule is: divide the node type according to the field type to which the entity field belongs, assign the node index number based on the deduplication result of the field value, and generate a node set of the graph neural network;

[0104] S13. Parse the relationship fields. For each structured data record, extract the corresponding relationship between two or more entity fields. Generate a set of candidate edge relationships based on the permutation results of the entity field combinations in the record, and establish an edge connection mapping. Each candidate edge connects two nodes in the node set, forming a candidate edge set.

[0105] S14. Assign an initial connection direction and an initial edge weight value to each candidate edge in the candidate edge set. The initial connection direction is determined according to a preset directionality field in the relationship field. The initial edge weight value can be set to a default constant or a result of a numeric field in the relationship field.

[0106] S15. Construct a structure candidate graph based on the node set and the candidate edge set, wherein a graph topology of the structure candidate graph is composed of nodes in the node set and edges in the candidate edge set, and all connection relationships in the graph structure are stored in the form of adjacency pairs;

[0107] S16. Perform a structural consistency check on the candidate structure graph, remove candidate edges that fail to match valid node numbers, delete isolated nodes with no edge connections in the node set, and complete the construction of the candidate structure graph that meets the training requirements of the graph neural network.

[0108] In this embodiment, S2 specifically includes:

[0109] S21. Perform a field feature collection operation on each node in the node set of the graph neural network, extract all entity field values ​​corresponding to the target node in the node set of the graph neural network from the structured data, and arrange them in a preset field order to form a node feature vector template;

[0110] S22. Numerically encode all field values ​​in the node feature vector template, keep the numeric fields in their original numeric form, convert the categorical fields into discrete integer indexes, and then uniformly convert them into fixed-dimensional numeric vectors to generate an embedded vector representation of each node in the node set of the graph neural network.

[0111] S23. Arrange the embedding vectors of all nodes in the node set of the graph neural network in order according to the node index numbers to form a node embedding feature matrix;

[0112] S24. Construct an adjacency matrix of the graph neural network, and initialize the adjacency matrix of the graph neural network to a matrix with element values ​​of zero;

[0113] S25. Traverse the candidate edge set in the structure candidate graph, read the start node index and the end node index connected to each candidate edge in the structure candidate graph, and record the row index corresponding to the start node index and the column index corresponding to the end node index in the adjacency matrix of the graph neural network as the candidate edge connection position;

[0114] S26. Input the node embedding feature matrix and the adjacency matrix of the completed candidate edge connection position records into the graph neural network.

[0115] In this embodiment, S3 specifically includes:

[0116] S31. Construct a graph neural network model, which includes an input layer, a graph convolution calculation layer of the graph neural network, and an output layer. The input of the graph neural network model includes a node embedding feature matrix of the graph neural network and an adjacency matrix of the graph neural network.

[0117] S32. Input the node embedding feature matrix of the graph neural network as input features and the adjacency matrix of the graph neural network as structural constraints into the graph convolution computation layer of the graph neural network model. Perform feature propagation, adjacency feature aggregation, and node embedding update operations in the graph convolution computation layer to obtain the predicted embedding representation of the graph neural network output layer.

[0118] S33. Probabilistic mapping is performed on the embedding vector of each target node in the output layer of the graph neural network. The output value of each dimension in the embedding vector is nonlinearly transformed according to an exponential function. The transformation results of all dimensions are normalized so that the output value of each dimension occupies a relative proportion in the sum of all dimensions, thereby obtaining the predicted probability distribution of the target node in each category. The sum of the predicted probabilities of each category is 1, forming a normalized probability vector.

[0119] S34. Based on the difference between the predicted probability distribution of the output layer of the graph neural network and the supervision label, the task loss function of the graph neural network is defined as:

[0120]

[0121] Among them, n represents the number of target nodes of the graph neural network participating in the supervised training, C represents the total number of classification categories, and y ic represents the true label of the i-th target node in the c-th category in the graph neural network, represents the predicted probability of the i-th target node in the c-th category.

[0122] In this embodiment, the S4 specifically includes:

[0123] S41. After the graph neural network model completes a round of forward propagation and calculates the task loss function based on the node embedding feature matrix and the adjacency matrix, for each candidate edge in the structural candidate graph, the index positions of the starting node and the ending node connected to it in the node embedding feature matrix are extracted, and the node embedding vector pair corresponding to the candidate edge is constructed;

[0124] S42, based on the node embedding vector pairs connected by the candidate edges, the task loss function is trained by the gradient sensitive sparse adjacency self-learning algorithm. To calculate the second-order partial derivative contribution of the node pair, the block diagonal Hessian approximation strategy is adopted and the calculation process is defined as follows:

[0125] Constructing node embedding vector sets for graph neural networks Where n is the number of nodes in the node set of the graph neural network, and d is the dimension of the embedding vector of each node;

[0126] For the node pair (i, j) connected by the candidate edge, approximately calculate its second-order gradient contribution in the loss function:

[0127]

[0128] in, are the embedding vectors of node i and node j respectively, Indicates the second-order gradient contribution of the candidate edge (i, j) to the task loss function in the t-th round of training;

[0129] S43, using the sliding average strategy Smoothing is performed to suppress training fluctuation interference and enhance the stability of adjacent structure evolution. The update formula is as follows:

[0130]

[0131] Among them, α∈(0,1) is the sliding control factor,

[0132] S44, smoothed contribution value of all outgoing edges corresponding to each node in the node set of the graph neural network Perform sorting, retain the top k candidate edges with the highest gradient contributions, normalize the gradient values ​​in the sorting results to the interval [0, 1], and write them to the corresponding edge positions in the adjacency matrix to form the initial graph structure representation of the current round;

[0133] S45. Set the adjacency matrix pruning threshold θ t =θ0·exp(-λt), where θ0 is the initial pruning threshold, λ is the threshold exponential decay coefficient, and t represents the current training round. t The edges of are removed to form a sparse structure;

[0134] S46. Input the node embedding feature matrix and sparse structure of the graph neural network into the graph neural network model, perform a complete forward propagation operation, and obtain the intermediate node embedding representation of the graph neural network model under the current structural configuration as the output of the current round of graph structure learning;

[0135] S47, based on the current round of intermediate node embedding representation and the edge connection weight information retained in the adjacency matrix, construct a graph structure triple set (i, j, a ij ), where i and j represent the connection node index, a ij ∈[0,1] represents the edge connection strength, and combined with the node embedding feature matrix of the graph neural network, the initial graph structure representation G0=(V,E0,X) is generated, where V is the node set of the graph neural network, E0 is the candidate edge set obtained by gradient-driven screening, and X is the node embedding feature matrix.

[0136] In this embodiment, the S5 specifically includes:

[0137] S51. Take the adjacency matrix and node embedding feature matrix in the initial graph structure representation as input, perform a round of forward propagation of the graph neural network model, and obtain the prediction results and task loss function of each supervision node.

[0138] S52. Construct an embedded interpretable gradient backtracking mechanism, including the following operations:

[0139] For each target node participating in supervised training in the graph neural network, the loss function Starting from its corresponding node embedding vector h i Find the first-order gradient, denoted as

[0140] by As the starting gradient signal, it backpropagates the gradient along each layer of the neural computation graph in the graph structure, calculates the explanatory gradient transfer amount of all edges on the path connecting to the target node through the chain rule, and constructs the gradient propagation path from the target node embedding vector to the edge connection path;

[0141] S53. For each edge connection (i, j), count its frequency and contribution gradient value in all target node backtracking paths, and perform explanatory gradient contribution aggregation, which is defined as:

[0142]

[0143] Among them, r ij represents the cumulative explanatory weight of edge (i, j), n sup Indicates the number of supervisory nodes, Represents the loss function component of the lth supervisory node;

[0144] S54, explanatory weight r for all edge connections ij Perform normalization and use the normalized gradient weights Replace the edge weights of the original positions in the adjacency matrix to form an explanatory driving structure correction matrix;

[0145] S55, re-inputting the updated explanatory driving structure correction matrix and the node embedding feature matrix into the graph neural network model, and inputting the update after completing one structural correction;

[0146] S56. Connect all edges (i, j) in the current adjacency matrix to their corresponding explanatory gradient weights Export together.

[0147] In this embodiment, S6 specifically includes:

[0148] S61. Take the adjacency matrix of the graph neural network modified by the embedded interpretable gradient backtracking mechanism and the node embedding feature matrix of the graph neural network as input at the same time to construct the current round computation graph of the graph neural network model;

[0149] S62. For each node of the graph neural network in the current round of computation, based on the edge connection relationship defined in the adjacency matrix, collect its embedded features from adjacent nodes, and form a new round of embedded feature input values ​​for the node through linear combination and normalization.

[0150] S63. Perform a matrix multiplication operation on the new embedded feature input value of each node and the weight parameters of each graph convolution layer in the graph neural network model, and combine it with a nonlinear activation function to generate a node output embedded feature vector of the current layer of the graph neural network model;

[0151] S64. Repeat the feature propagation and transformation operations on each graph convolutional layer in the graph neural network model until all network layers complete the calculation, and obtain the node embedding vector representation of the final output layer;

[0152] S65. Calculate the loss function value based on the embedded vector representation of all nodes in the output layer of the graph neural network and the preset supervision labels, using the loss calculation method corresponding to the target task;

[0153] S66. Based on the calculated loss function value, perform backpropagation operation on the parameters of the graph neural network model, update the weight parameters in each graph convolution layer, and record and save the node embedding feature matrix and adjacency matrix status of the current round.

[0154] In this embodiment, the S7 specifically includes:

[0155] S71. After the graph neural network model completes all training rounds and the loss function value converges and stabilizes, extract the adjacency matrix and node embedding feature matrix obtained from the final training, read all non-zero edge connection relationships in the adjacency matrix, and construct a final edge connection relationship set;

[0156] S72. In the final edge connection relationship set, for each edge connection (i, j), extract the edge weight in its adjacency matrix and define it as the final explanatory gradient weight of the edge connection Construct a set of structural descriptions consisting of edge connections and corresponding explanatory weights;

[0157] S73, perform normalization operation on the explanatory gradient weight set, and all Map to the interval [0,1] and construct a graph structure to represent the triple set The edge set description as the output of the final graph neural network structure;

[0158] S74. Define a graph modeling visualization control parameter set, including edge threshold control parameters, color mapping control parameters, and node embedding projection dimension parameters, for controlling edge display, weight coloring, and low-dimensional embedding space generation during graph structure display.

[0159] S75. Based on the control parameter, remove edges whose edge weights in the graph structure triple set are lower than a threshold value, and retain significant connection relationships.

[0160] S76. Based on the node embedding vector matrix of the final output layer of the graph neural network, perform a low-dimensional projection operation and use principal component analysis to map the high-dimensional embedding vector to a two-dimensional or three-dimensional coordinate space to construct a node visualization layout.

[0161] S77. Based on the edge connection strength and control parameters, the edge color and transparency mapping rules in the graph structure are generated. Finally, the node layout, edge connection relationship and explanatory gradient weight are output to the graph modeling visualization module to generate a structural interpretable graphical display result.

[0162] Example 1:

[0163] To verify the practical effectiveness and adaptability of the structured data self-learning method based on graph neural networks proposed in this paper, a data center affiliated with a large domestic joint-stock commercial bank was selected as an actual test scenario. This data center provides multiple business modules such as credit services, transaction clearing, and contract management to corporate customers, and has accumulated rich structured data resources. With the rapid growth in the number of corporate customers and the types of business, the original customer risk identification solutions that relied on manual construction and static models have gradually exposed problems such as insufficient accuracy, delayed structural updates, and unexplainable models. The bank hopes to improve its post-loan risk control capabilities and enhance its ability to identify potential risk customers through more intelligent and dynamically responsive modeling methods.

[0164] In this scenario, the bank connects structured customer behavior data from September to December 2024 to the graph modeling system of this invention. This data includes account activity records, contract update logs, customer profile changes, and correspondence information, totaling approximately 3.8 million field entries across 11 fields. Through automatic parsing of entity and relationship fields, the system extracts enterprise IDs, contact IDs, contract numbers, account IDs, and transaction numbers as nodes in the graph. It then generates candidate edge sets based on associations between fields like contract signing, fund transfers, and communication frequency, constructing the initial structure candidate graph for the graph neural network.

[0165] The system further constructs a feature template for each node, generating a node embedding feature matrix through field encoding and embedding mapping. After initializing the adjacency matrix, the graph neural network model enters the training phase. A gradient-sensitive sparse adjacency self-learning algorithm is introduced to perform a second-order gradient approximation on the contribution of candidate edges. Edge pruning and normalization are performed in each training round, ultimately constructing a sparse and efficient graph structure. Once the model stabilizes, the system utilizes an embedding interpretability backtracking mechanism to track the gradient flow from the prediction results, annotating the edge connection paths that have the greatest impact on customer risk assessment.

[0166] After training and prediction are complete, the system outputs the graph structure and interpretable paths to the graph modeling and visualization module, assisting risk analysts in verification and intervention strategy development. To quantify the modeling performance and business value of this method, the bank selected 20,000 pieces of real corporate customer data, 80% of which were used for training and 20% for evaluation. A comparative analysis was conducted using both traditional static rule-based graph construction methods and the proposed method, resulting in the following statistical analysis.

[0167] Table 1 Comparison of quality indicators of graph structure modeling

[0168]

[0169] As can be seen from the above table, the graph structure constructed by the method of the present invention is significantly superior to the traditional regular composition method in core indicators such as edge density and effective edge ratio. The average edge density is increased by 96%, reflecting a richer structural expression. The effective edge ratio is increased to 89.2%, indicating that the system retains the connection relationships that contribute most to the task through the gradient screening mechanism. The proportion of redundant edges has dropped significantly, reducing the interference of invalid features on model training. At the same time, the system supports daily automatic structural updates, dynamically adapting to business changes, and is much more efficient than the traditional "manual script update once a week" model. Node embedding training converges faster, and the labor cost of graph construction is reduced from 48 hours / month to less than 3 hours, greatly reducing deployment and maintenance costs.

[0170] In addition, in terms of model prediction results, the bank further counted the model's performance in actual business, including key business indicators such as customer risk prediction, warning accuracy, and business intervention response time, as shown below.

[0171] Table 2 Comparison of customer risk identification and risk control intervention effects

[0172]

[0173] As can be seen from the above business data, the graph neural network model constructed by the present invention has significantly improved the accuracy of high-risk customer identification, reaching 91.8%, which is more than 13 percentage points higher than the traditional method. Through structural optimization and an explainable path mechanism, the system can issue early warnings an average of 5.6 days in advance in actual business, providing a more sufficient intervention window. The success rate of risk control intervention has also increased significantly to 85.2%. Due to the introduction of explanatory edge weights and structural visualization, risk control personnel have increased their trust in the model's prediction results, and the satisfaction survey score has increased to 94.6%. Most employees have reported that the system has a "clear structure" and "traceable conclusions", which facilitates accurate judgment of risk sources.

[0174] For example, customer number X37812 was not identified as a high-risk customer in the traditional model, but was successfully identified in the method of the present invention. Its key path includes "continuous renewal of contract numbers - frequent changes in contacts - no valid reconciliation records in the past three months." The system output structure diagram shows that this path contributes as much as 0.82 to the classification result. After timely intervention, risk control personnel found that its actual controller was involved in a major legal dispute, and promptly froze the credit business to avoid subsequent bad debt losses.

[0175] In summary, this invention not only effectively solves core technical problems such as automatic mapping of structured data, edge connection screening and insufficient interpretability, but also demonstrates excellent structural quality, predictive performance and business support capabilities in actual financial risk control scenarios, and has strong practical value and industry promotion potential.

[0176] The above description is only a preferred specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any technician familiar with the technical field, within the technical scope disclosed by the present invention, who makes equivalent replacements or changes based on the technical solution and inventive concept of the present invention, should be covered by the scope of protection of the present invention.

Claims

1. A structured data self-learning method based on graph neural network, characterized in that: The steps include: S1. Parse structured data, extract entity fields to build a node set of the graph neural network, extract relationship fields to generate a candidate edge set, and build a structure candidate graph; S2. Generate a node embedding feature matrix based on the node set, initialize the adjacency matrix to be empty and bind it to the candidate edge position in the structure candidate graph; S3. Build a graph neural network model, take the node embedding feature matrix and adjacency matrix as input, and define the task loss function; S4. Based on the gradient-sensitive sparse adjacency self-learning algorithm, calculate the second-order gradient contribution of the candidate edge-connected node pairs to the task loss function, update the edge connection relationship and edge weight values ​​in the adjacency matrix, and generate the initial graph structure representation; S5. Based on the initial graph structure representation, an embedding interpretable gradient backtracking mechanism is executed to construct a gradient path from the node embedding feature to the task loss function and backtrack to the edge connection relationship. The explanatory gradient weights of the edge connection are extracted and written into the adjacency matrix, completing the structural modification of the graph neural network adjacency matrix. S6. Use the corrected adjacency matrix and node embedding feature matrix to perform graph neural network training and update the node embedding vector and graph structure representation; S7. After training convergence, extract the final edge connection relationship and corresponding explanatory gradient weight in the adjacency matrix, output the graph structure representation and explanatory indicator set, and generate graph modeling visualization results.

2. A structured data self-learning method based on graph neural network according to claim 1, characterized in that: Said S1 specifically includes: S11. Perform field parsing on the structured data, identifying fields in the structured data used to represent specific objects as entity fields, and identifying fields used to represent relationships between objects as relationship fields; S12. Based on the field value of the entity field, perform a one-to-one mapping operation on each type of entity object, mapping each unique entity field value to a node in the graph neural network, where the mapping rule is: divide the node type according to the field type to which the entity field belongs, assign the node index number based on the deduplication result of the field value, and generate a node set of the graph neural network; S13. Parse the relationship fields. For each structured data record, extract the corresponding relationship between two or more entity fields. Generate a set of candidate edge relationships based on the permutation results of the entity field combinations in the record, and establish an edge connection mapping. Each candidate edge connects two nodes in the node set, forming a candidate edge set. S14. Assign an initial connection direction and an initial edge weight value to each candidate edge in the candidate edge set. The initial connection direction is determined according to a preset directionality field in the relationship field. The initial edge weight value can be set to a default constant or a result of a numeric field in the relationship field. S15. Construct a structure candidate graph based on the node set and the candidate edge set, wherein a graph topology of the structure candidate graph is composed of nodes in the node set and edges in the candidate edge set, and all connection relationships in the graph structure are stored in the form of adjacency pairs; S16. Perform a structural consistency check on the candidate structure graph, remove candidate edges that fail to match valid node numbers, delete isolated nodes with no edge connections in the node set, and complete the construction of the candidate structure graph.

3. A structured data self-learning method based on graph neural network according to claim 1, characterized in that: The S2 specifically includes: S21. Perform a field feature collection operation on each node in the node set of the graph neural network, extract all entity field values ​​corresponding to the target node in the node set of the graph neural network from the structured data, and arrange them in a preset field order to form a node feature vector template; S22. Numerically encode all field values ​​in the node feature vector template, keep the numeric fields in their original numeric form, convert the categorical fields into discrete integer indexes, and then uniformly convert them into fixed-dimensional numeric vectors to generate an embedded vector representation of each node in the node set of the graph neural network. S23. Arrange the embedding vectors of all nodes in the node set of the graph neural network in order according to the node index numbers to form a node embedding feature matrix; S24. Construct an adjacency matrix of the graph neural network, and initialize the adjacency matrix of the graph neural network to a matrix with element values ​​of zero; S25. Traverse the candidate edge set in the structure candidate graph, read the start node index and the end node index connected to each candidate edge in the structure candidate graph, and record the row index corresponding to the start node index and the column index corresponding to the end node index in the adjacency matrix of the graph neural network as the candidate edge connection position; S26. Input the node embedding feature matrix and the adjacency matrix of the completed candidate edge connection position records into the graph neural network.

4. A structured data self-learning method based on graph neural network according to claim 1, characterized in that: The S3 specifically includes: S31. Construct a graph neural network model, which includes an input layer, a graph convolution calculation layer of the graph neural network, and an output layer. The input of the graph neural network model includes a node embedding feature matrix of the graph neural network and an adjacency matrix of the graph neural network. S32. Input the node embedding feature matrix of the graph neural network as input features and the adjacency matrix of the graph neural network as structural constraints into the graph convolution computation layer of the graph neural network model. Perform feature propagation, adjacency feature aggregation, and node embedding update operations in the graph convolution computation layer to obtain the predicted embedding representation of the graph neural network output layer. S33. Probabilistic mapping is performed on the embedding vector of each target node in the output layer of the graph neural network. The output value of each dimension in the embedding vector is nonlinearly transformed according to an exponential function. The transformation results of all dimensions are normalized so that the output value of each dimension occupies a relative proportion in the sum of all dimensions, thereby obtaining the predicted probability distribution of the target node in each category. The sum of the predicted probabilities of each category is 1, forming a normalized probability vector. S34. Based on the difference between the predicted probability distribution of the output layer of the graph neural network and the supervision label, the task loss function of the graph neural network is defined as: Among them, n represents the number of target nodes of the graph neural network participating in the supervised training, C represents the total number of classification categories, and y ic represents the true label of the i-th target node in the c-th category in the graph neural network, represents the predicted probability of the i-th target node in the c-th category.

5. A structured data self-learning method based on graph neural network according to claim 1, characterized in that: The S4 specifically includes: S41. After the graph neural network model completes a round of forward propagation and calculates the task loss function based on the node embedding feature matrix and the adjacency matrix, for each candidate edge in the structural candidate graph, the index positions of the starting node and the ending node connected to it in the node embedding feature matrix are extracted, and the node embedding vector pair corresponding to the candidate edge is constructed; S42, based on the node embedding vector pairs connected by the candidate edges, the task loss function is trained by the gradient sensitive sparse adjacency self-learning algorithm. To calculate the second-order partial derivative contribution of the node pair, the block diagonal Hessian approximation strategy is adopted and the calculation process is defined as follows: Constructing node embedding vector sets for graph neural networks Where n is the number of nodes in the node set of the graph neural network, and d is the dimension of the embedding vector of each node; For the node pair (i, j) connected by the candidate edge, approximately calculate its second-order gradient contribution in the loss function: in, are the embedding vectors of node i and node j respectively, Indicates the second-order gradient contribution of the candidate edge (i, j) to the task loss function in the t-th round of training; S43, using the sliding average strategy Smoothing is performed to suppress training fluctuation interference and enhance the stability of adjacent structure evolution. The update formula is as follows: Among them, α∈(0,1) is the sliding control factor, S44, smoothed contribution value of all outgoing edges corresponding to each node in the node set of the graph neural network Perform sorting, retain the top k candidate edges with the highest gradient contributions, normalize the gradient values ​​in the sorting results to the interval [0, 1], and write them to the corresponding edge positions in the adjacency matrix to form the initial graph structure representation of the current round; S45. Set the adjacency matrix pruning threshold θ t =θ0·exp(-λt), where θ0 is the initial pruning threshold, λ is the threshold exponential decay coefficient, and t represents the current training round. t The edges of are removed to form a sparse structure; S46. Input the node embedding feature matrix and sparse structure of the graph neural network into the graph neural network model, perform a complete forward propagation operation, and obtain the intermediate node embedding representation of the graph neural network model under the current structural configuration as the output of the current round of graph structure learning; S47, based on the current round of intermediate node embedding representation and the edge connection weight information retained in the adjacency matrix, construct a graph structure triple set (i, j, a ij ), where i and j represent the connection node index, a ij ∈[0,1] represents the edge connection strength, and combined with the node embedding feature matrix of the graph neural network, the initial graph structure representation G0=(V,E0,X) is generated, where V is the node set of the graph neural network, E0 is the candidate edge set obtained by gradient-driven screening, and X is the node embedding feature matrix.

6. A structured data self-learning method based on graph neural network according to claim 1, characterized in that: The S5 specifically includes: S51. Take the adjacency matrix and node embedding feature matrix in the initial graph structure representation as input, perform a round of forward propagation of the graph neural network model, and obtain the prediction results and task loss function of each supervision node. S52. Construct an embedded interpretable gradient backtracking mechanism, including the following operations: For each target node participating in supervised training in the graph neural network, the loss function Starting from its corresponding node embedding vector h i Find the first-order gradient, denoted as by As the starting gradient signal, it backpropagates the gradient along each layer of the neural computation graph in the graph structure, calculates the explanatory gradient transfer amount of all edges on the path connecting to the target node through the chain rule, and constructs the gradient propagation path from the target node embedding vector to the edge connection path; S53. For each edge connection (i, j), count its frequency and contribution gradient value in all target node backtracking paths, and perform explanatory gradient contribution aggregation, which is defined as: Among them, r ij represents the cumulative explanatory weight of edge (i, j), n sup Indicates the number of supervisory nodes, Represents the loss function component of the lth supervisory node; S54, explanatory weight r for all edge connections ij Perform normalization and use the normalized gradient weights Replace the edge weights of the original positions in the adjacency matrix to form an explanatory driving structure correction matrix; S55, re-inputting the updated explanatory driving structure correction matrix and the node embedding feature matrix into the graph neural network model, and inputting the update after completing one structural correction; S56. Connect all edges (i, j) in the current adjacency matrix to their corresponding explanatory gradient weights Export together.

7. A structured data self-learning method based on graph neural network according to claim 1, characterized in that: The S6 specifically includes: S61. Take the adjacency matrix of the graph neural network modified by the embedded interpretable gradient backtracking mechanism and the node embedding feature matrix of the graph neural network as input at the same time to construct the current round computation graph of the graph neural network model; S62. For each node of the graph neural network in the current round of computation, based on the edge connection relationship defined in the adjacency matrix, collect its embedded features from adjacent nodes, and form a new round of embedded feature input values ​​for the node through linear combination and normalization. S63. Perform a matrix multiplication operation on the new embedded feature input value of each node and the weight parameters of each graph convolution layer in the graph neural network model, and combine it with a nonlinear activation function to generate a node output embedded feature vector of the current layer of the graph neural network model; S64. Repeat the feature propagation and transformation operations on each graph convolutional layer in the graph neural network model until all network layers complete the calculation, and obtain the node embedding vector representation of the final output layer; S65. Calculate the loss function value based on the embedded vector representation of all nodes in the output layer of the graph neural network and the preset supervision labels, using the loss calculation method corresponding to the target task; S66. Based on the calculated loss function value, perform backpropagation operation on the parameters of the graph neural network model, update the weight parameters in each graph convolution layer, and record and save the node embedding feature matrix and adjacency matrix status of the current round.

8. A structured data self-learning method based on graph neural network according to claim 1, characterized in that: The S7 specifically includes: S71. After the graph neural network model completes all training rounds and the loss function value converges and stabilizes, extract the adjacency matrix and node embedding feature matrix obtained from the final training, read all non-zero edge connection relationships in the adjacency matrix, and construct a final edge connection relationship set; S72. In the final edge connection relationship set, for each edge connection (i, j), extract the edge weight in its adjacency matrix and define it as the final explanatory gradient weight of the edge connection Construct a set of structural descriptions consisting of edge connections and corresponding explanatory weights; S73, perform normalization operation on the explanatory gradient weight set, and all Map to the interval [0,1] and construct a graph structure to represent the triple set The edge set description as the output of the final graph neural network structure; S74. Define a graph modeling visualization control parameter set, including edge threshold control parameters, color mapping control parameters, and node embedding projection dimension parameters, for controlling edge display, weight coloring, and low-dimensional embedding space generation during graph structure display. S75. Based on the control parameter, remove edges whose edge weights in the graph structure triple set are lower than a threshold value, and retain significant connection relationships. S76. Based on the node embedding vector matrix of the final output layer of the graph neural network, perform a low-dimensional projection operation and use principal component analysis to map the high-dimensional embedding vector to a two-dimensional or three-dimensional coordinate space to construct a node visualization layout. S77. Based on the edge connection strength and control parameters, the edge color and transparency mapping rules in the graph structure are generated. Finally, the node layout, edge connection relationship and explanatory gradient weight are output to the graph modeling visualization module to generate a structural interpretable graphical display result.

Images