A knowledge graph-based data classification and grading method

Abstract

The application discloses a data classification and grading method based on a knowledge graph, comprising the following steps: collecting multi-source data of a target data object, and preprocessing to form a multi-source feature set; constructing a knowledge graph, and mapping the multi-source feature set to the knowledge graph; generating a target vector representation according to a neighborhood structure; obtaining a similar data object set based on approximate nearest neighbor search; constructing a dynamic evidence subgraph with the target data object as the center; constructing an improved liquid graph neural network to obtain a category result and a level result; generating a classification and grading label and an explanation evidence chain, and mapping to a governance strategy node. The application realizes consistent and traceable data classification and grading across platforms through semantic modeling of a knowledge graph combined with approximate nearest neighbor search and an improved liquid graph neural network.

Description

Technical Field

[0001] This invention relates to the field of knowledge graph technology, and in particular to a data classification and grading method based on knowledge graphs. Background Technology

[0002] Existing data classification and grading technologies primarily address enterprise-level data asset governance and security compliance needs. Common implementation methods include keyword or regular expression-based identification, field name and metadata dictionary matching, classification models trained on a small number of samples, and manually compiled classification and grading catalog systems. Current solutions typically rely on a single data source or a single feature perspective, making it difficult to cover situations where structured and unstructured data coexist in multi-source heterogeneous data environments, where the same business meaning may have different names and expressions on different platforms, where field annotations are missing or non-standardized, and where data content sampling has significant noise. This leads to low accuracy, weak cross-platform generalization ability, and inconsistent output grades for similar data across different systems. Due to the large scale and continuous changes in data assets, full-volume matching or full-database precise similarity retrieval methods are often computationally expensive and costly to update, making it difficult to support real-time or near-real-time grading requirements in continuous governance scenarios.

[0003] As the data flow during collection, storage, processing, sharing, and external provision becomes increasingly complex, data sensitivity levels are often strongly correlated with data lineage, derivation relationships, sharing behaviors, and access events. Furthermore, there are phenomena of combined sensitivity and propagation sensitivity; that is, a single field or object may not be sensitive in isolation, but may develop a higher risk level after being associated with objects, aggregated along lineage, or shared across domains. In existing technologies, many solutions lack platform-based utilization of relationship and lineage evidence, making it difficult to achieve propagation inference and combined identification of sensitivity levels along relationship paths. Classification and grading outputs often lack interpretable evidence chains and reproducible retrieval criteria, failing to meet the requirements of audit traceability, compliance verification, and closed-loop review. When data models, rule systems, or data relationships change, continuous updates and consistency maintenance are also difficult, thus affecting the stable execution and reliable implementation of data governance strategies.

[0004] Therefore, how to provide a data classification and grading method based on knowledge graphs is a problem that urgently needs to be solved by those skilled in the art. Summary of the Invention

[0005] One objective of this invention is to propose a data classification and grading method based on knowledge graphs. This invention comprehensively utilizes multi-source data fusion, knowledge graph semantic association modeling, approximate nearest neighbor search, and improved liquid graph neural network techniques. It details the entire process from multi-source data acquisition and preprocessing, knowledge graph construction and mapping, vectorized representation generation, similar data object retrieval based on versioned index structures and graph index edge patches, dynamic evidence subgraph construction, to classification and grading inference and strategy output based on continuous evolution graph generators, jump term liquid updates, and uncertainty structures. In terms of retrieval structure, it innovatively introduces versioned index structures and graph index edge patches to support replayable retrieval and incremental updates. In terms of network structure, it innovatively introduces continuous evolution graph generators, jump term liquid updates, and uncertainty structures to achieve propagation inference and rejection review driven by relationship and lineage evidence. Compared with existing technologies, this invention has the advantages of high classification and grading accuracy, good cross-platform consistency, strong interpretability, traceability, and continuous update capabilities, and ease of engineering implementation.

[0006] A data classification and grading method based on knowledge graphs according to an embodiment of the present invention includes: Collect multi-source data of the target data object, preprocess the multi-source data, and form a multi-source feature set; Construct a knowledge graph, mapping the multi-source feature set of the target data object to knowledge graph nodes and edges, and forming associations; Based on the multi-source feature set and the neighborhood structure in the knowledge graph, a target vector representation is generated; Based on approximate nearest neighbor search, retrieval is performed on the target vector representation. A versioned index structure is introduced to solidify and record version identification. Graph index edge patches are introduced for incremental updates to obtain a set of similar data objects. Centered on the target data object, nodes corresponding to sets of similar data objects are incorporated into the knowledge graph to construct a dynamic evidence subgraph; An improved liquid graph neural network is constructed. The dynamic evidence subgraph is input into the continuous evolution graph generator to generate graph structure parameters and edge parameters that change over time. Instantaneous and continuous updates are performed through the liquid update of the jump term. An uncertainty structure is introduced to perform confidence assessment and rejection judgment to obtain category results and grade results. Based on the category and grade results, classification and grading labels and explanatory evidence chains are generated, and the classification and grading labels are mapped to governance strategy nodes to form strategy output.

[0007] Optional data includes content data, metadata, data lineage data, and access sharing event data.

[0008] Optionally, forming a multi-source feature set includes: Obtain multi-source data corresponding to the target data object, perform deduplication and format unification processing on the multi-source data, and generate the original dataset; The original dataset is cleaned, including missing value handling, outlier handling, noise data removal and field normalization. The cleaned data is then encoded, converting text fields into word sequences, categorical fields into discrete codes, and numerical fields into numerical representations with uniform units, generating a clean and encoded dataset. The system performs standardization and structuring on the cleaned and coded dataset. Numerical fields are standardized to have a mean of zero and a variance of one. The lineage transfer data is converted into a set of triplets consisting of source data object identifiers, target data object identifiers, and transfer types. Access sharing event data is converted into an event sequence consisting of event occurrence time, event type, subject identifier, and target data object identifier. The system outputs a multi-source feature set of the target data object.

