Entity analysis method based on multi-granularity attribute relation graph embedding

Abstract

The invention relates to an entity analysis method based on multi-granularity attribute relation graph embedding, and belongs to the technical field of data integration and entity matching, the method comprises the following steps: firstly, using a lightweight GPT model to carry out semantic evaluation and pre-sequencing on attribute importance, and combining a BertMatch matcher to carry out scoring screening on attributes and combinations thereof so as to determine an optimal attribute set; secondly, mapping attributes and combinations thereof into graph nodes, constructing a multi-granularity attribute relation graph based on a K-nearest neighbor algorithm, and capturing potential semantic dependency among different granularities through a cross-layer connection mechanism; and finally, inputting the multi-granularity attribute graph into the graph neural network for feature embedding and matching rule learning, and improving the robustness and generalization ability of the model in combination with a data enhancement strategy. According to the method, the data enhancement strategy is introduced, so that the diversity and robustness of the graph structure are improved, the complex association between attributes can be effectively captured, and the accuracy and generalization ability of an entity analysis task are remarkably improved.

Description

Technical Field

[0001] This invention belongs to the field of data integration and entity matching technology, specifically relating to an entity parsing method based on multi-granularity attribute relationship graph embedding. Background Technology

[0002] Entity resolution (ER) is an important research area in data management and knowledge fusion. Its goal is to identify and link records from different data sources that point to the same real-world object. This technology plays a crucial role in knowledge graph construction, data cleaning, recommender systems, and information retrieval, and is an important foundation for achieving the fusion and semantic unification of multi-source heterogeneous data. With the rapid development of the internet and large-scale databases, entity data exhibits characteristics such as high dimensionality, semantic complexity, and structural heterogeneity, posing significant challenges to the accuracy and robustness of entity resolution tasks.

[0003] Existing entity parsing methods primarily rely on attribute similarity-based matching strategies. These strategies calculate similarity between attributes using methods such as edit distance, Jaccard coefficient, TF-IDF, or word embeddings, and then weight and fuse the matching results for each attribute to determine if entities are identical. While this approach is simple and intuitive, it has significant limitations. First, it typically assumes that attributes are independent, ignoring potential semantic dependencies and failing to capture complex cross-attribute semantic relationships. For example, in academic literature data, authors, conference names, and publication years often have close contextual relationships, and traditional methods cannot effectively model these higher-order dependencies. Second, strategies based on fixed similarity functions are highly sensitive to noise, missing values, and heterogeneous formats. Differences in attribute naming or granularity can easily lead to decreased matching accuracy. Furthermore, these methods struggle to achieve uniform feature alignment in multi-source heterogeneous data environments, limiting the model's generalization ability in real-world applications.

[0004] To overcome these problems, researchers have begun to introduce deep learning techniques to automatically learn attribute features and matching rules. Pre-trained language models (such as BERT) can capture semantic relationships between attributes and are widely used in entity parsing tasks. The typical BertMatch model encodes the attribute vectors of two entities separately using a two-stream structure and calculates similarity in a high-dimensional semantic space, thereby improving matching accuracy. However, deep learning-based entity parsing methods still have shortcomings. First, most models only focus on comparing single attributes or fixed sets of attributes, lacking global-level semantic relationship modeling, which prevents them from fully utilizing implicit dependencies between attributes. Second, existing methods typically employ a uniform granularity of feature extraction, ignoring the differences in semantic hierarchy and importance between different attribute combinations, and lacking multi-granularity feature fusion mechanisms. Third, these models mostly represent entities as flat vectors, failing to explicitly model the topological relationships between attributes, thus limiting the depth of semantic interaction and the interpretability of the model.

