Constrained large model patent atlas construction method

Abstract

The invention provides a large model patent atlas construction method with constraints. The method comprises the steps that a TRIZ rule table is constructed, TRIZ rules of each process are matched by inputting atlas states and atlas construction processes, the TRIZ rules of the processes form a process TRIZ rule table, TRIZ rule matching is carried out according to each process, and TRIZ rule matching results are obtained; converting the updated constraint condition cluster into a logical reasoning rule, performing constraint condition cluster classification on knowledge in the graph, judging whether the graph knowledge violates constraint conditions or a dependency set according to the logical reasoning rule, and if the graph knowledge violates the constraint conditions or the dependency set, triggering early warning; and carrying out correlation analysis on the updated constraint condition cluster by adopting an expectation maximization algorithm, iteratively optimizing the constraint condition cluster until the correlation of the constraint condition cluster tends to be stable, and updating a logical reasoning rule and an early warning mode according to the optimized constraint condition cluster.

Description

Technical Field

[0001] The present invention relates to the field of information technology, and in particular to a method for constructing a large-model patent graph with constraints. Background Art

[0002] The propagation of constraints in the graph is closely related to the topological structure of the graph. Constraints may be presented at different granularities and levels. When a constraint is triggered, it may cause a series of related constraints to be triggered at the same time, forming a clustering effect of constraints and causing constraint diffusion. This constraint diffusion may spread rapidly along certain key paths in the graph, bringing challenges to the organization and management of the graph. In addition, the constraints in the graph may evolve dynamically with the changes in time and space. The same constraint may produce completely different effects when triggered at different time points, and may even lead to logical conflicts and knowledge confusion. Changes in spatial dimensions may also change the scope of application and impact path of constraints. How to effectively use the invention principle of triz to explore the contradiction between constraint diffusion conditions and spatiotemporal evolution, organize and manage constraints in the graph, control constraint diffusion, and deal with dynamic adaptation problems caused by spatiotemporal changes is a technical problem that needs to be solved urgently. It is necessary to design a hierarchical constraint propagation mechanism to reasonably divide the granularity and level of constraints and control the path and scope of constraint diffusion. At the same time, it is necessary to introduce spatiotemporal factors to capture the dynamic evolution of constraints, adjust the organization of constraints in a timely manner, and resolve potential logical conflicts. This requires comprehensive consideration of multiple aspects such as the topological structure of the graph, the intrinsic properties of the constraints, the influence of temporal and spatial factors, etc., which poses new challenges to traditional graph organization and management technologies. Summary of the invention

[0003] The present invention provides a method for constructing a large model patent map with constraints, which mainly includes:

[0004] Construct a TRIZ rule table, match the TRIZ rules of each process by inputting the graph state and the graph building process, form the TRIZ rules of the process into a process TRIZ rule table, match the TRIZ rules according to each process, and obtain the TRIZ rule matching results;

[0005] According to the TRIZ rule matching results, a hierarchical clustering algorithm is used to analyze the intrinsic properties of the nodes in the graph and the topological structure of the entire graph, and constraint condition clusters of different granularities and levels are obtained. The correlation between the constraints is analyzed and the correlation relationship between the constraint condition clusters is determined.

[0006] According to the association relationship of the constraint condition cluster, the constraint condition is decomposed into dependent objects and trigger levels, the constraint condition dependency set and trigger sequence are constructed, and the spatiotemporal attributes of the constraint condition dependency set and trigger sequence are obtained, and the spatiotemporal attributes are converted into child nodes of the current version node;

[0007] According to the spatiotemporal attributes of different version nodes, a relational constraint version tree is constructed. The correlation between constraint conditions is obtained by mapping the version tree nodes in continuous time and space. If the correlation between relational constraint conditions changes, the corresponding constraint diffusion and propagation is triggered, and the associated constraint condition clusters are updated to obtain the updated constraint condition clusters.

[0008] Convert the updated constraint clusters into logical reasoning rules, classify the knowledge in the graph into constraint clusters, and determine whether the graph knowledge violates the constraint or dependency set based on the logical reasoning rules. If the constraint or dependency set is violated, trigger an early warning.

[0009] Monitor and warn based on graph knowledge nodes and constraint sets. Calculate the evaluation score based on the matching of constraint sets and graph knowledge nodes. If the evaluation score is lower than the set threshold, isolate the knowledge node and add it to the deletion stack for deletion. At the same time, trigger the corresponding constraint diffusion and propagation, and update the associated constraint cluster.

[0010] The expectation maximization algorithm is used to perform correlation analysis on the updated constraint clusters, and the constraint clusters are iteratively optimized until the correlation of the constraint clusters tends to be stable. The logical reasoning rules and early warning methods are updated according to the optimized constraint clusters.

[0011] The technical solution provided by the embodiment of the present invention may have the following beneficial effects:

[0012] The present invention discloses a method for constructing a patent graph with a large model with constraints. The method first constructs a TRIZ rule table and designs a matching method, and matches the TRIZ rules by inputting the graph state. Then, the constraints are analyzed by using a hierarchical clustering and association rule learning algorithm, and a constraint dependency set is constructed. Then, a convolutional recurrent neural network is used to obtain the spatiotemporal attributes of the constraints, and a relational constraint version tree is constructed. When the relevance of the constraints changes, constraint diffusion and propagation are triggered, and the constraint cluster is updated. Finally, the consistency of the graph knowledge is continuously monitored. By continuously optimizing the constraint cluster through the expectation maximization algorithm, the dynamic optimization and quality control of the knowledge graph are realized, and the accuracy and reliability of the knowledge graph are effectively improved. BRIEF DESCRIPTION OF THE DRAWINGS

[0013] Figure 1 The present invention is a flowchart of a method for constructing a large-model patent map with constraints.

[0014] Figure 2 A schematic diagram of a constrained large-model patent map construction method of the present invention.

[0015] Figure 3 This is another schematic diagram of a method for constructing a constrained large model patent map according to the present invention. DETAILED DESCRIPTION

[0016] In order to make the purpose, technical solutions and advantages of the present invention more clear, the present invention is described in detail below with reference to the accompanying drawings and specific embodiments.

[0017] like Figure 1-3 In this embodiment, a method for constructing a large model patent map with constraints may specifically include:

[0018] Step S101, construct a TRIZ rule table, match the TRIZ rules of each process by inputting the graph state and the graph building process, form the TRIZ rules of the process into a process TRIZ rule table, perform TRIZ rule matching according to each process, and obtain the TRIZ rule matching result.

[0019] The graph neural network is used to encode the attributes of the graph nodes and edges to obtain a vector representation of the graph state. According to the vector representation of the graph state, the degree of matching between the graph state and the preset state template vector is calculated, and the template with the highest matching degree is selected as the reference of the current graph state. For each rule, the applicability score of the current graph state is calculated, and the applicability score is obtained by multiplying the matching degree between the rule condition and the graph state feature by the historical application frequency of the rule. A decision tree is constructed based on the applicability score, and the construction process of the decision tree includes feature selection and splitting criterion determination. Using the graph state feature as input, the decision tree is traversed from top to bottom until the leaf node to determine the final applicable rule subset. The rule subset is mapped to each process in the graph construction process to form a complete process TRIZ rule table. The process TRIZ rule table contains process identification, applicable rule ID list and rule application suggestions. If there are conflicting rules in the process TRIZ rule table, they are selected according to the rule priority, and a conflict-free and high-coverage rule set is obtained through iterative optimization.