[0009] Optionally, the construction of the knowledge graph includes: Construct a data model for the knowledge graph, define a set of node types and a set of edge types. The set of node types includes data object nodes, business concept nodes, sensitive information type nodes, compliance rule nodes, and governance strategy nodes. The set of edge types includes semantic relationship edges, lineage transfer edges, and event edges. Define a set of attribute fields and attribute data types for each node type and edge type. Generate knowledge graph nodes and edges based on multi-source feature sets, generate data object nodes for target data objects, generate business concept nodes for business concepts, generate compliance rule nodes for compliance rules, generate governance strategy nodes for governance strategies and write strategy identifiers, names and action sets, establish semantic relationship edges, lineage transfer edges and event edges and write relationship type, direction and time attributes; The knowledge graph is subjected to consistency processing and index construction. Consistency processing includes node identifier deduplication, synonym concept merging, concept hierarchy relationship verification, and edge connection validity verification. Index construction includes building a retrieval index based on node identifier, a type index based on node type, and a relationship index based on edge type. The output is a knowledge graph containing a set of nodes, a set of edges, and an index structure.

[0010] Optionally, the generation of the target vector representation includes: Based on a multi-source feature set, semantic features, content features, and structural features of the target data object are generated. Semantic features are generated from the data object name, annotation information, and mapped business concept identifiers. Content features are generated from sample value patterns, statistical distribution features, and entity recognition results. Structural features are generated from the distribution of neighborhood node types, relationship types, and path identifier set within the hop count range of the target data object in the knowledge graph. The semantic features, content features and structural features are vectorized respectively. The text sequence is input into the text encoding to obtain a fixed-length vector. The numerical statistical features are concatenated according to the dimension to obtain a numerical vector. The discrete identifier is mapped to an embedding vector through an embedding table. The obtained vectors are concatenated in order to form the target vector representation. Perform the same feature generation and vectorization process on historically labeled data objects to obtain the historical vector representation of each historically labeled data object. Then, associate and store the historical vector representation with the corresponding category label, level label, and data object identifier.

[0011] Optionally, obtaining the set of similar data objects includes: Construct a vector index for near nearest neighbor search and perform version management. Version management includes generating index snapshot versions at a preset period or triggering conditions, assigning a unique version identifier to each index snapshot version, writing new vectors, deleted vectors and updated vectors to the change log and storing them in association with the current version identifier, and determining the target version identifier to be used for retrieval when receiving a retrieval request. Perform approximate nearest neighbor retrieval on the target vector representation at the vector index corresponding to the target version identifier, determine the candidate search range based on the target vector representation, generate a candidate vector identifier set within the candidate search range, calculate the similarity of the candidate vectors in the candidate vector identifier set and filter to obtain the first candidate set; Construct a graph index for near nearest neighbor search and perform graph index edge patching updates. The graph index includes a base edge table and an edge patch table. The base edge table stores the set of adjacent edges built offline and is associated with the base edge version identifier. The edge patch table stores newly added edge records, replaced edge records, and deleted edge records added online and is associated with the patch version identifier. When receiving an adjacency update, the update is written to the edge patch table. When performing graph index retrieval on the target vector representation, the adjacent edge set of the base edge table and the adjacent edge update record of the edge patch table are read to generate a merged adjacency relationship set. Based on the merged adjacency relationship set, graph traversal retrieval is performed to obtain the second candidate set. The first and second candidate sets are merged and rearranged. The candidate vector identifier set is deduplicated. The corresponding vectors in the deduplicated candidate vector identifier set are read one by one and the similarity with the target vector representation is calculated. The similarity is sorted from high to low to obtain the set of similar data objects.

[0012] Optionally, constructing the dynamic evidence subgraph includes: In the knowledge graph, the data object node corresponding to the target data object is taken as the central node. The data object nodes corresponding to the similar data object set are merged into the candidate node set of the central node. The node identifier and node type of each candidate node in the candidate node set are recorded as a node list. Starting from the central node, perform neighborhood expansion in the knowledge graph, traverse along semantic relationship edges, bloodline flow edges and event edges to obtain expanded nodes and expanded edges, and add the expanded nodes and expanded edges to the node list and edge list respectively. Event edges in the edge list are sorted in ascending order of event occurrence time to generate an event sequence. Bloodline flow edges are connected according to flow direction to generate a bloodline path set. Semantic relationship edges are grouped according to relationship type and endpoint node type to generate a semantic relationship set. A dynamic evidence subgraph is constructed using the node list, edge list, event sequence, bloodline path set, and semantic relationship set.

[0013] Optionally, obtaining the category results and ranking results includes: An improved liquid graph neural network is constructed, which includes a continuous evolution graph generator, a jump term liquid update unit, and an uncertainty structure. The dynamic evidence subgraph is input into the continuous evolution graph generator, and a graph structure parameter set and an edge parameter set are generated based on the node attributes, edge attributes and event sequences in the dynamic evidence subgraph. The dynamic evidence subgraph is temporally unfolded based on the graph structure parameter set and edge parameter set. Adjacent event time intervals are generated according to the event occurrence time order of the event sequence, and a corresponding time graph structure and time edge parameters are generated for each event time interval. The temporal expansion result is input into the jump term liquid update unit to perform node state update. The node state vector is initialized for each node in the dynamic evidence subgraph. The node state vector at the end of the interval is obtained by performing continuous update on each node within each event time interval. When the corresponding event at the end of the interval is triggered, the node associated with the current event is updated by performing jump update to obtain the node state vector after the event. The category and grade results of the target data object are generated based on the state vector of the node after the event. The category and grade results are input into the uncertainty structure to perform confidence assessment and rejection judgment, and the category confidence value, grade confidence value and rejection mark are output.

[0014] Optionally, the generation of classification and grading labels and explanatory evidence chains includes: Based on the category results, grade results, category confidence value, grade confidence value, and rejection flag, generate classification and grading labels; Generate an explanatory evidence chain and complete the policy mapping. The explanatory evidence chain includes a list of similar data object identifiers, a list of semantic relationship edge identifiers, a list of bloodline transfer edge identifiers, a list of event edge identifiers and corresponding time attributes. The policy mapping includes matching governance policy nodes in the knowledge graph based on category labels and level labels. Record audit traceability data, which includes classification and grading labels, explanatory evidence chains, target version identifiers, base-edge version identifiers and patch version identifiers, a list of similar data object identifiers and dynamic evidence subgraph identifiers. Write the audit traceability data into the audit storage for playback retrieval and playback inference.