[0005] In recent years, the introduction of Graph Neural Networks (GNNs) has provided a new research direction for entity parsing. GNNs, through information transfer and aggregation mechanisms between nodes, can model the dependencies between entities and their attributes in a graph structure, thus overcoming the independence assumption of traditional methods to some extent. However, most existing GNN-based entity parsing methods employ a single-layer static graph structure, with graph construction relying on manual rules or fixed thresholds, lacking adaptability. Furthermore, the varying importance of different attributes to the matching results is not fully considered, and noisy attributes may mislead within the graph structure, thus affecting overall performance.

[0006] To address the aforementioned shortcomings, this invention proposes an entity parsing method based on Multi-Granular Attribute Relational Graph Embeddings (MGARGE). This method innovatively combines attribute importance assessment, a lightweight large language model, and a graph neural network to achieve multi-granular modeling and fusion of dependencies between attributes through a multi-layered graph structure. Specifically, the method first uses a lightweight GPT model to perform semantic evaluation and pre-ranking of attribute importance, and then uses a BertMatch matcher to score and filter attributes and their combinations to determine the optimal attribute set. Next, attributes and their combinations are mapped to graph nodes, and a multi-granularity attribute relational graph is constructed based on the K-nearest neighbor algorithm. A cross-layer connection mechanism is used to capture potential semantic dependencies between different granularities. Finally, the multi-granularity attribute graph is input into a graph neural network for feature embedding and matching rule learning, and data augmentation strategies such as node addition, deletion, and edge reconnection are combined to improve the model's robustness and generalization ability.

[0007] The MGARGE method of this invention can overcome the limitations of the attribute independence assumption and single-layer fusion in traditional entity parsing, effectively capture the deep semantic relationship between attributes, and significantly improve the accuracy and stability of entity matching. It has shown superior performance and generalization ability compared to existing technologies on standard datasets such as ER-Magellan. Summary of the Invention

[0008] The purpose of this invention is to overcome the problems of attribute independence assumptions, insufficient semantic dependency modeling, and limited feature fusion capabilities in existing entity parsing methods, and to propose an entity parsing method based on multi-granularity attribute graph embedding (MGARGE). This method introduces an attribute importance evaluation mechanism that combines a lightweight large language model with a matcher. Through a multi-granularity attribute graph structure and cross-layer fusion strategy, it effectively models multi-level dependencies between attributes, and combines graph neural networks and data augmentation techniques to achieve efficient feature learning and entity matching, thereby significantly improving the accuracy and generalization performance of entity parsing.

[0009] The technical solution of the present invention is as follows: An entity parsing method based on multi-granularity attribute relation graph embedding includes the following steps: (1) Multi-source data construction and feature extraction: Construct a multi-source heterogeneous entity dataset (including structured and dirty data), clean and standardize it, and extract textual and numerical attribute features through a pre-trained language model and embedding layer to form a fine-grained unified feature representation.

[0010] (2) Attribute selection and graph node transformation: Combining lightweight GPT attribute recommendation and BertMatch evaluation, candidate attributes are first selected based on GPT semantic score and attribute coverage, and then the optimal attribute combination is determined by BertMatch verification, and then transformed into graph nodes containing attribute information and features.

[0011] (3) Multi-granularity graph construction and fusion: Based on KNN, node connections are established according to the similarity of attribute features, and multi-granularity layers are divided according to the number of attributes; mapping edges are established for cross-layer nodes of the same entity, and a unified entity representation is formed through weighted fusion.

[0012] (4) GNN learning and data augmentation: The fused graph is input into the GNN to learn matching rules. At the same time, node addition (generating new nodes by averaging features), deletion (randomly deleting nodes and edges), and edge reconnection (replacing connection relationships) are used to enhance robustness and generalization ability.

[0013] (5) Matching determination and result output: Based on GNN embedding features, classify entity pairs matching relationships and output parsing results; this method is validated on the ER-Magellan dataset, and the F1-score is significantly improved, with accuracy and generalization ability superior to existing technologies.