[0020] Specifically, the input graph state is feature extracted according to the pre-established knowledge graph structure, and the graph neural network is used to encode the attributes of the graph nodes and edges to generate a vector representation of the graph state. The cosine similarity is used to calculate the matching degree between the current graph state vector and the preset state template vector, and the template with the highest matching degree is selected as the reference of the current graph state. The TRIZ rule set is obtained from the rule base, which is constructed by collecting, sorting and standardizing TRIZ innovation principles. For each rule, its applicability score with the current graph state is calculated by multiplying the matching degree between the rule condition and the graph state feature by the historical application frequency of the rule. The weighted summation method is used to comprehensively consider the universality, timeliness and other factors of the rule, and the weight is obtained based on historical data statistics. The rules are prioritized and the rule subset with the highest score is selected. A decision tree is constructed for the selected rule subset. The construction process of the decision tree includes feature selection and splitting criterion determination. The rule application conditions are set at each node of the tree, and the graph state features are used as input to traverse the decision tree from top to bottom until the leaf node to determine the final applicable rule subset. These rules are organized into a structured process rule table, which contains information such as rule ID, rule description, applicable conditions and priority. Conflict detection is performed on the rules in the process rule table, and the relationship between the rules is analyzed using the association rule mining algorithm, and the support and confidence between the rules are calculated. If there are conflicting rules, they are selected according to the rule priority, and a conflict-free and high-coverage rule set is obtained through iterative optimization. The final rule set is mapped to each process in the graph construction process to form a complete process TRIZ rule table. For each graph construction process, the applicable rules are selected from the rule set, and the rule ID and the corresponding process identifier are recorded. The final output process TRIZ rule table contains the process identifier, the applicable rule ID list and the rule application suggestion. In the process of knowledge graph feature extraction, the graph convolutional network is used to encode the graph nodes and edges. Taking a knowledge graph containing 100 nodes and 500 edges as an example, each node has a 10-dimensional attribute vector and each edge has a 5-dimensional attribute vector. Through two layers of graph convolution, node features are aggregated into 64-dimensional vectors, edge features are aggregated into 32-dimensional vectors, and finally all node and edge features are concatenated to obtain a 6400-dimensional graph state vector. The preset state template library contains 50 typical graph states, each of which is also represented as a 6400-dimensional vector. Calculate the cosine similarity between the current graph state vector and the template vector, and select the template with the highest similarity as a reference. The TRIZ rule library contains 40 standardized innovation principles, and each rule consists of a condition part and an action part. The rule applicability score adopts the product of condition matching degree and historical application frequency, where the condition matching degree is obtained by calculating the dot product of the rule condition vector and the graph state vector, and the historical application frequency is obtained based on the statistics of the past 1000 application records.The rule universality (weight 0.3), timeliness (weight 0.4) and domain relevance (weight 0.3) were comprehensively considered for weighted summation, and the 10 rules with the highest scores were selected. When constructing the decision tree, the information gain ratio was used as the feature selection and splitting criterion, the maximum depth of the tree was set to 5, and the minimum number of leaf node samples was 10. The rule subset obtained after traversing the decision tree was organized into a process rule table, which contains fields such as rule ID, description, condition and priority. The Apriori algorithm was used for association rule mining, with the minimum support set to 0.1 and the minimum confidence set to 0.7 to discover the association relationship between rules. If conflicting rules were detected, the rules with high priority were retained, and the final conflict-free rule set was obtained through 3 rounds of iterative optimization. The rule set was mapped to the 8 main processes of the graph construction process, and 2-3 most relevant rules were selected for each process to form a complete process TRIZ rule table containing process identification, rule ID list and application suggestions.

[0021] Step S102, based on the TRIZ rule matching results, a hierarchical clustering algorithm is used to analyze the intrinsic properties of the nodes in the graph and the topological structure of the entire graph, to obtain constraint condition clusters of different granularities and levels, analyze the correlation between the constraints, and determine the correlation relationship between the constraint condition clusters.

[0022] The method comprises the following steps: obtaining the intrinsic attributes and topological structure characteristics of the nodes in the graph, wherein the intrinsic attributes and topological structure characteristics are determined according to the TRIZ rule matching results; converting the node attributes into numerical vectors, wherein the topological characteristics are quantified by degree centrality and / or clustering coefficient indicators; using Euclidean distance to calculate the similarity between nodes and constructing a similarity matrix; clustering the nodes by a hierarchical clustering algorithm to obtain constraint condition clusters of different granularities; constructing a hierarchical tree based on the clustering results, merging from the bottom up starting from the leaf nodes, and merging the two clusters if the average distance between the two clusters is less than a preset threshold; using the Apriori algorithm to analyze the correlation between constraint condition clusters, screening frequent item sets according to preset minimum support and minimum confidence, and generating candidate association rule sets; calculating the lift of the association rule, wherein the lift is equal to the confidence divided by the support of the result item; sorting the rules according to the support, confidence and lift of the association rule, and selecting the top-ranked rules as the association relationship between constraint condition clusters; constructing a constraint condition association network diagram, wherein the nodes in the network diagram represent clusters, the edges represent association relationships, and the thickness of the edges represents the strength of association.

[0023] Specifically, the intrinsic attributes and topological structure characteristics of the nodes in the graph are obtained according to the TRIZ rule matching results, and the node attributes are converted into numerical vectors. The topological characteristics are quantified by indicators such as degree centrality and clustering coefficient. The Euclidean distance is used to calculate the similarity between nodes, and the similarity matrix is ​​constructed. The nodes are clustered by the AGNES hierarchical clustering algorithm to obtain constraint clusters of different granularities. A hierarchical tree is constructed based on the clustering results, and the bottom-up merging starts from the leaf node. The merging threshold is set as the average distance between the two clusters. The cluster boundary is determined by calculating the connection strength and the shortest path length between the nodes to form a multi-level constraint cluster structure. The Apriori algorithm is used to analyze the correlation between constraint clusters, and the minimum support is set to 0.1 and the minimum confidence is set to 0.5 to screen frequent item sets, generate association rule candidate sets, and calculate the rule lift to evaluate the rule strength. The lift calculation formula is lift = confidence / result item support. The rules are sorted according to their support, confidence and lift, and the top 10% of the rules are selected as the final constraint cluster association relationship. The constraint association network diagram is constructed, where nodes represent clusters, edges represent association relationships, and the thickness of edges represents the strength of association. Using the constructed association network diagram, other associated constraint clusters can be quickly identified for specific constraints to assist in solving complex constraint problems. In the implementation process, the intrinsic attributes and topological structure characteristics of the graph nodes are first extracted from the TRIZ rule matching results. Assuming that there are 100 nodes, each node has 5 intrinsic attributes (such as importance, frequency, intensity, etc.), and these attributes are converted into 5-dimensional vectors. The topological features are obtained by calculating the degree centrality and clustering coefficient of each node to form a 2-dimensional vector. The intrinsic attribute vector and the topological feature vector are concatenated to obtain a 7-dimensional feature vector for each node. The Euclidean distance is used to calculate the similarity between nodes, and a 100x100 similarity matrix is ​​constructed. The AGNES hierarchical clustering algorithm is used, each node is initially regarded as a cluster, and the most similar clusters are gradually merged until all nodes are classified into one category. The merge threshold is set to 0.5. When the distance between clusters is greater than 0.5, the merge is stopped. Finally, 10 constraint clusters are obtained. When constructing the hierarchical tree, start from 100 leaf nodes, merge the two clusters with the closest distance each time, and record the merge process to form a tree structure. Calculate the connection strength between nodes, ranging from 0 to 1. Node pairs with a strength greater than 0.7 are considered strong connections. Calculate the shortest path length between nodes, and node pairs with a length less than 3 are considered neighboring nodes. Determine the cluster boundaries based on strong connections and neighboring relationships to form a multi-level constraint cluster structure. Use the Apriori algorithm to analyze the correlation between constraint clusters, set the minimum support 0.1 and the minimum confidence 0.5, and find frequent item sets from 10 clusters. Generate candidate association rule sets, calculate the rule lift, and rules with a lift greater than 1.5 are considered to have significant correlation.The discovered rules are comprehensively ranked by support, confidence and lift, and the top 10%, i.e., 3 rules, are selected as the final association relationship between constraint clusters. A constraint association network diagram is constructed, with 10 clusters as nodes and 3 association rules as edges. The thickness of the edges represents the strength of association (lift). Using this network diagram, other constraint clusters associated with specific constraints can be quickly identified. For example, when querying constraints related to "material strength", two related clusters of "structural design" and "processing technology" can be quickly located, assisting in solving complex engineering design constraint problems.