[0015] The beneficial effects of this invention are: This invention enhances the automation capabilities of data classification and grading in scenarios involving multi-source heterogeneity and cross-platform semantic inconsistencies by fusing multi-source data and leveraging knowledge graphs to achieve semantic alignment and relationship modeling. Compared to existing solutions that rely on keyword matching or single models, this invention utilizes multi-source feature sets and knowledge graph neighborhood structures to generate unified vector representations. It also employs an approximate nearest neighbor search with versioned index structures and graph index edge patches to achieve efficient similar object retrieval and incremental updates. This reduces the cost of precise full-database retrieval and frequent reconstruction, ensuring higher consistency and reproducibility of classification and grading results across different systems and time versions, thereby improving accuracy and generalization performance.

[0016] This invention utilizes dynamic evidence subgraphs and an improved liquid graph neural network to achieve propagation inference and combination recognition driven by relationship and lineage evidence, enhancing the temporal sensitivity and audit traceability of hierarchical decision-making. A continuous evolution graph generator generates graph structure parameters and edge parameters that change over time. Jump term liquid updates provide instantaneous responses to risk changes triggered by key events and continuously evolve within non-event intervals. An uncertainty structure performs confidence assessments and rejection decisions on the output, thereby triggering a review process in cases of insufficient or conflicting evidence. Simultaneously, by combining audit records with explanatory evidence chains, index version identifiers, and edge patch version identifiers, replay retrieval and replay inference are achieved, supporting continuous updates and closed-loop governance to meet the needs of compliance audits and engineering implementation. Attached Figure Description

[0017] The accompanying drawings are provided to further illustrate the invention and form part of the specification. They are used in conjunction with embodiments of the invention to explain the invention and do not constitute a limitation thereof. In the drawings: Figure 1 This is a flowchart of a knowledge graph-based data classification and grading method proposed in this invention; Figure 2 This is a structural block diagram of the approximate nearest neighbor search of a knowledge graph-based data classification and grading method proposed in this invention; Figure 3 This is a functional schematic diagram of an improved liquid graph neural network for a knowledge graph-based data classification and grading method proposed in this invention. Detailed Implementation

[0018] The present invention will now be described in further detail with reference to the accompanying drawings. These drawings are simplified schematic diagrams, illustrating only the basic structure of the invention, and therefore only show the components relevant to the invention.

[0019] refer to Figure 1 , Figure 2 and Figure 3 A knowledge graph-based data classification and grading method includes: Collect multi-source data of the target data object, preprocess the multi-source data, and form a multi-source feature set; Construct a knowledge graph, mapping the multi-source feature set of the target data object to knowledge graph nodes and edges, and forming associations; Based on the multi-source feature set and the neighborhood structure in the knowledge graph, a target vector representation is generated; Based on approximate nearest neighbor search, retrieval is performed on the target vector representation. A versioned index structure is introduced to solidify and record version identification. Graph index edge patches are introduced for incremental updates to obtain a set of similar data objects. Centered on the target data object, nodes corresponding to sets of similar data objects are incorporated into the knowledge graph to construct a dynamic evidence subgraph; An improved liquid graph neural network is constructed. The dynamic evidence subgraph is input into the continuous evolution graph generator to generate graph structure parameters and edge parameters that change over time. Instantaneous and continuous updates are performed through the liquid update of the jump term. An uncertainty structure is introduced to perform confidence assessment and rejection judgment to obtain category results and grade results. Based on the category and grade results, classification and grading labels and explanatory evidence chains are generated, and the classification and grading labels are mapped to governance strategy nodes to form strategy output.

[0020] This implementation includes content data, metadata, data lineage data, and access sharing event data.

[0021] In this embodiment, forming a multi-source feature set includes: Obtain multi-source data corresponding to the target data object, perform deduplication and format unification processing on the multi-source data, and generate the original dataset; The original dataset undergoes cleaning, including handling missing values, outlier removal, noise data elimination, and field normalization. The cleaned data is then encoded, converting text fields into word sequences, categorical fields into discrete codes, and numerical fields into uniform numerical representations, generating a cleaned and encoded dataset. The cleaned data is encoded as follows: Records are divided into three categories according to field type: text, categorical, and numeric. Encoding configurations are generated for each field. Text fields are unified in terms of full-width and half-width characters, capitalization, and control characters are removed. Word segments are generated using spaces, punctuation, underscores, and camelCase breaks as segmentation boundaries. Numeric fields are converted to a unified unit after unit conversion. The minimum and maximum values ​​are calculated for each numeric field. Interval normalization is applied. The normalized value is equal to the current value minus the minimum value and then divided by the maximum value minus the minimum value. When the maximum value equals the minimum value, the normalized value is 0. The encoding results of each field are combined in the field order to form a cleaned and encoded dataset. The categorical field is converted into discrete codes. Specifically, the frequency of each category value in the dataset is counted. Categories with a frequency of at least 1% are defined as high-frequency categories. All high-frequency categories are assigned consecutive integer codes starting from the beginning according to their frequency of occurrence from high to low. Categories with a frequency of occurrence of less than 1% are uniformly encoded as zero. Missing values ​​are encoded as negative one. When a new category value not included in the mapping table appears, the new category value is temporarily encoded as zero and recorded as a category to be updated. The statistics are recalculated and the codes are assigned according to the same rules during the next mapping table update. The system performs standardization and structuring on the cleaned and coded dataset. Numerical fields are standardized to have a mean of zero and a variance of one. The lineage transfer data is converted into a set of triplets consisting of source data object identifiers, target data object identifiers, and transfer types. Access sharing event data is converted into an event sequence consisting of event occurrence time, event type, subject identifier, and target data object identifier. The system outputs a multi-source feature set of the target data object.