[0014] Furthermore, the attribute importance assessment in step (2) consists of the following three steps: (2.1) GPT Semantic Scoring: Input the entity attribute set into a lightweight GPT model (such as GPT-4o). The model combines the entity parsing task objective with domain knowledge (such as "brand" being more important than "color" in e-commerce scenarios) to score the semantic importance of each attribute. The higher the score, the greater the contribution of the attribute to entity differentiation. (2.2) Determine the candidate attribute set: Calculate the coverage of each attribute (number of non-null records / total number of records), multiply it by the GPT semantic score to obtain the comprehensive importance score; sort in descending order of comprehensive score, select the attributes with the highest scores and basic combinations (such as pairwise combinations of high-scoring attributes) to form the candidate attribute set.

[0015] (2.3) BertMatch Validation: Construct a BertMatch model with BERT as the backbone, input candidate attributes and combinations into the model respectively, evaluate its discrimination ability and F1-score in entity matching tasks; select the attribute combination with the best performance as the final optimal attribute combination for subsequent graph node construction.

[0016] Furthermore, the multi-granularity layer construction and cross-layer fusion in step (3) are divided into the following four steps: (3.1) KNN node connection: Calculate the feature similarity (such as Euclidean distance) between all graph nodes, select 1-6 nodes with the highest similarity (determined by experimental optimization) as neighbors for each node, establish edge connections between the node and its neighbors to form the initial graph structure.

[0017] (3.2) Divide the granularity layers: count the number of attributes corresponding to each node, classify nodes with only 1 attribute into coarse-grained layers, nodes with 2 attributes into medium-grained layers, and nodes with 3 or more attributes into fine-grained layers, and record the node list and internal connection relationship of each layer.

[0018] (3.3) Construction of cross-layer mapping edges: Based on the unique identifier of the entity (such as product ID, document DOI), identify nodes belonging to the same entity in different granularity layers; establish mapping edges between cross-layer nodes of the same entity in the order of "coarse granularity → medium granularity → fine granularity" to realize the hierarchical transmission of attribute dependency relationship.

[0019] (3.4) Weighted fusion features: Weights are assigned based on the average comprehensive importance score of nodes in each layer (fine-grained layers usually have higher weights than coarse-grained layers because they contain more attribute information); the node features of the same entity in different layers are weighted and summed to obtain a unified entity feature representation that takes into account multiple granularities of information.

[0020] Furthermore, the data augmentation strategy in step (4) consists of the following three steps: (4.1) Node addition: Randomly select two nodes in the graph and generate new node features by averaging their feature vectors; if the entity labels of the two nodes are the same (both are "matched" or "not matched"), the new node inherits the label, otherwise the label is set to "uncertain"; add the new node to the graph and use the KNN algorithm to match the new node with its neighbors and establish edge connections.

[0021] (4.2) Node deletion: Randomly select some nodes in the graph according to a preset probability, delete the selected nodes and all their associated edges; update the neighbor list of the remaining nodes to ensure the integrity of the graph structure and simulate the data missing scenario to enhance the robustness of the model.

[0022] (4.3) Edge reconnection: Randomly select some edges in the graph according to a preset probability, and replace one endpoint of the edge with other random nodes in the graph (avoiding self-loop edges and duplicate edges); update the connection relationship of the graph, enrich the association mode between entities, and improve the model's adaptability to complex relationships.

[0023] Compared with existing technologies, the beneficial effects of this invention are: (1) The combination of GPT and BertMatch to filter attributes reduces the amount of redundant attribute combination evaluation by about 70% and ensures the matching validity of the screening results, solving the problems of low screening efficiency and insufficient reliability of traditional methods. (2) The multi-granularity graph and cross-layer fusion design fully captures the hierarchical dependency relationship between attributes, and more comprehensively represents entity features than a single granularity model, significantly improving matching accuracy. (3) Diverse data augmentation strategies break through the limitations of traditional text perturbation, effectively adapt to complex scenarios such as missing data and changes in relationships, and improve the robustness and generalization ability of the model. (4) It achieves the best performance in all 8 domains (including structured and dirty data) of the ER-Magellan dataset, with an F1-score that is more than 40% higher than that of traditional models, and can be widely used in e-commerce product matching, academic literature deduplication and other scenarios. Attached Figure Description