[0024] Step S103, according to the association relationship of the constraint condition cluster, the constraint conditions are decomposed into dependent objects and trigger levels, the dependency set and trigger sequence of the constraint conditions are constructed, and the spatiotemporal attributes of the constraint dependency set and the trigger sequence are obtained, and the spatiotemporal attributes are converted into child nodes of the current version node.

[0025] According to the association relationship of the constraint cluster, the node importance score is calculated, and the dependency object list and the trigger level matrix are determined by the node importance score; the dependency object list and the trigger level matrix are used to construct a constraint dependency directed graph, and the trigger sequence is determined by a topological sorting algorithm to obtain a constraint dependency set and a trigger sequence; the dependency path length and the trigger time interval in the dependency directed graph are calculated, and the constraint dependency set and the trigger sequence are converted into time series data; the time series data is input into a convolutional recurrent neural network for training, and the convolutional recurrent neural network includes a convolutional layer, an LSTM layer and a fully connected layer, and the time evolution characteristics and spatial distribution characteristics of the constraint dependency and the trigger sequence are extracted to obtain a high-dimensional spatiotemporal attribute vector; for the current version node, the high-dimensional spatiotemporal attribute vector is reduced in dimension by principal component analysis, and the attributes after dimension reduction are clustered by a K-means algorithm to obtain a cluster center set; a sub-node set is generated according to the cluster center set, and the sub-node structure of the current version node is updated by comparing the similarity between the newly generated sub-node and the existing sub-node.

[0026] Specifically, according to the association relationship of the constraint cluster, the PageRank algorithm is used to calculate the node importance score, the node connectivity and directionality are used to determine the dependent object, and the trigger level is quantitatively divided in combination with the score to obtain the dependent object list and the trigger level matrix. Using the dependent object list and the trigger level matrix, the constraint dependency directed graph is constructed, and the trigger sequence is determined by the topological sorting algorithm to generate the constraint dependency set and the trigger sequence. The Dijkstra algorithm is used to calculate the dependency path length and the trigger time interval, and the dependency set and the trigger sequence are converted into time series data. The time series data is input into the convolutional recurrent neural network for training. The network structure contains 2 convolutional layers, 1 LSTM layer and 2 fully connected layers. The time evolution characteristics and spatial distribution characteristics of the constraint dependency and the trigger sequence are extracted to obtain a high-dimensional spatiotemporal attribute vector. For the current version node, the extracted spatiotemporal attribute vector is reduced in dimension by principal component analysis, and the attributes after dimension reduction are clustered by the K-means algorithm. The number of clusters is set to 1.5 times the number of direct child nodes of the current version node. Each cluster center is used as a child node to generate a set of child nodes and establish an association relationship with the current version node. By comparing the similarity between the newly generated child nodes and the existing child nodes, the child node structure of the updated version node is merged with the high similarity child nodes, and the new independent child nodes are directly added. In the implementation process, the cluster association relationship containing 50 constraints is first analyzed. The PageRank algorithm is used to calculate the importance of the node. After 10 iterations, the score of each node is obtained, ranging from 0.01 to 0.15. By setting the connectivity threshold of 0.6 and the directionality threshold of 0.8, 40 pairs of dependent objects are determined. According to the importance score, the trigger level is divided into 5 levels, and a 50x5 trigger level matrix is ​​generated. Based on the dependent object list and the trigger level matrix, a directed graph is constructed, which contains 50 nodes and 40 edges. The Kahn algorithm is used for topological sorting to obtain the trigger sequence. The Dijkstra algorithm is applied to calculate the dependency path. The longest path length is 6 and the average trigger time interval is 2.5 unit time. The dependency set and the trigger sequence are converted into sequence data with 100 time steps. Design a convolutional recurrent neural network, including 2 convolutional layers (kernel size 3x3, 32 and 64 filters), 1 LSTM layer (128 units), and 2 fully connected layers (64 and 32 neurons). After 50 rounds of training, a 256-dimensional spatiotemporal attribute vector is extracted. Perform principal component analysis on the spatiotemporal attribute vectors of the current version of the node, retain the principal component that explains 95% of the variance, and reduce it to 64 dimensions. Use the K-means algorithm for clustering, and set the number of clusters to 15 (1.5 times the current 10 direct child nodes). Generate 15 child nodes and calculate the cosine similarity with the existing 10 child nodes, with the threshold set to 0.85.Nodes with similarity higher than the threshold are merged, the remaining 5 new nodes are added directly, and finally the version node is updated to form a new structure with 20 child nodes.

[0027] Step S104, construct a relational constraint version tree according to the spatiotemporal attributes of different version nodes, and obtain the correlation between constraint conditions by mapping the version tree nodes in continuous time and space. If the correlation of relational constraint conditions changes, the corresponding constraint diffusion and propagation is triggered, and the associated constraint condition clusters are updated to obtain the updated constraint condition clusters.

[0028] Construct a relational constraint version tree, determine the hierarchical structure of the version tree by calculating the Euclidean distance between nodes, and obtain the version tree with a multi-level structure; according to the nodes in the version tree, use the ARIMA model to extract the evolution characteristics of the nodes on the continuous time axis, and obtain the distribution characteristics of the nodes in the low-dimensional space; if the change in the correlation strength between nodes exceeds the preset threshold, use the graph convolutional network to simulate the diffusion process of the constraint conditions, and calculate the diffusion impact range and intensity; according to the diffusion results, use the decision tree algorithm to locally adjust the cluster, recalculate the correlation relationship within the cluster, and generate an updated constraint condition cluster; if the node position change exceeds the preset change threshold, reconstruct the affected subtree to ensure that the version tree structure is consistent with the updated constraint condition cluster.