[0022] In this embodiment, the construction of the knowledge graph includes: Construct a data model for the knowledge graph, define a set of node types and a set of edge types. The set of node types includes data object nodes, business concept nodes, sensitive information type nodes, compliance rule nodes, and governance strategy nodes. The set of edge types includes semantic relationship edges, lineage transfer edges, and event edges. Define a set of attribute fields and attribute data types for each node type and edge type. Knowledge graph nodes and edges are generated based on multi-source feature sets. Data object nodes are generated for target data objects, business concept nodes for business concepts, compliance rule nodes for compliance rules, and governance strategy nodes for governance strategies, with strategy identifiers, names, and action sets written into them. Semantic relationship edges, lineage transfer edges, and event edges are established, with relationship type, direction, and time attributes written into them. Specifically, the generation of knowledge graph nodes and edges based on multi-source feature sets involves: Create a data object node with the target data object identifier and write its name, type, and attributes. Extract candidate business concept terms from the multi-source feature set and calculate the matching score with the business concept term library. The matching score is the average of the edit distance similarity and the cosine similarity. If the score is not lower than 0.85, associate it with an existing business concept node; otherwise, create a new business concept node. Generate or associate compliance rule nodes based on the rule hit results. Generate governance strategy nodes based on the strategy configuration and write the strategy identifier, name, and action set. Establish semantic relationship edges to connect data object nodes and business concept nodes and write the relationship type and direction. Establish lineage flow edges one by one according to the lineage flow triplet and write the direction and occurrence time. Establish event edges one by one according to the event sequence to connect subject nodes and data object nodes and write the direction and event occurrence time. Consistency processing and index construction are performed on the knowledge graph. Consistency processing includes node identifier deduplication, merging of synonymous concepts, validation of concept hierarchy relationships, and validation of edge connection validity. Index construction includes building a retrieval index based on node identifiers, a type index based on node types, and a relationship index based on edge types. The output is a knowledge graph containing a set of nodes, a set of edges, and an index structure. Specifically, consistency processing and index construction on the knowledge graph are performed as follows: The node set is deduplicated based on node identifiers. For duplicate identifiers, only the node with the latest update time is retained, and the references of the remaining nodes are redirected to the retained nodes. For each pair of business concept nodes, a synonym score is calculated. The synonym score is the average of the name edit distance similarity and the cosine similarity of the concept vector. If the synonym score is not lower than 0.90, the nodes are merged and the inbound and outbound edges are redirected. Directed cycle detection is performed on the concept hierarchy relationship. If a cycle is detected, the latest level edge in the cycle is deleted. The legality of each edge connection is verified. It is required that the start and end node identifiers of the edge exist and the edge type and the end node type satisfy the matching table. If not, the edge is deleted. Indexes are constructed, including a retrieval index from node identifier to node record, a type index from node type to node identifier list, and a relationship index from edge type to edge record list. The knowledge graph is then output.

[0023] In this embodiment, the generation of the target vector representation includes: Based on a multi-source feature set, semantic features, content features, and structural features of the target data object are generated. Semantic features are generated from the data object name, annotation information, and mapped business concept identifiers. Content features are generated from sample value patterns, statistical distribution features, and entity recognition results. Structural features are generated from the distribution of neighborhood node types, relationship types, and path identifier set within the hop count range of the target data object in the knowledge graph. Semantic features, content features, and structural features are each vectorized. The text sequence is input into text encoding to obtain a fixed-length vector. Numerical statistical features are concatenated according to dimension to obtain a numerical vector. Discrete identifiers are mapped to embedding vectors through an embedding table. The resulting vectors are then concatenated sequentially to form the target vector representation, where: The text sequence is input into text encoding to obtain a fixed-length vector. Specifically, the text sequence is segmented into words to obtain a word sequence. The maximum length is set to 128 words. Words exceeding 128 words are truncated, and words less than 128 words are padded with padding characters at the end. Each word is converted into a word number according to the vocabulary list, and a position number corresponding to the word position is generated. The word number sequence and the position number sequence are input into text encoding to obtain the hidden representation of each position. The hidden representations of all positions are averaged along the dimension to obtain a fixed-length vector. The average is calculated by summing the position values ​​of each position in the same dimension and dividing by 128, which is used as the text encoding result. Discrete identifiers are mapped to embedding vectors through an embedding table. Specifically, an embedding table is established for each type of discrete identifier. The embedding table consists of row vectors, with each row corresponding to a discrete encoded integer. The vector dimension is fixed. The discrete identifier is first converted into the corresponding discrete encoded integer. The current row vector is read from the embedding table as the embedding vector, using the integer as the row index. For new discrete codes that are not in the mapping table, they are uniformly mapped to unknown rows and the unknown row vector is read. When the same record contains a discrete identifier, the corresponding embedding vectors are read in the field order and concatenated to form a discrete embedding representation. Perform the same feature generation and vectorization process on historically labeled data objects to obtain the historical vector representation of each historically labeled data object. Then, associate and store the historical vector representation with the corresponding category label, level label, and data object identifier.