[0024] Figure 1 This is an architecture diagram of the system built based on this method.

[0025] Figure 2 This module is used to calculate the importance of attributes and create graphical nodes for us.

[0026] Figure 3 This is for fine-grained layer blending.

[0027] Figure 4 The graph shows the effect of the k value on the layer construction. Detailed Implementation

[0028] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0029] like Figure 1 As shown, this invention provides an entity parsing method based on multi-granularity attribute relationship graph embedding. In the attribute selection and graph node construction stages, to improve the efficiency and accuracy of attribute selection, this invention combines the recommendation capability of a lightweight GPT model (such as GPT-4o) with the evaluation capability of the BertMatch model: First, the preprocessed entity attribute set is input into the GPT model. The model combines the entity parsing task objective with domain semantics (e.g., in e-commerce scenarios, "brand" and "model" are more distinguishable than "color") to score the semantic importance of each attribute; simultaneously, the coverage rate of each attribute (the proportion of non-empty records to the total number of records) is calculated, and this is multiplied by the GPT semantic score to obtain a comprehensive importance score. The top 80% of attributes and their basic combinations (e.g., pairwise combinations of high-scoring attributes) are selected in descending order of score as the candidate attribute set. Subsequently, a BertMatch model with BERT as its backbone and a Softmax classification layer was constructed. Candidate attributes and combinations were input into the model, and the F1-score and discriminative ability (the ability to distinguish between matching and non-matching entity pairs) in the entity matching task were calculated to select the attribute combination with the best performance. Finally, each attribute and each attribute combination in the combination was transformed into a fixed-dimensional semantic feature vector through the feature extraction layer of BertMatch. The feature vector was used as a graph node, and the attribute name, comprehensive importance score and other information corresponding to the node were recorded to complete the graph node construction.

[0030] In the multi-granularity attribute relationship graph construction and cross-layer fusion stage, node connections are first established based on the K-Nearest Neighbors (KNN) algorithm: the Euclidean distance between all graph nodes is calculated (the smaller the distance, the higher the feature similarity), and K=2 nodes with the smallest distance (determined through experimental optimization, balancing connection effectiveness and noise control) are selected as neighbors for each node. Edge connections are established between nodes and their neighbors to form the initial graph structure. Next, multi-granularity layers are divided according to the number of attributes corresponding to the nodes: nodes with only 1 attribute are assigned to the coarse-grained layer, nodes with 2 attributes are assigned to the medium-grained layer, and nodes with 3 or more attributes are assigned to the fine-grained layer. The node list and intra-layer edge connection relationships of each layer are recorded. To achieve feature association of the same entity at different granularities, nodes belonging to the same entity in different layers are identified based on the entity's unique identifier (such as product ID or document DOI number). Mapping edges are established between these cross-layer nodes in the order of "coarse-grained layer → medium-grained layer → fine-grained layer". At the same time, weights are assigned according to the average comprehensive importance score of nodes in each layer (the weight is set to 0.5 for fine-grained layer because it contains more attribute information, 0.3 for medium-grained layer, and 0.2 for coarse-grained layer). The features of nodes in multiple layers of the same entity are weighted and summed to form a unified entity feature representation that takes into account information from multiple granularities.