[0029] Specifically, according to the spatiotemporal attributes of different version nodes, the AGNES algorithm is used to construct a relational constraint version tree. The hierarchical structure of the tree is determined by calculating the Euclidean distance between nodes. The distance threshold is set to control the depth and width of the tree, and a version tree with a multi-level structure is obtained. For the nodes in the version tree, the ARIMA model is used to extract the evolution characteristics of the nodes on the continuous time axis, and the t-SNE algorithm is combined to obtain the distribution characteristics of the nodes in the low-dimensional space. The strength of the correlation between the constraints is calculated by the cosine similarity of the feature vector. The correlation change detection threshold is set. When the change in the correlation strength between nodes exceeds the threshold, the constraint diffusion and propagation mechanism is triggered. The graph convolution network is used to simulate the diffusion process of the constraint conditions, and the diffusion impact range and intensity are calculated. The graph convolution network contains 3 graph convolution layers, each layer uses the ReLU activation function, and the last layer outputs the diffusion probability distribution. According to the diffusion results, the affected constraint condition clusters are updated, the decision tree algorithm is used to locally adjust the clusters, and the internal correlation relationships of the clusters are recalculated to generate updated constraint condition clusters. Feedback the update results to the corresponding nodes in the version tree, update the spatiotemporal attribute values ​​of the nodes, and adjust the position of the nodes in the version tree according to the new attribute values. If the node position changes significantly, re-execute the AGNES algorithm to reconstruct the affected subtree to ensure that the version tree structure is consistent with the updated constraint cluster. In the implementation process, the spatiotemporal attributes of 100 version nodes are first processed, and each node contains 20-dimensional time features and 30-dimensional spatial features. The AGNES algorithm is used to construct the relationship constraint version tree, and the distance threshold is set to 0.5. Finally, a 5-layer deep tree structure is obtained, which contains 150 internal nodes and 100 leaf nodes. The ARIMA (2,1,2) model is applied to each node to extract 10 key time series features, and then the t-SNE algorithm is used to reduce the 30-dimensional spatial features to 3 dimensions. The correlation strength matrix between nodes is obtained by calculating the cosine similarity of the feature vectors. The correlation change detection threshold is set to 0.1. When the correlation strength between two version nodes changes by more than 0.1, the constraint diffusion mechanism is triggered. A three-layer graph convolutional network is used to simulate the diffusion process, with each layer containing 64 convolution kernels, ReLU activation function, and dropout rate of 0.5. The diffusion impact range is determined by setting a probability threshold of 0.05, affecting 15 adjacent nodes on average. According to the diffusion results, the decision tree algorithm (maximum depth of 5, minimum sample split of 10) is used to adjust the affected constraint clusters. The updated cluster adjusts the internal structure of the cluster by recalculating the Euclidean distance of the internal nodes. The update results are fed back to the version tree to modify the spatiotemporal attribute values ​​of the corresponding nodes. If the Euclidean distance of a node in the t-SNE dimensionality reduction space changes by more than 0.3, the AGNES algorithm is re-executed to reconstruct the subtree containing the node, affecting the two-layer structure of the tree on average.

[0030] By classifying the associations between constraints, a propagation level stack is constructed, and constraint changes are propagated to each constraint node in the tree in descending order.

[0031] According to the strength of the correlation between the constraints, the K-means clustering algorithm is used to divide the correlation into multiple levels, and the optimal K value is determined by the silhouette coefficient method to obtain the correlation level division result; using the correlation level division result, a propagation level stack is constructed, and the propagation level stack adopts a heap data structure to realize the priority queue function, and the constraints with high correlation levels are placed at the top of the stack, and the constraints with low correlation levels are located at the bottom of the stack; starting from the top of the propagation level stack, the constraints with high correlation are taken out, and the associated nodes are found in the tree structure by the depth-first search algorithm, and the depth-first search algorithm dynamically adjusts the search depth according to the hierarchical structure of the tree; a propagation attenuation factor is introduced to adjust the influence of the change according to the propagation distance, and the propagation attenuation factor is set to the value of the power of the number of propagation layers, and a time window is set to limit the propagation range within a unit time; for each affected node, the cumulative effect of the change is calculated, and if the cumulative effect exceeds a preset threshold, the node is re-stacked until the stack is empty or the maximum number of iterations is reached.

[0032] Specifically, according to the strength of the correlation between constraints, the K-means clustering algorithm is used to divide the correlation into multiple levels. The optimal K value is determined by the silhouette coefficient method. The correlation threshold is set as the average value of the distance between cluster centers to obtain the correlation level division result. Using the divided correlation levels, a propagation level stack is constructed, and the heap data structure is used to implement the priority queue function. The constraints with high correlation levels are placed at the top of the stack, and the constraints with low correlation levels are at the bottom of the stack. Starting from the top of the propagation level stack, the constraints with high correlation levels are taken out, and the associated nodes are found in the tree structure through the depth-first search algorithm. The algorithm dynamically adjusts the search depth according to the hierarchical structure of the tree, propagates the change information to these nodes, and records the propagation path. The propagation attenuation factor is introduced to adjust the influence of the change according to the propagation distance. The attenuation factor is set to 0.9 times the number of propagation layers. The time window is set to 10 time units to limit the propagation range per unit time. For each affected node, the cumulative effect of the change is calculated, considering the importance weight of the node and the length of the propagation path. When the cumulative effect exceeds the preset threshold (set to 20% of the initial importance of the node), the node is re-stacked to ensure that the chain reaction is fully considered, until the stack is empty or the maximum number of iterations is reached (set to twice the total number of nodes in the tree). In the implementation process, the relevance strength of 100 constraints is first analyzed and the K-means clustering algorithm is used for level division. The optimal K value is determined to be 5 by the silhouette coefficient method, and the relevance threshold is set to 0.6. The clustering results show that 20 constraints belong to the highest relevance level, 30 belong to the second highest level, 25 belong to the middle level, 15 belong to the second lowest level, and 10 belong to the lowest level. Subsequently, a maximum heap of size 100 is used to implement the priority queue, build a propagation level stack, and push the constraints of the 5 levels into the stack according to priority. Starting from the top of the stack, take out the high-relevance constraints, such as "material strength requirements", and use the depth-first search algorithm to find the relevant nodes in the tree structure. The algorithm uses full-depth search in the first three layers according to the 6-layer structure of the tree, and limits the search depth to 2 in the last three layers. A propagation attenuation factor of 0.9 is introduced, and the influence attenuation for the fourth-layer nodes is 0.729. A window of 10 time units is set, and a maximum of 20 nodes are processed in each unit. When calculating the cumulative effect, the node importance weight (range 0.1-1.0) and the propagation path length are considered. If the cumulative effect exceeds 20% of the initial importance of the node, the node is re-stacked. For example, the initial importance of the "Material Selection" node is 0.8, and when the cumulative effect exceeds 0.16, it triggers re-stack; the process continues until the stack is empty or 200 iterations are reached (twice the total number of nodes in the tree is 100).

[0033] Step S105, convert the updated constraint clusters into logical reasoning rules, classify the knowledge in the graph into constraint clusters, and determine whether the graph knowledge violates the constraints or dependency sets based on the logical reasoning rules. If the constraints or dependency sets are violated, an early warning is triggered.