[0024] In this embodiment, obtaining a set of similar data objects includes: A vector index for near-nearest neighbor search is constructed and versioned management is performed. Versioning management includes generating index snapshot versions at preset periods or trigger conditions, assigning a unique version identifier to each index snapshot version, writing newly added, deleted, and updated vectors to a change log and storing them in association with the current version identifier, and determining the target version identifier for the search when a search request is received. Specifically, generating index snapshot versions at preset periods or trigger conditions involves: Set the snapshot period to seven days. When the period expires, the current vector index structure and vector identifier mapping will be solidified into a snapshot and a new version identifier will be generated. At the same time, set the trigger conditions as follows: the total number of change log records reaches one million, the number of newly added vectors reaches one hundred thousand, or the ratio of updates and deletions reaches 30%. The ratio is calculated by dividing the sum of the number of updated and deleted records by the total number of log records. If any trigger condition is met, the index writing will be frozen, the change log will be applied to the index in the order of records and verified before a snapshot is generated. After completion, the solidified part of the change log will be archived and the new version identifier will be enabled. Approximate nearest neighbor retrieval is performed on the target vector representation at the vector index corresponding to the target version identifier. A candidate search range is determined based on the target vector representation. A candidate vector identifier set is generated within the candidate search range. The similarity of candidate vectors in the candidate vector identifier set is calculated, and the first candidate set is obtained by filtering. Where: The candidate search range is determined based on the target vector representation. A candidate vector identifier set is generated within the candidate search range. Specifically, the pre-stored cluster center set is read from the vector index. The Euclidean distance between the target vector representation and each cluster center is calculated. The ten cluster centers with the smallest distance are selected as the candidate cluster set. The inverted list corresponding to the candidate cluster set is used as the candidate search range. The vector identifiers in the ten inverted lists are combined and deduplicated to obtain the candidate vector identifier set. When the number of candidate vector identifiers exceeds 200,000, the first 20,000 vector identifiers of each inverted list are truncated in ascending order according to the coarse distance pre-stored in the inverted list, and then combined and deduplicated to ensure that the number of candidate vector identifiers does not exceed 200,000. The similarity of candidate vectors in the candidate vector identifier set is calculated and the first candidate set is obtained by filtering. Specifically, the candidate vectors corresponding to the candidate vector identifiers are read one by one, and the cosine similarity is calculated with the target vector representation. The cosine similarity is calculated by dividing the dot product of the two vectors by the product of the norms of the two vectors. All candidate vectors are sorted from high to low according to the cosine similarity. The first thousand vector identifiers are selected as the first candidate set. When the highest similarity in the first candidate set is less than 0.6, the first candidate set is expanded to the first two thousand vector identifiers and the corresponding similarity value is output. A graph index for approximate nearest neighbor search is constructed, and edge patching updates are performed. The graph index includes a base edge table and an edge patch table. The base edge table stores the set of adjacent edges constructed offline and is associated with the base edge version identifier. The edge patch table stores newly added, replaced, and deleted edge records added online and is associated with the patch version identifier. When an adjacency update is received, the update is written to the edge patch table. Specifically, the graph index edge patching update is performed as follows: The system receives adjacency update requests. Each update request includes a start vector identifier, an end vector identifier, an update type, and a timestamp. When the update type is to add an edge, the start vector identifier and end vector identifier are written to the edge patch table and marked as new records. When the update type is to replace an edge, the system first queries the edge patch table for the existing valid adjacency record corresponding to the start vector identifier and marks it as invalid. Then, it writes the new start vector identifier and end vector identifier and marks it as a replacement record. When the update type is to delete an edge, the system writes the start vector identifier and end vector identifier to the edge patch table and marks it as a deleted record. Each patch record is assigned an incrementing sequence number and associated with a patch version identifier. The patch version identifier is generated on a rolling basis when the number of patch records reaches one million or the cumulative time reaches seven days. When the patch is rolled over, the current patch version identifier is sealed and a new patch version identifier is enabled. When performing graph index retrieval on the target vector representation, the adjacent edge set of the base edge table and the adjacent edge update records of the edge patch table are read to generate a merged adjacency relationship set. A graph traversal retrieval is then performed based on this merged adjacency relationship set to obtain a second candidate set. Specifically, the graph traversal retrieval based on the merged adjacency relationship set to obtain the second candidate set involves: Select a preset set of entry nodes from the base edge table, with five entry nodes. Calculate the cosine similarity between the target vector representation and each entry node vector, and select the entry node with the highest similarity as the starting node. Iterate through the merged adjacency set, maintaining a candidate queue and a visited set. The candidate queue initially contains the starting node and records the similarity. Each time, take the node with the highest similarity from the candidate queue as the current node. Read the set of adjacent nodes of the current node and calculate the cosine similarity between the unvisited adjacent nodes and the target vector representation. Add adjacent nodes with a similarity of not less than 0.5 to the candidate queue and the visited set. Stop traversing when the number of visited nodes reaches 10,000 or the candidate queue is empty. Sort the nodes in the visited set in descending order of cosine similarity and extract the first 1,000 nodes as the second candidate set. The first and second candidate sets are merged and rearranged. The candidate vector identifier set is deduplicated. The corresponding vectors in the deduplicated candidate vector identifier set are read one by one and the similarity with the target vector representation is calculated. The similarity is sorted from high to low to obtain the set of similar data objects.

[0025] In this embodiment, constructing the dynamic evidence subgraph includes: In the knowledge graph, the data object node corresponding to the target data object is taken as the central node. The data object nodes corresponding to the similar data object set are merged into the candidate node set of the central node. The node identifier and node type of each candidate node in the candidate node set are recorded as a node list. Starting from the central node, neighborhood expansion is performed in the knowledge graph. This involves traversing along semantic relationship edges, lineage transfer edges, and event edges to obtain expanded nodes and edges. These expanded nodes and edges are then added to the node list and edge list, respectively. Specifically, the neighborhood expansion process starting from the central node involves: The algorithm employs breadth-first traversal with a maximum hop count of three. It initializes the current layer node set as the center node and adds it to the node list. During each hop traversal, it reads the semantic relationship edges, lineage flow edges, and event edges connected to the current layer node set one by one. Edges that satisfy the edge type belonging to the three edge sets are added to the edge list, and the other end node of the edge is added to the next layer node set. To control the scale, an expansion limit is set, allowing a maximum of fifty edges to be expanded for each node. When the number of edges associated with a node exceeds fifty, the first fifty edges are retained in order of time attribute from near to far. Edges with empty time attributes are placed at the end. This process is repeated until the three-hop expansion is completed or the next layer node set is empty. Finally, the node list and edge list are output. Event edges in the edge list are sorted in ascending order of event occurrence time to generate an event sequence. Bloodline flow edges are connected according to flow direction to generate a bloodline path set. Semantic relationship edges are grouped according to relationship type and endpoint node type to generate a semantic relationship set. A dynamic evidence subgraph is constructed using the node list, edge list, event sequence, bloodline path set, and semantic relationship set.