[0031] In the Graph Neural Network (GNN) learning and data augmentation stages, the fused multi-granularity attribute relationship graph is input into the Graph Convolutional Network (GCN). Through the multi-layer convolutional operations of the GCN, the features of the node itself and the features of its neighboring nodes are gradually aggregated, and the node representation is updated to capture the complex relationships between entities. Taking the error between the predicted results of entity matching and the true labels as the optimization objective, the cross-entropy loss function is adopted, and the model parameters are updated through backpropagation, so that the model learns stable entity matching rules. To improve the robustness and generalization ability of the model, three types of data augmentation strategies are introduced: When adding a node, two nodes are randomly selected, and their feature vectors are element-wise averaged to generate new node features. If the labels of the two nodes are the same (both are "matched" or "not matched"), the new node is added to the graph and its neighbors are rematched through KNN; when deleting a node, some nodes are randomly selected with a preset probability of 0.1, the nodes and all associated edges are deleted, and the neighbor list of the remaining nodes is updated; when reconnecting edges, some edges are randomly selected with a preset probability of 0.05, and one endpoint of the edge is replaced with another random node in the graph (to avoid self-loops and duplicate edges), and the connection relationship of the graph is updated.

[0032] In the entity matching and parsing result output stage, the entity embedding features output by GCN are input into the Softmax classifier to calculate the matching probability of entity pairs: if the probability is greater than 0.5, the two entities are judged as "matched" (pointing to the same real-world entity); otherwise, they are judged as "not matched". At the same time, the number of true positives, false positives, true negatives, and false negatives in the test set are counted, and performance indicators such as precision (the proportion of true positives to the total number of predicted matches), recall (the proportion of true positives to the total number of actual matches), and F1-score (the harmonic mean of precision and recall) are calculated. This invention was validated on eight domains of the ER-Magellan benchmark dataset (such as Amazon-Google, DBLP-ACM, Walmart-Amazon2, etc.). The results show that the F1-score is superior to existing models such as DeepMatcher and Ditto. The F1-score reaches 90.81 on the dirty dataset Walmart-Amazon2. Furthermore, the computational cost is reduced by approximately 73% through GPT-assisted attribute filtering. While maintaining high accuracy, it also takes into account computational efficiency and can be effectively applied to multi-domain entity parsing scenarios.

[0033] The specific implementation steps are as follows; 1. Preprocessing of the original dataset This embodiment uses the ER-Magellan benchmark dataset, including multiple subsets such as Amazon-Google, DBLP-ACM, DBLP-Scholar, Fodors-Zagats, and Walmart-Amazon, covering both structured and unstructured data scenarios. To ensure the generalization and comparability of the experiment, all datasets are divided into training, validation, and test sets in a 3:1:1 ratio, and text fields are standardized, including case unification, stop word removal, special character cleanup, and encoding format conversion. This step ensures semantic consistency in subsequent attribute matching and feature mapping. Table 1 provides detailed information about the datasets, including their names (Dataset), the number of tuple pairs (Size), and the number of entity-related attributes (Attr). The datasets consist of structured data and dirty data.

[0034] Table 1 2. Attribute Importance Assessment and Ranking Based on GPT To address the assumption of "equal contribution from all attributes" in traditional entity matching, this invention introduces a Geometric Attribute Importance (GPT)-based recommendation mechanism. The system inputs attribute information from each dataset into the GPT model to generate attribute importance scores. Taking into account the non-empty ratio of attributes The importance score for a single attribute is defined as follows: Based on the ranking results, construct a multi-attribute combination C = {a1, a2, ..., ak}, and calculate its overall importance: in This represents the attribute weights. The GPT model further outputs the discriminative power D(C) of the attribute combinations, calculated as follows: in and These represent the number of positive examples for matching and non-matching samples, respectively. This process automatically filters key attribute combinations, reducing the computational cost of combination traversal by approximately 65%.