[0034] A decision tree algorithm is used to construct logical reasoning rules, and the algorithm controls the generation granularity of the rules by setting an information gain threshold. According to the logical reasoning rules, the naive Bayes algorithm is used to classify knowledge into constraint clusters, and the classification uses the TF-IDF method to construct knowledge vectors. For the classified graph knowledge, a forward chain reasoning algorithm is used to judge the constraints and dependencies. The algorithm starts from known facts, matches the rule antecedents, triggers the rule consequences, and generates new facts. If the violation degree of the new facts exceeds the preset threshold, the specific rules and knowledge items violated are recorded. For the violated rules and knowledge items, a fuzzy comprehensive evaluation method is used for comprehensive evaluation, and the evaluation method is calculated based on the number of violated rules, the degree of violation, and the scope of influence. If the comprehensive evaluation result exceeds the preset warning level threshold, a warning signal of the corresponding level is triggered, and the warning signal includes details of the violated rules, the affected knowledge items, and suggested correction plans.

[0035] Specifically, according to the updated constraint clusters, the C4.5 decision tree algorithm is used to construct logical reasoning rules. The information gain threshold is set to 0.1 to control the generation granularity of the rules, and a set of structured logical reasoning rule sets are obtained. For the knowledge in the graph, the naive Bayes algorithm is used to classify the knowledge into constraint clusters, and the TF-IDF feature extraction method is used to construct the knowledge vector. The first 1000 high-frequency words are selected as features, and the knowledge is classified into the corresponding constraint clusters by calculating the cosine similarity. The forward chain reasoning algorithm is used to judge the constraints and dependencies of the classified graph knowledge based on the logical reasoning rules. The algorithm starts from the known facts, matches the rule antecedents, triggers the rule consequences, generates new facts, and repeats this process until no new facts can be generated. The violation degree threshold is set to 0.8. When the violation degree exceeds the threshold, the specific rules and knowledge items violated are recorded. According to the severity and number of rule violations, a multi-level warning method is established, and the fuzzy comprehensive evaluation method is used to comprehensively evaluate the violations. The evaluation indicators include the number of rule violations, the degree of violation, and the scope of influence, and the weights are set to 0.3, 0.4, and 0.3 respectively. When the evaluation result exceeds the preset warning level threshold, which is 0.6 for mild, 0.75 for moderate, and 0.9 for severe, the corresponding level of warning signal is triggered. The warning information contains the details of the violation, the affected knowledge items, and the suggested correction plan, which are sent to the relevant processing module through the message queue, and the scope and priority of the constraint cluster are updated at the same time. In the implementation process, the C4.5 decision tree algorithm was first applied to the cluster containing 200 constraints, and the information gain threshold was set to 0.1, and 150 logical reasoning rules were generated. The 10,000 knowledge items in the knowledge graph were processed, and the TF-IDF method was used to extract features, and the 1,000 words with the highest word frequency were selected as feature vectors. The naive Bayes algorithm was used for classification, and the knowledge items were assigned to 20 constraint clusters, with a classification accuracy of 85%. Subsequently, the forward chain reasoning algorithm was used to make constraint judgments on the classified knowledge. Starting from 5,000 known facts, 2,000 new facts were generated after an average of 10 rounds of iterations. During this process, 500 knowledge items were found to have violated the constraints, of which 100 exceeded the threshold of 0.8. Fuzzy comprehensive evaluation was performed on these 100 serious violations, and the evaluation matrix was 3x100, which represents the scores of the 100 violations on 3 indicators. The weight vector [0.3, 0.4, 0.3] was applied for weighted calculation to obtain 100 comprehensive scores. Among them, 20 scores exceeded 0.9, triggering severe level warnings; 35 scores were between 0.75 and 0.9, triggering moderate warnings; and 45 scores were between 0.6 and 0.75, triggering mild warnings. Five warning messages were sent per second through the message queue, including the violation rule ID, the affected knowledge item ID, and the automatically generated correction suggestions.At the same time, based on early warning feedback, the scope of application of 30 constraints was reduced by 20%, and the priority of 10 constraints was increased by one level.

[0036] Step S106, monitor and warn based on the graph knowledge nodes and constraint sets, calculate the evaluation score according to the matching of the constraint set and the graph knowledge node, if the evaluation score is lower than the set threshold, isolate the knowledge node and add it to the deletion stack for deletion, trigger the corresponding constraint diffusion and propagation, and update the associated constraint cluster.

[0037] The BERT model is used to extract the feature vector of the knowledge node to obtain the feature vector; the feature vector is normalized to obtain a standardized node feature representation; the cosine similarity algorithm is used to calculate the matching degree of the standardized node feature representation and the constraint set to obtain the node matching degree; the weight factor is set according to the node matching degree, the importance of different constraints is adjusted, and the node evaluation score is obtained; the evaluation score threshold is set, and if the evaluation score of the node is lower than the evaluation score threshold, the isolation program is started to mark the node as a state to be deleted; the node information marked as a state to be deleted is pushed into the deletion stack, and the deletion stack adopts a first-in-last-out deletion order; constraint diffusion and propagation are triggered, and the diffusion process of the constraint condition is simulated using a graph convolutional network algorithm; the constraint condition cluster of the affected node is updated according to the diffusion process of the constraint condition to obtain an updated constraint condition cluster; the updated constraint condition cluster is fed back to the knowledge graph management module through the message queue to update the constraint condition weight in the evaluation system.

[0038] Specifically, according to the structural characteristics and semantic information of the graph knowledge nodes, the BERT model is used to extract the feature vector of the knowledge node, and the feature dimension is set to 768. After L2 normalization, a standardized node feature representation is obtained. The cosine similarity algorithm is used to calculate the matching degree between the feature vector of the knowledge node and the constraint set, and the weight factor is set to adjust the importance of different constraints. The weight factor is determined by historical data analysis, and the evaluation score of the node is obtained by weighted summation. The evaluation score threshold is set, and the initial threshold is set to 0.6. After every 1,000 node evaluations, the threshold is dynamically adjusted according to the evaluation results. When the node evaluation score is lower than the threshold, the isolation program is started to mark the node as a pending deletion state, and the node information is pushed into the deletion stack. The stack structure is used to implement the first-in, last-out deletion order management. The constraint diffusion and propagation mechanism is triggered, and the graph convolutional network algorithm is used to simulate the diffusion process of the constraint condition. The diffusion depth is set to 3 layers, the attenuation factor is set to 0.8, the propagation range and speed are controlled, and the constraint condition cluster of the affected node is updated. The updated constraint condition cluster is fed back to the knowledge graph management module through the message queue, and the constraint condition weight in the evaluation system is updated at the same time. The monitoring frequency is set to once an hour, and a three-level warning mechanism is set according to the evaluation score, including mild 0.4-0.6, moderate 0.2-0.4, and severe <0.2. In the implementation process, the pre-trained BERT-base model is first applied to 10,000 knowledge graph nodes to extract 768-dimensional feature vectors. Each vector is normalized by the L2 norm to make its norm 1. For 100 constraints, the weight factor is determined based on historical data analysis and expert scoring, ranging from 0.5 to 2. The cosine similarity algorithm is used to calculate the matching degree between the node and the constraint condition to obtain a 100-dimensional matching degree vector. The matching degree vector is multiplied by the weight factor, and the sum is obtained to obtain the evaluation score. The initial evaluation threshold is set to 0.6. After processing each 1,000 nodes, the score distribution is calculated, and the threshold is adjusted to the 25th percentile of the current distribution. In the first evaluation, 1,500 nodes were found to have scores below the threshold, and these nodes were marked as pending deletion and pushed into the deletion stack with a capacity of 2,000. The constraint diffusion mechanism is triggered, using a 3-layer graph convolutional network with 64 convolution kernels per layer and ReLU activation function. The decay factor is set to 0.8, and the impact range covers the 3-hop neighbors of the node. The updated constraint affects 3,000 related nodes, and 50 update messages are sent to the knowledge graph management module per second through the message queue. The constraint weights in the evaluation system are adjusted according to the new impact range, with an average change of 15%. The monitoring program triggers a full-graph scan every hour. This scan takes 40 minutes and finds 100 severe warnings with a score <0.2, 300 moderate warnings with a score of 0.2-0.4, and 500 mild warnings with a score of 0.4-0.6.