[0026] In this embodiment, obtaining the category result and the grade result includes: An improved liquid graph neural network is constructed, comprising a continuous evolution graph generator, a jump term liquid update unit, and an uncertainty structure. Specifically, the construction of the improved liquid graph neural network involves: A continuous evolution graph generator is constructed, taking node attributes, edge attributes, and time-ordered event sequences as input. Event time intervals are divided according to the timestamps of adjacent events. When the time interval exceeds 300 seconds, a split point is inserted at 300 seconds. Each time interval is mapped to the corresponding graph structure parameters and edge parameters. A jump term liquid update unit is then constructed to initialize the state vector for each node. Continuous updates are performed within each time interval based on node attributes and adjacency aggregation messages. When an event occurs at the end of the interval, a jump update is performed based on the event type code and the target node state. Finally, an uncertainty structure is constructed. After class and grade outputs, class confidence values ​​and grade confidence values ​​are calculated, and a rejection threshold of 0.6 is set. If any confidence value is less than 0.6, a rejection flag of 1 is output; otherwise, it is 0, forming an improved liquid graph neural network. The dynamic evidence subgraph is input into the continuous evolution graph generator. Based on the node attributes, edge attributes, and event sequences in the dynamic evidence subgraph, a graph structure parameter set and an edge parameter set are generated. Specifically, the generation of the graph structure parameter set and edge parameter set based on the node attributes, edge attributes, and event sequences in the dynamic evidence subgraph is as follows: The event sequence is arranged in ascending order of time and divided into time intervals by adjacent event timestamps. When the time interval exceeds 300 seconds, a sub-interval is formed by inserting a 300-second dividing point. For each time interval, the edges that are effective before the start time of the interval are used as the basic edge set. The basic edge set is updated according to the new, deleted and replaced events in the interval to obtain the time edge set. The edge connection pairs and edge existence markers of the time edge set are summarized into a graph structure parameter set. Edge parameters are generated for each time edge. The edge type and edge direction are converted into discrete codes. The edge weight is the sum of the number of lineages, the number of sharings and the number of visits divided by 100. The time decay coefficient is obtained by dividing the number of seconds after the event occurs by 3600 and taking the exponential decay. The edge parameters of each time interval are summarized to form an edge parameter set. The dynamic evidence subgraph is temporally unfolded based on the graph structure parameter set and edge parameter set. Adjacent event time intervals are generated according to the event occurrence time order of the event sequence, and a corresponding time graph structure and time edge parameters are generated for each event time interval. The temporal expansion result is input into the jump term liquid update unit to perform node state update. The node state vector is initialized for each node in the dynamic evidence subgraph. The node state vector at the end of the interval is obtained by performing continuous update on each node within each event time interval. When the corresponding event at the end of the interval is triggered, the node associated with the current event is updated by performing jump update to obtain the node state vector after the event. Based on the post-event node state vector, the category and grade results of the target data object are generated. These results are then input into an uncertainty structure to perform confidence assessment and rejection determination. The outputs are the category confidence value, grade confidence value, and rejection flag, where: The method for generating category and grade results for target data objects based on the node state vectors after an event is as follows: The node state vector of the target data object after the end of the last event time interval is taken as input and fed into the category output head and grade output head respectively. The category output head performs a linear transformation on the node state vector to obtain the score vectors of each category, normalizes the score vectors to obtain the probability distribution of each category, and selects the category with the highest probability as the category result. The grade output head performs a linear transformation on the node state vector to obtain the score vectors of each grade, normalizes the score vectors to obtain the probability distribution of each grade, and selects the grade with the highest probability as the grade result. The category and rank results are input into the uncertainty structure to perform confidence assessment and rejection determination. Specifically, the uncertainty structure reads the category probability distribution and rank probability distribution respectively, defines the category confidence value as the maximum probability in the category probability distribution, defines the rank confidence value as the maximum probability in the rank probability distribution, sets the rejection threshold to 0.6, and outputs a rejection flag of 1 when the category confidence value is less than 0.6 or the rank confidence value is less than 0.6, otherwise outputs a rejection flag of 0, and outputs the category confidence value and the rank confidence value.

[0027] In this embodiment, the generation of classification and grading labels and explanatory evidence chains includes: Based on the category results, grade results, category confidence value, grade confidence value, and rejection flag, generate classification and grading labels; Generate an explanatory evidence chain and complete the policy mapping. The explanatory evidence chain includes a list of similar data object identifiers, a list of semantic relationship edge identifiers, a list of bloodline transfer edge identifiers, a list of event edge identifiers and corresponding time attributes. The policy mapping includes matching governance policy nodes in the knowledge graph based on category labels and level labels. Record audit traceability data, which includes classification and grading labels, explanatory evidence chains, target version identifiers, base-edge version identifiers and patch version identifiers, a list of similar data object identifiers and dynamic evidence subgraph identifiers. Write the audit traceability data into the audit storage for playback retrieval and playback inference.

[0028] Example 1: To verify the feasibility of this invention in practice, it was applied to a data governance scenario in a large enterprise. Data assets are scattered across multiple business systems and data platforms, including structured tables and fields, as well as interface return fields, logs, and unstructured data from business documents. The same business meaning exhibits different naming conventions, annotation habits, and value formats across different platforms. Furthermore, data is constantly derived and combined during extraction, cleaning, aggregation, sharing, and external distribution, making it difficult to reliably determine categories and levels using only keyword rules or single models. This frequently results in inconsistent classifications of similar data across different systems, data becoming sensitive only after combination but failing to be identifiable, and difficulties in reproducing the initial determination during audits. Currently, the enterprise has accumulated a batch of manually labeled samples, but the sample coverage is limited and updates are lagging. Data lineage and access sharing events are constantly changing, making traditional solutions poorly generalizable when adding new data objects and migrating across platforms. The burden of manual review is heavy, and governance strategies are difficult to implement automatically in a closed loop.