[0035] 3. Node feature extraction and layer construction based on BertMatch The attribute combinations sorted by GPT are input into the BertMatch model for semantic encoding, and each attribute combination generates a node representation vector: The semantic similarity between nodes is defined as: Based on node similarity, the K-Nearest Neighbors (KNN) algorithm is used to establish edge connections and calculate Euclidean distance: Each node is connected to its K nearest neighbors to form an edge set E. k This allows for the construction of layer structures G with different granularities. k = (V k E k Nodes are divided into different granularity layers based on the number of attributes: 4. Granularity-based layer linking and multi-layer blending To capture semantic dependencies between multiple granular attributes, this invention proposes a layer linking and fusion mechanism. The granularity layers are arranged in order from coarse to fine, and links are established layer by layer: Each node establishes connections with the upper and lower level nodes of the corresponding entity, achieving a gradual fusion from single attributes to multiple attributes. This strategy can effectively improve the model's ability to model complex entity features.

[0036] 5. Graph Neural Network Embedding and Feature Learning After the graph structure is constructed, a Graph Convolutional Network (GCN) is introduced to extract deep features after cross-layer fusion. The node feature update formula is as follows: in, To add a self-loop to the adjacency matrix, The ReLU activation function is used. This network simultaneously aggregates neighborhood information and inter-layer semantics during multi-layer propagation to obtain entity matching representations.

[0037] 6. Robustness optimization based on graph data augmentation To enhance the model's adaptability to noisy data, this invention introduces three graph data augmentation mechanisms: node addition, node deletion, and edge reconnection. Node addition (Add): Randomly selects two nodes from the graph and generates a new node based on their mean features; Node deletion (Delete): Randomly removes some nodes and related edges; Edge reconnection (Modify): Randomly replaces some edges to enhance topological diversity.

[0038] In each training batch, an operation is randomly selected to maintain graph structure diversity. By enhancing the operation, the model maintains stable matching ability even under noisy and missing attribute conditions.

[0039] 7. Model Training and Evaluation Cross-entropy loss is used as the matching supervision objective function: in To truly match the tags, Predict probabilities for the model. The optimizer uses AdamW with a learning rate of 3×10⁻⁶. -5 Validated on the ER-Magellan multi-domain benchmark, the F1 score is improved by 5%-10% compared to traditional models such as DeepMatcher, Ditto, SETEM, and AttendEM.

[0040] 8. Technical Effects This invention introduces GPT-assisted attribute ranking, BERT semantic feature extraction, multi-granularity layer construction, and cross-layer link fusion mechanisms to achieve hierarchical expression of attribute-level semantic dependencies in entity matching, effectively improving the model's generalization and robustness. As shown in Tables 2 and 3, we compare the performance of the proposed MGARGE model with the aforementioned models on eight datasets.

[0041] Experimental results show that the MGARGE model achieved the highest F1 scores on all eight datasets. Furthermore, MGARGE also demonstrated significant improvements on the AG, WA1, and WA2 datasets. Compared to DeepMatcher, Ditto, DPQ_STQ, SETEM, and AttendEM, MGARGE improved the average F1 scores on these three datasets by 44.18%, 8.62%, 55.53%, 4.62%, and 6.37%, respectively. These results demonstrate that MGARGE exhibits superior generalization ability and performance advantages.

[0042] On the AG dataset, MGARGE achieved an F1 score of 85.20, significantly outperforming other models. This advantage stems from MGARGE's innovative design, which captures the interdependencies between attributes, enabling more effective analysis and matching of structured data. In contrast, DeepMatcher uses recurrent neural networks (RNNs) to extract features and learn matching rules, excelling at capturing local and sequential patterns. However, when multiple or conditional dependencies exist between attributes, DeepMatcher's model may not adequately capture these complex relationships, appearing less flexible. While Ditto can learn the relationships between attributes to some extent through multi-head attention, it still has limitations when handling specific data types or complex attribute dependencies.

[0043] On the noisy WA2 dataset, MGARGE achieved an F1 score of 90.81, demonstrating its robustness in handling data noise and inconsistencies. It effectively identifies and utilizes attribute relationships, maintaining high performance in complex environments. In contrast, DPQ_STQ strikes a balance between informativeness and representativeness. However, in noisy and data-constrained scenarios, it struggles to capture key features because it relies too heavily on informativeness or representativeness, neglecting the interactions between attributes and noise effects. SETEM improves model stability and generalization ability, but its reliance on model complementarity without deeply exploring the intrinsic relationships between attributes limits its performance on noisy datasets such as WA2.

[0044] Table 2 Table 3 We evaluated the impact of the Granular Layer Building and Linking (GLBL) method and Graphical Data Augmentation (GDT) on model performance through ablation experiments, using the F1 score as the evaluation metric. The experimental results are shown in Table 4. The results indicate that GLBL plays a crucial role in improving model performance. For example, on the AG dataset, GLBL achieved an F1 score of 84.92, demonstrating its effectiveness in handling structured data. GLBL also performed well on the DA2 and DS2 datasets, with F1 scores of 98.94 and 96.28, respectively, highlighting its robustness in noisy data environments. Conversely, GDT, as an auxiliary technique, also showed consistent performance improvements across multiple datasets. On the AG dataset, GDT achieved a score of 83.38, indicating its positive contribution to model performance. When GLBL and GDT are used in combination, model performance is further improved. This combination not only demonstrates the advantages of both methods but also leverages their synergistic effect, achieving state-of-the-art performance on all test datasets. These results highlight the importance of combining GLBL and GDT and their potential to jointly improve model performance.

[0045] Table 4 Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art can still modify the technical solutions described in the foregoing embodiments or make equivalent substitutions for some of the technical features. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. An entity parsing method based on multi-granularity attribute relation graph embedding, characterized in that... Includes the following steps: (1) Construct a multi-source heterogeneous dataset for entity parsing and extract fine-grained features for each attribute of the entity; (2) The attribute importance evaluation strategy based on the matcher BertMatch is adopted, combined with the attribute recommendation mechanism of the lightweight GPT model, to screen and score the attributes and their combinations, determine the optimal attribute combination, and transform the attributes and their combinations into graph nodes. (3) Construct a multi-granularity attribute relationship graph based on the semantic correlation between attributes, establish the connection relationship between nodes based on the K-nearest neighbor KNN algorithm, and fuse the information between different granularity layers through the cross-layer connection strategy to obtain the multi-granularity attribute relationship graph. (4) Input the fused multi-granularity attribute relationship graph into the graph neural network (GNN) for feature embedding and matching rule learning. At the same time, introduce data augmentation strategies such as node addition, deletion and edge reconnection to improve robustness and generalization ability. (5) Perform entity matching and classification based on the learned embedded features, and output the final entity parsing results.

2. The entity parsing method based on multi-granularity attribute relation graph embedding according to claim 1, characterized in that, The attribute importance assessment in step (2) includes the following sub-steps: (2.1) Use the GPT model to score the semantic importance of each attribute; (2.2) Calculate the overall importance score by combining the attribute coverage to determine the candidate attribute set; (2.3) The attributes and their combinations are validated by the BertMatch model, and the optimal attribute combination is selected for subsequent graph construction.

3. The entity parsing method based on multi-granularity attribute relationship graph embedding according to claim 1, characterized in that: The multi-granularity layer construction and cross-layer fusion in step (3) includes the following sub-steps: (3.1) Based on the K-Nearest Neighbors (KNN) algorithm, establish node connection relationships according to attribute feature similarity; (3.2) Divide the nodes into layers of different granularities according to the number of attributes to form a multi-layer graph structure; (3.3) A layer connection method from coarse-grained to fine-grained is adopted to establish cross-layer mapping edges for multi-layer nodes of the same entity; (3.4) The features of different granularity layers are integrated through a weighted fusion mechanism to form a unified entity representation.

4. The entity parsing method based on multi-granularity attribute relationship graph embedding according to claim 1, characterized in that: The data augmentation strategy in step (4) includes the following sub-steps: (4.1) Node addition: A new node is generated by randomly selecting two nodes and averaging their features; (4.2) Node deletion: Randomly remove some nodes and their connected edges to enhance the robustness of the model; (4.3) Edge reconnection: Randomly replace the original node connection relationship to generate a new graph structure to improve structural diversity.

Images