[0039] Step S107, using the expectation maximization algorithm to perform correlation analysis on the updated constraint condition clusters, iteratively optimizing the constraint condition clusters until the correlation of the constraint condition clusters tends to be stable, and updating the logical reasoning rules and early warning methods according to the optimized constraint condition clusters.

[0040] Get the total number of constraints, take its square root as the initial number of clusters, and use the expectation maximization algorithm to perform correlation analysis. Based on the initial number of clusters, calculate the probability that each constraint belongs to each cluster; update the cluster center and covariance matrix. Using the clustering results, update the correlation strength between the constraints; wherein, the cosine similarity is used to calculate the similarity between the cluster centers. Determine whether the correlation of the constraint cluster has reached a stable state; specifically, calculate the rate of change of the cluster center, the silhouette coefficient, and the Calinski-Harabasz index after two consecutive iterations; if the rate of change of the three indicators is less than the preset threshold, it is determined that a stable state has been reached. Update the logical reasoning rules and early warning methods based on the optimized constraint cluster.

[0041] Specifically, according to the updated constraint clusters, the expectation maximization algorithm is used to perform association analysis. The initial number of clusters is set to the square root of the total number of constraints, and the maximum number of iterations is 100. In the E step (expectation step), the probability of each constraint belonging to each cluster is calculated; in the M step (maximization step), the cluster center and covariance matrix are updated. Using the calculated clustering results, the association strength between the constraints is updated, and the cosine similarity is used to calculate the similarity between the cluster centers. The association strength threshold is initially set to 0.7 and automatically adjusted by 5% every 10 iterations according to the clustering results. To determine whether the association of the constraint clusters has reached a stable state, the change rate of the cluster center, the silhouette coefficient, and the Calinski-Harabasz index after two consecutive iterations are calculated. When the change rate of the three indicators is less than 0.01, it is considered to have reached a stable state, otherwise it returns to the first step to continue iteration. If there is no convergence after 50 iterations or an empty cluster appears, the cluster center is reinitialized and the algorithm is restarted. According to the optimized constraint clusters, the logical reasoning rules and early warning mechanism are updated. The random forest algorithm is used to reconstruct the reasoning rules, including 100 decision trees, and the maximum depth of each tree is 10. The early warning threshold is adjusted and set to the 95th percentile of abnormal data in the past 7 days. The monitoring frequency is set to once every 6 hours, and the consistency and accuracy of the graph knowledge are continuously evaluated, which is achieved by calculating the closure consistency and semantic similarity of the knowledge graph. In the implementation process, the expectation maximization algorithm is first applied to the cluster containing 400 constraints. The initial number of clusters is set to 20, which is approximately the square root of 400. The algorithm converged after 87 iterations. The 400x20 probability matrix was calculated in the E step, and the 20 cluster centers and the corresponding covariance matrix were updated in the M step. When updating the association strength of the constraint, a 20x20 similarity matrix is ​​calculated, and the initial threshold of 0.7 is automatically adjusted to 0.735 at the 30th iteration. In the stability judgment, the cluster center change rate of the last two iterations was 0.008, the silhouette coefficient changed from 0.68 to 0.685, and the Calinski-Harabasz index increased from 1250 to 1255. The change rates of the three indicators were all less than 0.01, reaching a stable state. The optimized constraint cluster was used to update the logical reasoning rules. The random forest algorithm constructed 100 decision trees with an average of 127 nodes per tree. The warning threshold was set to the 14250th largest value based on the 15,000 abnormal data in the past 7 days. The system performs a full scan every 6 hours, which takes an average of 22 minutes. The closure consistency of the knowledge graph was calculated to be 0.92 and the semantic similarity was 0.87.

[0042] Calculate the correlation difference between the current constraint cluster and the previous version cluster, and use the back propagation algorithm to iteratively optimize the model.

[0043] According to the structural characteristics of the current version and the previous version clusters, the principal component analysis method is used to construct a vector representation, and the standardized feature vectors of the two version clusters are obtained through the Z-score normalization method; the difference between the feature vectors of the two version clusters is calculated, the weight factor is determined by the information gain method, the importance of different features is adjusted, and the correlation difference score is obtained by weighted summation; a neural network model is constructed, and the correlation difference score is used as input. The neural network model adopts a four-layer fully connected structure; the neural network model is trained using the back propagation algorithm, the Adam optimizer is used to adaptively adjust the learning rate, and the model parameters are updated by the gradient descent method; if the loss function value is lower than the preset threshold, the optimization is stopped; according to the optimized model, the importance score of each constraint condition is calculated, the constraints with scores lower than the preset threshold are pruned, and the constraint condition cluster structure is updated.

[0044] Specifically, according to the structural characteristics of the current constraint cluster and the previous version cluster, the principal component analysis method is used to construct a vector representation, and the feature dimension is set to 100. The standardized feature vectors of the two version clusters are obtained through Z-score normalization. The difference between the feature vectors of the two version clusters is calculated using the mean square error loss method, and the weight factor is determined by the information gain method. The importance of different features is adjusted, and the correlation difference score is obtained by weighted summation. A neural network model is constructed, and the correlation difference score is used as input. A four-layer fully connected structure is adopted, with 100 neurons in the input layer, 64 and 32 neurons in the two hidden layers, and 1 neuron in the output layer. The ReLU activation function is used to initialize the model parameters. The neural network model is trained using the back propagation algorithm, and the Adam optimizer is used to adaptively adjust the learning rate. The initial learning rate is set to 0.001, and the maximum number of iterations is 1000. The model parameters are updated by the gradient descent method. The optimization is stopped when the loss function value is lower than 0.01 or the maximum number of iterations is reached. If the gradient explodes, gradient clipping is used; if the gradient disappears, the weight of the corresponding layer is reinitialized. According to the optimized model, the importance score of each constraint is calculated, the constraints with scores below the threshold are pruned, and the constraint cluster structure is updated. In the implementation process, the principal component analysis method is first applied to the current cluster containing 500 constraints and the previous version cluster of 450 constraints to extract 100-dimensional feature vectors. Z-score normalization standardizes the feature values ​​to make the mean 0 and the standard deviation 1. The mean square error loss between the two versions is calculated to obtain a 500x450 difference matrix. The weight of each feature is calculated by the information gain method, and the weight range is between 0.005 and 0.025. After weighted summation, the correlation difference score is 0.327. The neural network model is constructed with 100 neurons in the input layer, 64 and 32 neurons in the two hidden layers respectively, and 1 neuron in the output layer. The ReLU activation function is used between all layers. The Adam optimizer is used for training, with an initial learning rate of 0.001 and a decay of 10% every 100 iterations. At the 732nd iteration, the loss function value dropped to 0.0098, which was lower than the threshold of 0.01, and the optimization was stopped. During the training process, the gradient explosion occurred at the 156th iteration, and the maximum gradient value reached 103, which was solved by limiting the gradient to the range of [-1,1]. At the 298th iteration, it was detected that the gradient of the hidden layer was close to 0, and the weight of the layer was reinitialized and the value was set between [-0.1,0.1]. The optimized model calculated the importance scores for 500 constraints, and the scores ranged from 0.02 to 0.98. The threshold was set to 0.3, and 78 constraints below the threshold were pruned. The final updated constraint cluster contained 422 conditions.