[0029] When applying this invention in the current scenario, multi-source data of data objects are formed into a multi-source feature set, and data objects, business concepts, sensitive information types, compliance rules, and governance strategies are mapped to a knowledge graph to establish semantic relationships, lineage flow, and event relationships. A target vector representation is generated for each data object, and an approximate nearest neighbor search index is constructed for candidate recall. A versioned index structure is used to form a replayable index snapshot and version identifier. Incremental updates to similarity relationships are performed through graph index edge patching, enabling newly added fields, changes in derivation links, and newly emerging similar patterns to be quickly reflected in the search results. After returning to the set of similar data objects, the target data object and similar objects, along with their semantic, kinship, and event associations in the knowledge graph, are incorporated into the same local subgraph to construct a dynamic evidence subgraph. The dynamic evidence subgraph is then input into an improved liquid graph neural network, where a continuous evolution graph generator generates graph structure parameters and edge parameters that change over time. Jump term liquid updates trigger instantaneous updates when key events occur and perform continuous updates within event intervals. An uncertainty structure performs confidence assessment on the output and outputs a rejection flag when the confidence is insufficient. Rejected samples undergo manual review and are written back to the graph and index versions, forming a continuously updated closed loop.

[0030] During large-scale trial operation, the data objects included in the governance cover various forms such as structured fields, interface fields, and document entries, with the cumulative number of objects reaching millions. The number of cross-platform synonym fields, synonym concept mappings, and lineage derivation links also reached millions, and the daily increase in access sharing events was in the hundreds of thousands range. Under the current load, the present invention can stably output categories and levels in a single retrieval and inference process, and simultaneously generate traceable explanatory evidence chains and index version information, enabling audit reproduction to be completed in minutes without relying on manual recall or rerunning the full task.

[0031] Table 1 Comparison of Classification and Grading Effects with Engineering Indicators

[0032] As shown in Table 1, in terms of overall recognition capability, this invention exhibits the most stable performance across key performance indicators, achieving an accuracy of 92% and a recall of 89%. This indicates that in data environments with diverse sources, heterogeneous structures, and significant differences in naming across platforms, this solution can not only more accurately determine categories and levels but also more fully cover objects that should be identified, reducing the classification gaps caused by missed detections. Compared to traditional rules or single models, which are prone to fluctuations due to field naming, missing annotations, and sample bias, the output of this invention is closer to stable judgment results under a unified standard.

[0033] In terms of cross-platform consistency and complex risk identification, this invention achieves a cross-platform consistency rate of 93%, significantly outperforming common comparative solutions. This means that even if the same business meaning exists in different ways on different platforms, the final classification and grading conclusions are more likely to remain consistent, reducing management conflicts between different levels of the same type during governance implementation. This invention achieves a combined sensitivity detection rate of 86%, which can better identify situations where a single field is not sensitive but becomes sensitive when combined. Coupled with a higher interpretable coverage rate, it outputs key evidence chains in a traceable manner, facilitating audit verification and review closure.

[0034] From an engineering feasibility perspective, this invention maintains high effectiveness while reducing incremental update time to 18 minutes. This allows new data assets, changes in lineage, and changes in sharing behavior to be reflected in the latest judgment results more quickly, reducing the lag window of the governance platform. Although the single-object inference latency is 78ms, update efficiency and replayability are more critical in continuous governance scenarios. This invention achieves a better balance between update window and traceability, making it suitable for large-scale, continuously iterative enterprise data governance operations.

[0035] The above description is only a preferred embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any equivalent substitutions or modifications made by those skilled in the art within the scope of the technology disclosed in the present invention, based on the technical solution and inventive concept of the present invention, should be covered within the scope of protection of the present invention.

Claims

1. A data classification and grading method based on knowledge graphs, characterized in that, include: Collect multi-source data of the target data object, preprocess the multi-source data, and form a multi-source feature set; Construct a knowledge graph, mapping the multi-source feature set of the target data object to knowledge graph nodes and edges, and forming associations; Based on the multi-source feature set and the neighborhood structure in the knowledge graph, a target vector representation is generated; Based on approximate nearest neighbor search, retrieval is performed on the target vector representation. A versioned index structure is introduced to solidify and record version identification. Graph index edge patches are introduced for incremental updates to obtain a set of similar data objects. Centered on the target data object, nodes corresponding to sets of similar data objects are incorporated into the knowledge graph to construct a dynamic evidence subgraph; An improved liquid graph neural network is constructed. The dynamic evidence subgraph is input into the continuous evolution graph generator to generate graph structure parameters and edge parameters that change over time. Instantaneous and continuous updates are performed through the liquid update of the jump term. An uncertainty structure is introduced to perform confidence assessment and rejection judgment to obtain category results and grade results. Based on the category and grade results, classification and grading labels and explanatory evidence chains are generated, and the classification and grading labels are mapped to governance strategy nodes to form strategy output.

2. The data classification and grading method based on knowledge graphs according to claim 1, characterized in that, The multi-source data includes content data, metadata, data lineage data, and access sharing event data.

3. The data classification and grading method based on knowledge graphs according to claim 1, characterized in that, The formation of the multi-source feature set includes: Obtain multi-source data corresponding to the target data object, perform deduplication and format unification processing on the multi-source data, and generate the original dataset; The original dataset is cleaned, including missing value handling, outlier handling, noise data removal and field normalization. The cleaned data is then encoded, converting text fields into word sequences, categorical fields into discrete codes, and numerical fields into numerical representations with uniform units, generating a clean and encoded dataset. The system performs standardization and structuring on the cleaned and coded dataset. Numerical fields are standardized to have a mean of zero and a variance of one. The lineage transfer data is converted into a set of triplets consisting of source data object identifiers, target data object identifiers, and transfer types. Access sharing event data is converted into an event sequence consisting of event occurrence time, event type, subject identifier, and target data object identifier. The system outputs a multi-source feature set of the target data object.

4. The data classification and grading method based on knowledge graphs according to claim 1, characterized in that, The construction of the knowledge graph includes: Construct a data model for the knowledge graph, define a set of node types and a set of edge types. The set of node types includes data object nodes, business concept nodes, sensitive information type nodes, compliance rule nodes, and governance strategy nodes. The set of edge types includes semantic relationship edges, lineage transfer edges, and event edges. Define a set of attribute fields and attribute data types for each node type and edge type. Generate knowledge graph nodes and edges based on multi-source feature sets, generate data object nodes for target data objects, generate business concept nodes for business concepts, generate compliance rule nodes for compliance rules, generate governance strategy nodes for governance strategies and write strategy identifiers, names and action sets, establish semantic relationship edges, lineage transfer edges and event edges and write relationship type, direction and time attributes; The knowledge graph is subjected to consistency processing and index construction. Consistency processing includes node identifier deduplication, synonym concept merging, concept hierarchy relationship verification, and edge connection validity verification. Index construction includes building a retrieval index based on node identifier, a type index based on node type, and a relationship index based on edge type. The output is a knowledge graph containing a set of nodes, a set of edges, and an index structure.

5. The data classification and grading method based on knowledge graphs according to claim 1, characterized in that, The generated target vector representation includes: Based on a multi-source feature set, semantic features, content features, and structural features of the target data object are generated. Semantic features are generated from the data object name, annotation information, and mapped business concept identifiers. Content features are generated from sample value patterns, statistical distribution features, and entity recognition results. Structural features are generated from the distribution of neighborhood node types, relationship types, and path identifier set within the hop count range of the target data object in the knowledge graph. The semantic features, content features and structural features are vectorized respectively. The text sequence is input into the text encoding to obtain a fixed-length vector. The numerical statistical features are concatenated according to the dimension to obtain a numerical vector. The discrete identifier is mapped to an embedding vector through an embedding table. The obtained vectors are concatenated in order to form the target vector representation. Perform the same feature generation and vectorization process on historically labeled data objects to obtain the historical vector representation of each historically labeled data object. Then, associate and store the historical vector representation with the corresponding category label, level label, and data object identifier.

6. The data classification and grading method based on knowledge graphs according to claim 1, characterized in that, The obtained set of similar data objects includes: Construct a vector index for near nearest neighbor search and perform version management. Version management includes generating index snapshot versions at a preset period or triggering conditions, assigning a unique version identifier to each index snapshot version, writing new vectors, deleted vectors and updated vectors to the change log and storing them in association with the current version identifier, and determining the target version identifier to be used for retrieval when receiving a retrieval request. Perform approximate nearest neighbor retrieval on the target vector representation at the vector index corresponding to the target version identifier, determine the candidate search range based on the target vector representation, generate a candidate vector identifier set within the candidate search range, calculate the similarity of the candidate vectors in the candidate vector identifier set and filter to obtain the first candidate set; Construct a graph index for near nearest neighbor search and perform graph index edge patching updates. The graph index includes a base edge table and an edge patch table. The base edge table stores the set of adjacent edges built offline and is associated with the base edge version identifier. The edge patch table stores newly added edge records, replaced edge records, and deleted edge records added online and is associated with the patch version identifier. When receiving an adjacency update, the update is written to the edge patch table. When performing graph index retrieval on the target vector representation, the adjacent edge set of the base edge table and the adjacent edge update record of the edge patch table are read to generate a merged adjacency relationship set. Based on the merged adjacency relationship set, graph traversal retrieval is performed to obtain the second candidate set. The first and second candidate sets are merged and rearranged. The candidate vector identifier set is deduplicated. The corresponding vectors in the deduplicated candidate vector identifier set are read one by one and the similarity with the target vector representation is calculated. The similarity is sorted from high to low to obtain the set of similar data objects.

7. The data classification and grading method based on knowledge graphs according to claim 1, characterized in that, The construction of the dynamic evidence subgraph includes: In the knowledge graph, the data object node corresponding to the target data object is taken as the central node. The data object nodes corresponding to the similar data object set are merged into the candidate node set of the central node. The node identifier and node type of each candidate node in the candidate node set are recorded as a node list. Starting from the central node, perform neighborhood expansion in the knowledge graph, traverse along semantic relationship edges, bloodline flow edges and event edges to obtain expanded nodes and expanded edges, and add the expanded nodes and expanded edges to the node list and edge list respectively. Event edges in the edge list are sorted in ascending order of event occurrence time to generate an event sequence. Bloodline flow edges are connected according to flow direction to generate a bloodline path set. Semantic relationship edges are grouped according to relationship type and endpoint node type to generate a semantic relationship set. A dynamic evidence subgraph is constructed using the node list, edge list, event sequence, bloodline path set, and semantic relationship set.

8. The data classification and grading method based on knowledge graphs according to claim 1, characterized in that, The obtained category and grade results include: An improved liquid graph neural network is constructed, which includes a continuous evolution graph generator, a jump term liquid update unit, and an uncertainty structure. The dynamic evidence subgraph is input into the continuous evolution graph generator, and a graph structure parameter set and an edge parameter set are generated based on the node attributes, edge attributes and event sequences in the dynamic evidence subgraph. The dynamic evidence subgraph is temporally unfolded based on the graph structure parameter set and edge parameter set. Adjacent event time intervals are generated according to the event occurrence time order of the event sequence, and a corresponding time graph structure and time edge parameters are generated for each event time interval. The temporal expansion result is input into the jump term liquid update unit to perform node state update. The node state vector is initialized for each node in the dynamic evidence subgraph. The node state vector at the end of the interval is obtained by performing continuous update on each node within each event time interval. When the corresponding event at the end of the interval is triggered, the node associated with the current event is updated by performing jump update to obtain the node state vector after the event. The category and grade results of the target data object are generated based on the state vector of the node after the event. The category and grade results are input into the uncertainty structure to perform confidence assessment and rejection judgment, and the category confidence value, grade confidence value and rejection mark are output.

9. A data classification and grading method based on knowledge graphs according to claim 1, characterized in that, The generation of classification and grading labels and the explanatory evidence chain includes: Based on the category results, grade results, category confidence value, grade confidence value, and rejection flag, generate classification and grading labels; Generate an explanatory evidence chain and complete the policy mapping. The explanatory evidence chain includes a list of similar data object identifiers, a list of semantic relationship edge identifiers, a list of bloodline transfer edge identifiers, a list of event edge identifiers and corresponding time attributes. The policy mapping includes matching governance policy nodes in the knowledge graph based on category labels and level labels. Record audit traceability data, which includes classification and grading labels, explanatory evidence chains, target version identifiers, base-edge version identifiers and patch version identifiers, a list of similar data object identifiers and dynamic evidence subgraph identifiers. Write the audit traceability data into the audit storage for playback retrieval and playback inference.

Images