[0045] As described above, the above embodiments are only used to illustrate the technical solutions of the present application, rather than to limit them. Although the present application has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein. However, these modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the embodiments of the present application.

Claims

1. A method for constructing a large model patent map with constraints, characterized in that: The method comprises: Construct a TRIZ rule table, match the TRIZ rules of each process by inputting the graph state and the graph building process, form the TRIZ rules of the process into a process TRIZ rule table, match the TRIZ rules according to each process, and obtain the TRIZ rule matching results; According to the TRIZ rule matching results, a hierarchical clustering algorithm is used to analyze the intrinsic properties of the nodes in the graph and the topological structure of the entire graph, and constraint condition clusters of different granularities and levels are obtained. The correlation between the constraints is analyzed and the correlation relationship between the constraint condition clusters is determined. According to the association relationship of the constraint condition cluster, the constraint condition is decomposed into dependent objects and trigger levels, the constraint condition dependency set and trigger sequence are constructed, and the spatiotemporal attributes of the constraint condition dependency set and trigger sequence are obtained, and the spatiotemporal attributes are converted into child nodes of the current version node; According to the spatiotemporal attributes of different version nodes, a relational constraint version tree is constructed. The correlation between constraint conditions is obtained by mapping the version tree nodes in continuous time and space. If the correlation between relational constraint conditions changes, the corresponding constraint diffusion and propagation is triggered, and the associated constraint condition clusters are updated to obtain the updated constraint condition clusters. Convert the updated constraint clusters into logical reasoning rules, classify the knowledge in the graph into constraint clusters, and determine whether the graph knowledge violates the constraint or dependency set based on the logical reasoning rules. If the constraint or dependency set is violated, trigger an early warning. Monitor and warn based on graph knowledge nodes and constraint sets. Calculate the evaluation score based on the matching of constraint sets and graph knowledge nodes. If the evaluation score is lower than the set threshold, isolate the knowledge node and add it to the deletion stack for deletion. At the same time, trigger the corresponding constraint diffusion and propagation, and update the associated constraint cluster. The expectation maximization algorithm is used to perform correlation analysis on the updated constraint clusters, and the constraint clusters are iteratively optimized until the correlation of the constraint clusters tends to be stable. The logical reasoning rules and early warning methods are updated according to the optimized constraint clusters.

2. The method according to claim 1, characterized in that The TRIZ rule table is constructed by matching the TRIZ rules of each process by inputting the graph state and the graph construction process, forming the TRIZ rules of the process into a process TRIZ rule table, performing TRIZ rule matching according to each process, and obtaining a TRIZ rule matching result, including: Use graph neural networks to encode the attributes of graph nodes and edges to obtain a vector representation of the graph state; Calculate the degree of matching between the vector representation of the atlas state and the preset state template vector, and select the template with the highest matching degree as the reference of the current atlas state; Calculate the applicability score of each rule to the current graph state, where the applicability score is obtained by multiplying the matching degree between the rule condition and the graph state feature by the historical application frequency of the rule; Constructing a decision tree based on the suitability score, wherein the decision tree construction process includes feature selection and splitting criterion determination; Using the graph state features as input, traverse the decision tree from top to bottom until the leaf node to determine the final applicable rule subset; Mapping the rule subset to each process in the graph building process to form a complete process TRIZ rule table; The process TRIZ rule table includes a process identifier, a list of applicable rule IDs, and rule application suggestions; If there are conflicting rules in the TRIZ rule table of the process, they are selected according to the rule priority, and a conflict-free and high-coverage rule set is obtained through iterative optimization.

3. The method according to claim 1, characterized in that According to the TRIZ rule matching results, a hierarchical clustering algorithm is used to analyze the intrinsic properties of the nodes in the graph and the topological structure of the entire graph, to obtain constraint condition clusters of different granularities and levels, to analyze the correlation between the constraint conditions, and to determine the correlation relationship between the constraint condition clusters, including: Obtaining intrinsic properties and topological structure characteristics of nodes in the graph, wherein the intrinsic properties and topological structure characteristics are determined according to TRIZ rule matching results; Converting node attributes into numerical vectors, wherein the topological features are quantified by degree centrality and / or clustering coefficient indicators; The Euclidean distance is used to calculate the similarity between nodes and construct a similarity matrix; Cluster the nodes using a hierarchical clustering algorithm to obtain constraint clusters of different granularities; A hierarchical tree is constructed based on the clustering results, and the nodes are merged from the bottom up starting from the leaf nodes. If the average distance between two clusters is less than the preset threshold, the two clusters are merged. The Apriori algorithm is used to analyze the correlation between constraint clusters, and frequent item sets are screened according to the preset minimum support and minimum confidence to generate candidate association rule sets. Calculate the lift of the association rule, where the lift is equal to the confidence divided by the support of the result item; Sort the rules according to the support, confidence and lift of the association rules, and select the top-ranked rules as the association relationship between constraint clusters; A constraint association network diagram is constructed, in which nodes represent clusters, edges represent association relationships, and the thickness of the edges represents the strength of association.

4. The method according to claim 1, characterized in that: According to the association relationship of the constraint condition cluster, the constraint condition is decomposed into dependent objects and trigger levels, the dependency set and trigger sequence of the constraint condition are constructed, and the spatiotemporal attributes of the dependency set and trigger sequence of the constraint condition are obtained, and the spatiotemporal attributes are converted into child nodes of the current version node, including: Calculate the node importance score according to the association relationship of the constraint condition cluster, and determine the dependent object list and the trigger level matrix through the node importance score; Using the dependent object list and the trigger level matrix, a constraint dependency directed graph is constructed, and a trigger sequence is determined using a topological sorting algorithm to obtain a constraint dependency set and a trigger sequence; Calculating the dependency path length and the trigger time interval in the dependency directed graph, and converting the constraint dependency set and the trigger sequence into time series data; Inputting the time series data into a convolutional recurrent neural network for training, wherein the convolutional recurrent neural network comprises a convolutional layer, an LSTM layer and a fully connected layer, extracting the time evolution characteristics and spatial distribution characteristics of constraint dependency and trigger sequence, and obtaining a high-dimensional spatiotemporal attribute vector; For the current version node, the high-dimensional spatiotemporal attribute vector is reduced in dimension by principal component analysis, and the attributes after dimension reduction are clustered by using K-means algorithm to obtain a cluster center set; A sub-node set is generated according to the cluster center set, and the sub-node structure of the current version node is updated by comparing the similarity between the newly generated sub-nodes and the existing sub-nodes.

5. The method according to claim 1, characterized in that According to the spatiotemporal attributes of different version nodes, a relational constraint version tree is constructed, and the correlation between constraint conditions is obtained by mapping the version tree nodes in continuous time and space. If the correlation of relational constraint conditions changes, the corresponding constraint diffusion and propagation is triggered, and the associated constraint condition cluster is updated to obtain the updated constraint condition cluster, including: Constructing a relational constraint version tree, determining the hierarchical structure of the version tree by calculating the Euclidean distance between nodes, and obtaining the version tree with a multi-level structure; According to the nodes in the version tree, the evolution characteristics of the nodes on the continuous time axis are extracted using the ARIMA model to obtain the distribution characteristics of the nodes in the low-dimensional space; If the change in the strength of the association between nodes exceeds the preset threshold, a graph convolutional network is used to simulate the diffusion process of the constraint conditions and calculate the diffusion impact range and intensity; According to the diffusion results, the decision tree algorithm is used to make local adjustments to the clusters, recalculate the internal associations of the clusters, and generate updated constraint condition clusters; If the node position change exceeds the preset change threshold, the affected subtree is reconstructed to ensure that the version tree structure is consistent with the updated constraint condition cluster; The method also includes: classifying the associations between constraints into levels, constructing a propagation level stack, and propagating the constraint changes to each constraint node of the tree in a descending order.

6. The method according to claim 5, characterized in that The above method divides the association between constraints into levels, constructs a propagation level stack, and propagates the constraint changes to each constraint node of the tree in descending order, including: According to the strength of the correlation between the constraints, the K-means clustering algorithm is used to divide the correlation into multiple levels, and the optimal K value is determined by the silhouette coefficient method to obtain the correlation level division result; Using the relevance level division result, a propagation level stack is constructed, wherein the propagation level stack uses a heap data structure to implement a priority queue function, and the constraints with a high relevance level are placed at the top of the stack, and the constraints with a low relevance level are placed at the bottom of the stack; Starting from the top of the propagation level stack, taking out the highly relevant constraints, and searching for the relevant nodes in the tree structure by a depth-first search algorithm, wherein the depth-first search algorithm dynamically adjusts the search depth according to the hierarchical structure of the tree; Introduce a propagation attenuation factor to adjust the influence of the change according to the propagation distance. The propagation attenuation factor is set to the value of the power of the number of propagation layers, and set a time window to limit the propagation range within a unit time. For each affected node, the cumulative effect of the change is calculated. If the cumulative effect exceeds a preset threshold, the node is pushed back into the stack until the stack is empty or the maximum number of iterations is reached.

7. The method according to claim 1, characterized in that The updated constraint clusters are converted into logical reasoning rules, the knowledge in the graph is classified into constraint clusters, and the graph knowledge is judged according to the logical reasoning rules whether it violates the constraint or dependency set. If the constraint or dependency set is violated, an early warning is triggered, including: A decision tree algorithm is used to construct logical reasoning rules, and the algorithm controls the generation granularity of the rules by setting an information gain threshold; According to the logical reasoning rules, the knowledge is classified into constraint clusters using the Naive Bayes algorithm, and the classification uses the TF-IDF method to construct a knowledge vector; For the classified graph knowledge, a forward chain reasoning algorithm is used to judge the constraints and dependencies. The algorithm starts from known facts, matches rule antecedents, triggers rule consequences, and generates new facts. If the new fact violation exceeds the preset threshold, the specific rules and knowledge items violated are recorded; A fuzzy comprehensive evaluation method is used to conduct a comprehensive evaluation of the violated rules and knowledge items. The evaluation method is calculated based on the number of violated rules, the degree of violation, and the scope of impact. If the comprehensive evaluation result exceeds the preset warning level threshold, a warning signal of the corresponding level is triggered, which includes details of the violation of the rules, the affected knowledge items and suggested correction plans.

8. The method according to claim 1, characterized in that: The monitoring and early warning based on the graph knowledge nodes and constraint condition sets are performed, and the evaluation score is calculated according to the matching of the constraint condition set and the graph knowledge node. If the evaluation score is lower than the set threshold, the knowledge node is isolated and added to the deletion stack for deletion, and the corresponding constraint diffusion and propagation are triggered, and the associated constraint condition cluster is updated, including: A BERT model is used to extract a feature vector of a knowledge node to obtain the feature vector; Normalizing the feature vector to obtain a standardized node feature representation; Calculating the matching degree between the standardized node feature representation and the constraint condition set using a cosine similarity algorithm to obtain the matching degree of the node; Set the weight factor according to the matching degree of the node, adjust the importance of different constraints, and obtain the evaluation score of the node; Setting an evaluation score threshold, if the evaluation score of a node is lower than the evaluation score threshold, starting an isolation procedure to mark the node as pending deletion; Push the node information marked as to-be-deleted into a deletion stack, which uses a first-in-last-out deletion order; Trigger constraint diffusion and propagation, and use graph convolutional network algorithms to simulate the diffusion process of constraint conditions; updating the constraint condition cluster of the affected node according to the diffusion process of the constraint condition to obtain an updated constraint condition cluster; The updated constraint condition cluster is fed back to the knowledge graph management module through the message queue to update the constraint condition weights in the evaluation system.

9. The method according to claim 1, characterized in that: The expectation maximization algorithm is used to perform correlation analysis on the updated constraint condition clusters, iteratively optimize the constraint condition clusters until the correlation of the constraint condition clusters tends to be stable, and the logical reasoning rules and early warning methods are updated according to the optimized constraint condition clusters, including: Obtain the total number of constraints, take its square root as the initial number of clusters, and use the expectation maximization algorithm to perform correlation analysis; According to the initial number of clusters, the probability of each constraint condition belonging to each cluster is calculated; Update cluster centers and covariance matrices; Using the clustering results, update the association strength between constraints; Among them, cosine similarity is used to calculate the similarity between cluster centers; Determine whether the correlation of the constraint cluster has reached a stable state; Specifically, it includes calculating the rate of change of cluster centers, silhouette coefficient, and Calinski-Harabasz index after two consecutive iterations; If the change rates of the three indicators are all less than the preset thresholds, it is determined that a stable state has been reached; Update logical reasoning rules and early warning methods based on the optimized constraint condition cluster; It also includes: calculating the correlation difference between the current constraint condition cluster and the previous version cluster, and iteratively optimizing the model using the back propagation algorithm.

10. The method according to claim 9, characterized in that The calculation of the correlation difference between the current constraint condition cluster and the previous version cluster, and iterative optimization of the model using the back propagation algorithm, include: According to the structural characteristics of the current version and the previous version cluster, the principal component analysis method is used to construct a vector representation, and the standardized feature vectors of the two version clusters are obtained through the Z-score normalization method; the difference between the feature vectors of the two version clusters is calculated, and the weight factor is determined by the information gain method, the importance of different features is adjusted, and the correlation difference score is obtained by weighted summation; a neural network model is constructed, and the correlation difference score is used as input. The neural network model adopts a four-layer fully connected structure; the back propagation algorithm is used to train the neural network model, and the Adam optimizer is used to adaptively adjust the learning rate, and the model parameters are updated by the gradient descent method; if the loss function value is lower than the preset threshold value, then stop the optimization; according to the optimized model, calculate the importance score of each constraint condition, The constraints whose scores are lower than a preset threshold are pruned, and the constraint cluster structure is updated.

Images