Wind power knowledge graph entity unification method and system
By using BERT and Word2Vec models in the wind power field to build entity vector libraries and replacement dictionaries, combining similarity algorithms and spatial index structures, the complexity and data quality problems of entity fusion in the wind power knowledge graph are solved, and efficient and accurate entity unification is achieved. and fusion.
Patent Information
- Application Number
- CN202410956222.4
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2024-07-17
- Publication Date
- 2024-11-22
AI Technical Summary
The prior art is difficult to effectively perform entity fusion when building knowledge graphs in the field of wind power, especially in dealing with complex entity relationships and semantic understanding, and data quality issues affect the accuracy and efficiency of entity fusion.
Using the BERT similarity model and Word2Vec vectorization model, the text data in the wind power maintenance work order is trained and vectorized to build an entity vector library and a replacement dictionary, combining the similarity algorithm and spatial index structure to achieve unified and efficient fusion of entities. .
It improves the entity uniform accuracy and efficiency of the wind power knowledge graph, can effectively handle complex entity relationships and semantic understanding, reduces the demand for computing resources, and ensures the speed and accuracy of data processing.
Smart Images

Figure CN119004227A_ABST
Abstract
Description
Technical Field
[0001] The present invention relates to the technical field of wind turbine knowledge graph entity unification, and in particular to a wind power knowledge graph entity unification method and system. Background Art
[0002] As a highly specialized technical field, the wind power industry has a large number of diverse documents and materials. These data are highly professional, large in volume, from diverse sources, and frequently updated. As an efficient semantic knowledge base, the knowledge graph systematically organizes entities and their relationships through a graph structure, providing a powerful information management and decision support tool for the wind power industry. Its advantages lie in its ability to integrate data from different sources and formats to form a unified knowledge base for easy management and access; to use data analysis and reasoning functions to provide a scientific basis for operational decisions; to predict equipment failures and maintenance needs through historical data analysis, and to achieve early identification and management of risks; at the same time, the knowledge graph helps to discover new technology trends and solutions and promote industry innovation.
[0003] In the process of building the knowledge graph of the wind power industry, entity fusion technology plays a vital role. It involves identifying and merging the same entities mentioned in the text, ensuring that the same entity mentioned in different contexts is correctly associated. The importance of entity fusion is reflected in ensuring the consistency of information, improving data accuracy, enhancing retrieval efficiency, and promoting the discovery and application of new knowledge. Through entity fusion, the entity representations in different data sources can be unified, reducing misleading information caused by inconsistent or incorrect data, allowing users to quickly find the information they need, and revealing the potential connections between entities, providing support for the continued development and innovation of the wind power industry. Therefore, entity fusion is the basis for ensuring the quality and effectiveness of the knowledge graph, and is crucial to the successful construction of the knowledge graph of the wind power industry.
[0004] The main task of entity fusion is to identify the entities mentioned in the text and determine whether they refer to the same object in the real world. Traditionally, entity fusion includes entity disambiguation, entity unification, and coreference resolution, and its actual definition and implementation methods may vary depending on the application scenario. Generally speaking, entity disambiguation refers to "determining whether an entity referent corresponds to multiple entities in the real world"; while entity unification, also known as entity alignment, refers to "determining whether multiple entity referents correspond to the same entity in the real world", for example, the "oil collecting bottle" and "oil collecting box" in the variable pitch system both refer to the "oil collecting bottle", a common component; finally, coreference resolution, also known as co-reference resolution, refers to "determining whether entity referents and pronouns, such as 'you, me, and him', all refer to the same entity in the real world". The goal of entity fusion is to correctly associate these ambiguous entities with the entities they actually refer to. Entity fusion technology is mainly used in the following aspects: 1. Knowledge graph construction: align entities in new text with entity nodes in the knowledge graph to enrich and expand the knowledge graph; 2. Search engine: entity fusion improves the relevance and accuracy of search results by understanding entities in user queries and providing more precise information; 3. Recommendation system: entity fusion helps personalization systems better understand user interests and behaviors, thereby providing more relevant recommendations; 4. Text mining and analysis: entity fusion helps extract and analyze key information, such as identifying related companies and people in corporate intelligence analysis.
[0005] The existing entity fusion related implementation technologies are as follows: 1. Rule-based method: use predefined rules and patterns to identify and fuse entities; 2. Machine learning-based method: use labeled data to train models to automatically identify and fuse entities; 3. Deep learning method: use neural networks, such as recurrent neural networks and Transformer models, to handle complex entity fusion tasks; 4. Knowledge base and ontology: use existing knowledge base and ontology to assist in the identification and fusion of entities; With the development of natural language processing technology, the accuracy and efficiency of entity fusion have been continuously improved, which has played an important role in improving the performance of various NLP applications.
[0006] With the increasing research and application of knowledge graphs, the technology of entity fusion is also booming. At present, no entity fusion methodology has been found for constructing knowledge graphs in the wind power field, but it has applications in other fields: for example, Chinese invention patent applications CN116796000A and CN116702899A unify entities by limiting the number of relationships. That is, under certain conditions, a household address should belong to only one household. If two households appear, the two households should be regarded as the same household. This method is simple and easy to implement, but it has great limitations. For example, it can only be applied to one-to-one corresponding entity types and relationships, but wind power entity relationships often appear one-to-many or many-to-many situations. For example, a fault problem can have multiple processing methods. Secondly, this method also lacks an understanding of entity semantics. However, in the wind power field, there can be multiple entities that have the same meaning but are expressed in different ways, such as "oil overtemperature", "oil overtemperature", "oil temperature exceeds limit", etc. Therefore, the entity description is diverse and complex, and it is impossible to rely entirely on rules or knowledge bases to accurately align entities. At the same time, if there are quality problems with the input data, such as inconsistency, incorrect information or missing data, it will directly affect the accuracy and reliability of entity fusion. In addition, as the amount of data increases, how to efficiently process and fuse a large amount of entity data with limited computing resources becomes a problem.
[0007] The above examples show that the current methods cannot be directly transferred to the wind power business scenario for direct application, so a unified entity method suitable for the wind power industry is proposed. Summary of the invention
[0008] The purpose of the present invention is to overcome the shortcomings of the prior art and propose a wind power knowledge graph entity unification method and system, so as to reduce text ambiguity and make the constructed knowledge graph structure richer and more interconnected. The text data is mainly concentrated in inspection work orders or maintenance work orders. The BERT similarity model and vectorization models such as Word2Vec are trained to classify the text and build an entity vector library. When a new entity is input, the similarity algorithm is used to compare the similarity with the entities in the entity vector library. When the similarity is greater than the threshold, it is considered that the new entity can be unified with the entities in the entity vector library.
[0009] The object of the present invention is achieved by the following technical solution: A method for unifying wind power knowledge graph entities, comprising the following steps:
[0010] S1. Collect text data from wind power maintenance work orders, perform pre-processing of the text data by cleaning and pairing, and perform preliminary labeling on the pre-processed text data;
[0011] S2, input the preliminarily annotated text data into the BERT-based pre-training model for training, and build a BERT-based similarity model;
[0012] S3, based on the similarity model, making similarity clusters and entity replacement words to form an entity replacement dictionary;
[0013] S4. Convert text data into entity vectors based on the Word2Vec model, classify and store the entity vectors, and build an entity vector library;
[0014] S5. When a new entity is input, if there is a corresponding entry between the new entity and the entity replacement dictionary, the entity replacement word is used to directly replace the new entity. If there is no corresponding entry between the new entity and the entity replacement dictionary, the similarity model is used to compare the entities in the entity vector library. When the similarity is greater than a preset threshold, the new entity is considered to be unified with the entity in the entity vector library.
[0015] Further, the step S1 comprises:
[0016] Text data is collected from wind power maintenance work orders. The text data is used as the original entity. Regular expressions are defined to clean the original entities to remove punctuation marks, empty characters and specific wind turbine number information. Then, the Levenshtein distance and Jaccard coefficient similarity algorithms are used to preliminarily pair entities with similar expressions under the same attributes to form a data set T; the entities are preliminarily labeled, entities with the same meaning are positive samples, marked as 1, and entities with different meanings are negative samples, marked as 0, so that the ratio between positive samples and negative samples is 1:1, and they are divided into a training set Ttrain and a test set Ttest, and the ratio of the training set to the test set is 4:1.
[0017] Further, the step S2 comprises:
[0018] First, each entity pair is concatenated together using the [SEP] identifier, and then the [CLS] identifier is added before the entity pair. The maximum length of the entity pair is 512. The part of the actual entity pair that exceeds the maximum length needs to be trimmed, and the part of the actual entity pair that does not exceed the maximum length needs to be padded with 0. The obtained entity pair is vectorized and encoded based on the BERT pre-trained model, with a dimension of 768;
[0019] Then build the architecture of the training model. Modify the output dimension on the existing network architecture to achieve the binary classification task. That is, add a fully connected layer with an output dimension of 1 at the end of the network structure of the BERT model, and then add a Sigmoid activation function to the fully connected layer:
[0020]
[0021] Where x is the input value, e is the base of the natural logarithm, and σ(x) is the output value of the Sigmoid activation function. The original output of the fully connected layer is mapped to the interval (0,1) through a linear transformation, which is expressed as the similarity probability p of the entity pair.
[0022] Next, select the loss function and the optimizer used for optimization during training, the binary cross entropy loss for the binary classification task:
[0023] BinaryCross-EntropyLoss=-(y*log(p)+(1-y)*log(1-p))
[0024] Among them, y is the true value, which takes a value of 0 or 1, p is the probability that the model predicts that the sample is a positive sample, that is, the predicted output, log is the natural logarithm, and the optimizer selects AdamW;
[0025] Finally, the BERT model is fine-tuned based on the processed data, the defined model architecture, loss function, optimizer, and the set training parameters, and the model effect is evaluated. The evaluation criterion is accuracy:
[0026]
[0027] Among them, TP is the true positive example, which refers to the number of samples correctly predicted by the model as positive; TN is the true negative example, which refers to the number of samples correctly predicted by the model as negative; FP is the false positive example, which refers to the number of negative samples incorrectly predicted by the model as positive; FN is the false negative example, which refers to the number of positive samples incorrectly predicted by the model as negative.
[0028] Furthermore, the set training parameters include the number of iterations epoch, the amount of data batch size for each training, and the learning rate of the optimizer.
[0029] Further, the step S3 comprises:
[0030] The BERT-based similarity model is used to iterate all entities with the same attribute and compare the output similarity scores. When the similarity score is greater than the preset threshold, all entities are classified into the same category to form an entity replacement dictionary; the entity replacement dictionary includes the representative entity at the center of each category and other entities similar to the representative entity.
[0031] Further, the step S4 comprises:
[0032] Word2Vec converts words into fixed-length vector representations by learning contextual information in text data. That is, the Word2Vec model learns word vectors by optimizing the objective function, which is expressed as:
[0033]
[0034] Among them, ω i is a given word, ω context is the context of the word, θ is the model parameter, and N is the number of training samples;
[0035] All entities are segmented using Jieba's Chinese word segmentation function, and sent to the Word2Vec model for training to obtain the vector expression of each word with a dimension of 100. Then, all word vectors of each entity are averaged to obtain the fixed-dimensional vector expression of the entity. After obtaining the entity vector, these vectors are stored according to entity attribute classification using the spatial index structure to build an entity vector library.
[0036] The entity vector library is dynamically updated by adding new entities and updating existing entity vectors. At the same time, the retrieval performance and accuracy are optimized by adjusting the hyperparameters of the Word2Vec model and the configuration of the spatial index structure.
[0037] Furthermore, the spatial index structure includes Ball-Tree and KD-Tree.
[0038] Further, the step S5 comprises:
[0039] When introducing a new entity, first check whether there is an entry corresponding to the new entity in the entity replacement dictionary. If there is an entry corresponding to the new entity, it is directly replaced with the representative entity; if there is no entry corresponding to the new entity, locate it in the corresponding entity vector library according to the entity attributes; then, use the Word2Vec model to vectorize the entity, and then start a similarity search in the entity vector library, which is based on cosine similarity or Euclidean distance;
[0040] In the similarity search, the top 10 to 20 entities in similarity ranking are initially screened out as candidate sets. The similarity scores of these candidate entities are recalculated using the BERT-based similarity model. Only when the score is higher than the set threshold, the candidate entity is considered to be semantically consistent with the input entity and adopted as a replacement.
[0041] A wind power knowledge graph entity unification system, used to implement the above-mentioned wind power knowledge graph entity unification method, comprising:
[0042] A data collection module, used to collect text data from wind power maintenance work orders;
[0043] The data preprocessing and preliminary annotation module is used to clean and preprocess the text data, and to preliminarily annotate the preprocessed text data;
[0044] The similarity model building module is used to input the preliminarily annotated text data into the BERT-based pre-training model for training and build a BERT-based similarity model;
[0045] A similarity clustering and entity replacement dictionary making module makes similarity clustering and entity replacement words according to the similarity model to form an entity replacement dictionary;
[0046] The entity vectorization and entity vector library construction module converts text data into entity vectors based on the Word2Vec model, classifies and stores entity vectors, and builds an entity vector library;
[0047] Entity unification and threshold determination module, when a new entity is input, if there is a corresponding entry between the new entity and the entity replacement dictionary, the entity replacement word is used to directly replace the new entity. If there is no corresponding entry between the new entity and the entity replacement dictionary, the similarity model is used to compare the entities in the entity vector library. When the similarity is greater than the preset threshold, the new entity is considered to be unified with the entities in the entity vector library.
[0048] Furthermore, the data preprocessing and preliminary annotation module includes:
[0049] Text data is collected from wind power maintenance work orders. The text data is used as the original entity. Regular expressions are defined to clean the original entities, remove punctuation marks, empty characters, and specific wind turbine number information. Then, the Levenshtein distance and Jaccard coefficient similarity algorithms are used to preliminarily pair entities with similar expressions under the same attributes to form a data set T; the entities are preliminarily labeled, entities with the same meaning are positive samples, marked as 1, and entities with different meanings are negative samples, marked as 0, so that the ratio between positive samples and negative samples is 1:1, and divided into a training set Ttrain and a test set Ttest, with a ratio of 4:1 between the training set and the test set;
[0050] The similarity model building module includes:
[0051] First, each entity pair is concatenated together using the [SEP] identifier, and then the [CLS] identifier is added before the entity pair. The maximum length of the entity pair is 512. The part of the actual entity pair that exceeds the maximum length needs to be trimmed, and the part of the actual entity pair that does not exceed the maximum length needs to be padded with 0. The obtained entity pair is vectorized and encoded based on the BERT pre-trained model, with a dimension of 768;
[0052] Then build the architecture of the training model. Modify the output dimension on the existing network architecture to achieve the binary classification task. That is, add a fully connected layer with an output dimension of 1 at the end of the network structure of the BERT model, and then add a Sigmoid activation function to the fully connected layer:
[0053]
[0054] Where x is the input value, e is the base of the natural logarithm, and σ(x) is the output value of the Sigmoid activation function. The original output of the fully connected layer is mapped to the interval (0,1) through a linear transformation, which is expressed as the similarity probability p of the entity pair.
[0055] Next, select the loss function and the optimizer used for optimization during training, the binary cross entropy loss for the binary classification task:
[0056] BinaryCross-EntropyLoss=-(y*log(p)+(1-y)*log(1-p))
[0057] Among them, y is the true value, which takes a value of 0 or 1, p is the probability that the model predicts that the sample is a positive sample, that is, the predicted output, log is the natural logarithm, and the optimizer selects AdamW;
[0058] Finally, the BERT model is fine-tuned based on the processed data, the defined model architecture, loss function, optimizer, number of epochs, batch size of data for each training, and the learning rate of the optimizer, and the model effect is evaluated. The evaluation criterion is accuracy:
[0059]
[0060] Among them, TP is the true positive example, which refers to the number of samples correctly predicted by the model as positive; TN is the true negative example, which refers to the number of samples correctly predicted by the model as negative; FP is the false positive example, which refers to the number of negative samples incorrectly predicted by the model as positive; FN is the false negative example, which refers to the number of positive samples incorrectly predicted by the model as negative.
[0061] The similarity clustering and entity replacement dictionary making module includes:
[0062] The BERT-based similarity model is used to iterate all entities with the same attribute and compare the output similarity scores. When the similarity score is greater than the preset threshold, all entities are classified into the same category to form an entity replacement dictionary; the entity replacement dictionary includes the representative entity at the center of each category and other entities similar to the representative entity.
[0063] The entity vectorization and entity vector library construction module includes:
[0064] Word2Vec converts words into fixed-length vector representations by learning contextual information in text data. That is, the Word2Vec model learns word vectors by optimizing the objective function, which is expressed as:
[0065]
[0066] Among them, ω i is a given word, ω context is the context of the word, θ is the model parameter, and N is the number of training samples;
[0067] All entities are segmented using Jieba's Chinese word segmentation function, and sent to the Word2Vec model for training to obtain the vector expression of each word with a dimension of 100. Then, all word vectors of each entity are averaged to obtain the fixed-dimensional vector expression of the entity. After obtaining the entity vector, the Ball-Tree and KD-Tree spatial index structures are used to store these vectors according to entity attribute classification to build an entity vector library.
[0068] The entity vector library is dynamically updated by adding new entities and updating existing entity vectors. At the same time, the retrieval performance and accuracy are optimized by adjusting the hyperparameters of the Word2Vec model and the configuration of the spatial index structure.
[0069] The entity unification and threshold determination module includes:
[0070] When introducing a new entity, first check whether there is an entry corresponding to the new entity in the entity replacement dictionary. If there is an entry corresponding to the new entity, it is directly replaced with the representative entity; if there is no entry corresponding to the new entity, locate it in the corresponding entity vector library according to the entity attributes; then, use the Word2Vec model to vectorize the entity, and then start a similarity search in the entity vector library, which is based on cosine similarity or Euclidean distance;
[0071] In the similarity search, the top 10 to 20 entities in similarity ranking are initially screened out as candidate sets. The similarity scores of these candidate entities are recalculated using the BERT-based similarity model. Only when the score is higher than the set threshold, the candidate entity is considered to be semantically consistent with the input entity and adopted as a replacement.
[0072] Compared with the prior art, the present invention has the following advantages and beneficial effects:
[0073] 1. The present invention aims at data quality and consistency issues, and achieves conceptual unification in the rules of entity extraction, including the number of entity categories and the division method, to ensure the validity of the extracted entities in terms of form and meaning to the greatest extent;
[0074] 2. Aiming at the accuracy problem of entity unification, the present invention takes into account the deficiencies of rule-based methods in semantic understanding and the deficiencies of knowledge bases in magnitude. In the process of building an entity unification program, the present invention not only integrates the traditional similarity algorithm and vector library construction method, but also combines the pre-trained model. Therefore, the advantages of the traditional similarity algorithm and knowledge base fixed paradigm, which can be transferred and utilized, and the advantages of fast calculation, can be brought into play. The advantages of semantic understanding of the model based on large-scale corpus training can also be used to achieve the best unification effect.
[0075] 3. The entity unification system composed of the traditional similarity algorithm, knowledge base and pre-trained model of the present invention often takes a lot of time to unify the newly input text, because the calculation time of traversing and searching for similar entities from the knowledge base shows a linear growth. In order to solve this problem, the present invention introduces a preliminary sorting algorithm that combines the spatial index structure and the Word2Vec vectorization model. All entities are segmented, trained and vectorized based on Word2Vec, and then stored in an entity vector library based on the spatial index structure. When there is a new input, similar entities are preliminarily screened based on vector similarity, and then the final result is obtained by fine screening based on semantic understanding, which ensures both speed and accuracy;
[0076] 4. The BERT-based similarity model constructed by the present invention can effectively distinguish entities with similar appearance but different meanings based on semantics, making them accurately unified;
[0077] 5. The present invention takes the initial screening and selection as the basic idea, realizes the entity unified link combining the dictionary library, vector library and similarity algorithm, which can ensure both the overall processing speed and the accuracy of the processing;
[0078] 6. The present invention has strong portability and is easy to iterate, and can replace algorithms and entity vector libraries with better effects according to specific needs. BRIEF DESCRIPTION OF THE DRAWINGS
[0079] Figure 1 The architectural diagram of the unified approach for wind power knowledge graph entities.
[0080] Figure 2 Flowchart of the unified approach for wind power knowledge graph entities.
[0081] Figure 3 Code example diagram for replacing dictionaries for entities. DETAILED DESCRIPTION
[0082] The present invention will be further described below in conjunction with specific embodiments.
[0083] Example 1
[0084] See also Figure 1 to Figure 2As shown in the figure, the method for unifying entities in the wind power knowledge graph provided in this embodiment is characterized by including the following steps:
[0085] S1. Collect text data from wind power maintenance work orders, perform preprocessing of cleaning and pairing on the text data, and perform preliminary annotation on the preprocessed text data, including:
[0086] Collect text data from wind power maintenance work orders. This text data serves as the original entity. Define regular expressions to clean the original entity, removing punctuation marks, null characters, and information with specific fan numbers. Subsequently, use the Levenshtein distance and Jaccard coefficient similarity algorithms to perform preliminary pairing on entities with similar expressions under the same attributes to form a dataset T. Perform preliminary annotation on the entities. Entities with the same meaning are positive samples, marked as 1, and entities with different meanings are negative samples, marked as 0, so that the ratio between positive samples and negative samples is 1:1, and divide them into a training set Ttrain and a test set Ttest, and the ratio of the training set to the test set is 4:1.
[0087] Among them, a total of nearly 7,000 pieces of data are collected for text data, in the form of "#Fault work order of the frequency converter of the first wind farm (unit 015). The unit reported a converter fault resulting in the unit shutdown. The troubleshooting description is as follows: 1. Board the unit to connect the frequency converter to view the data and find that the specific fault is too high water-cooling pressure; 2. Drain the water-cooling liquid to an appropriate pressure and then the unit resumes operation. In this embodiment, the entity category is defined as 5 types, including "wind farm name", "fault name", "fault phenomenon", "fault cause", and "maintenance method". After entity extraction, the corresponding entity content is as shown in Table 1 below:
[0088] Entity Class Examples Fault name Converter failure Cause Water cooling pressure is too high Fault phenomenon Unit shutdown Maintenance means Drain the water coolant to the appropriate pressure Wind farm name #1 Wind Farm (Unit 015)
[0089] Table 1 Example of entity content after entity extraction of text data
[0090] After obtaining all entity sets through entity extraction, it is necessary to clean the entities, such as punctuation marks or other useless information. In this example, "#The first wind farm (unit 015)" becomes "The first wind farm" after cleaning;
[0091] After that, use the Levenshtein distance algorithm to match each entity under the same entity category with another most similar entity except itself. As shown in Table 2 below, there are more than 5,000 in total. Then perform manual annotation, with the ratio of positive and negative samples being 1:1. Subsequently, divide the training set and the test set, and the ratio is 4:1.
[0092]
[0093]
[0094] Table 2 Example of entity matching
[0095] S2. Input the preliminarily annotated text data into the BERT-based pre-training model for training and build a BERT-based similarity model, including:
[0096] First, each entity pair is concatenated together using the [SEP] identifier, and then the [CLS] identifier is added before the entity pair. The maximum length of the entity pair is 512. The part of the actual entity pair that exceeds the maximum length needs to be trimmed, and the part of the actual entity pair that does not exceed the maximum length needs to be padded with 0. The obtained entity pair is vectorized and encoded based on the BERT pre-trained model, with a dimension of 768;
[0097] Then build the architecture of the training model. Modify the output dimension on the existing network architecture to achieve the binary classification task. That is, add a fully connected layer with an output dimension of 1 at the end of the network structure of the BERT model, and then add a Sigmoid activation function to the fully connected layer:
[0098]
[0099] Where x is the input value, e is the base of the natural logarithm, and σ(x) is the output value of the Sigmoid activation function. The original output of the fully connected layer is mapped to the interval (0,1) through a linear transformation, which is expressed as the similarity probability p of the entity pair.
[0100] Next, select the loss function and the optimizer used for optimization during training, the binary cross entropy loss for the binary classification task:
[0101] BinaryCross-EntropyLoss=-(y*log(p)+(1-y)*log(1-p))
[0102] Among them, y is the true value, which takes a value of 0 or 1, p is the probability that the model predicts that the sample is a positive sample, that is, the predicted output, log is the natural logarithm, and the optimizer selects AdamW;
[0103] Then the concatenated code is put into model training, the number of iterations is epoch: 10, the amount of data for each training is batch size: 128, the learning rate of the optimizer is learning rate: 0.00001, and the model effect is evaluated. The evaluation standard is accuracy:
[0104]
[0105] Among them, TP is a true positive example, which refers to the number of samples correctly predicted by the model as positive; TN is a true negative example, which refers to the number of samples correctly predicted by the model as negative; FP is a false positive example, which refers to the number of negative samples incorrectly predicted by the model as positive; FN is a false negative example, which refers to the number of positive samples incorrectly predicted by the model as negative; after testing, the training accuracy is 84% and the test is 83%.
[0106] S3. Based on the similarity model, similarity clusters and entity replacement words are created to form an entity replacement dictionary, including:
[0107] The BERT-based similarity model is used to iterate all entities with the same attribute and compare the output similarity scores. When the similarity score is greater than the preset threshold, all entities are classified into the same category to form an entity replacement dictionary; the entity replacement dictionary includes the representative entity of each category center and other entities similar to the representative entity. The pseudo code of the process is as follows:
[0108]
[0109]
[0110] The specific implementation process is as follows:
[0111] Use Python to write a clustering algorithm that accepts three parameters, including a similarity threshold, a similarity model, and an entity list. The clustering algorithm is made to traverse all entities and cluster centers, and by calculating the similarity score between the entity and each cluster center, if the similarity score exceeds the threshold, the entity is added to the cluster; otherwise, the entity forms a new cluster center alone. Finally, a list of clustering results is returned. In this example, the threshold is set to 0.85, the similarity model is a BERT-based similarity model, and the entity list is in categories. When the maintenance method is used as a category, it is {clean up garbage, add coolant pressure value, readjust the oil level sensor after wiping, check and find 86° line, check the communication from the cabin to the tower base} or when the fault phenomenon is used as a category, it is {the unit cannot run, the cabin is damaged by vibration, the temperature of the pitch shaft box is high, the surface of the hydraulic station oil level sensor is sticky with oil, and the EFC signal is disconnected}. The algorithm is calculated according to the category input, and finally a clustering dictionary in json format is returned. The clustering dictionaries of all categories are spliced to form a total clustering dictionary, see Figure 3 As shown, and marked with category labels, corresponding to Figure 3 The "property" key is the representative entity, the "centroid" key is the similar entity set, and the "entities" key is the similar entity set.
[0112] S4. Convert text data into entity vectors based on the Word2Vec model, classify and store the entity vectors, and build an entity vector library, including:
[0113] Word2Vec converts words into fixed-length vector representations by learning contextual information in text data. That is, the Word2Vec model learns word vectors by optimizing the objective function, which is expressed as:
[0114]
[0115] Among them, ω i is a given word, ω context is the context of the word, θ is the model parameter, and N is the number of training samples;
[0116] All entities are segmented using Jieba's Chinese word segmentation function, and sent to the Word2Vec model for training to obtain the vector expression of each word with a dimension of 100. Then, all word vectors of each entity are averaged to obtain the fixed-dimensional vector expression of the entity. After obtaining the entity vector, the Ball-Tree and KD-Tree spatial index structures are used to store these vectors according to entity attribute classification to build an entity vector library.
[0117] The entity vector library is dynamically updated by adding new entities and updating existing entity vectors. At the same time, the retrieval performance and accuracy are optimized by adjusting the hyperparameters of the Word2Vec model and the configuration of the spatial index structure. The specific implementation process is as follows:
[0118] Jieba's Chinese word segmentation function is used to segment all representative entities. For example, "clean up willow catkins" will be segmented into "clean up" and "willow catkins". Then the segmented entity collection, such as {{"clean up", "willow catkins"}, {"replace", "yaw", "release", "relay"}...{"clean up", "filter element"}}, is sent to the Word2Vec model for training to obtain a vector expression with a length of 100 for each word, such as the vector expression of "filter element" {0.21109512448310852, 0.509698212146759, 0.35695305466651917...0.114264115691185, -0.6741855144500732}, and then all word vectors of each entity are averaged to obtain the vector expression of the entity. After obtaining the entity vector, each entity is numbered, and then a spatial index structure such as Ball-Tree is used to store these vectors and numbers, and distinguish them by attributes to achieve efficient similarity retrieval.
[0119] In addition, the construction process of Ball-Tree is as follows:
[0120] 1. Initialization: Ball-Tree has only one root node, and all data points point to it;
[0121] 2. Loop division: In each loop, each node will be divided into two sub-nodes;
[0122] ■Calculate the center point of all data points in the node, i.e. the centroid;
[0123] ■Find the data point farthest from the center point as the left child node;
[0124] ■ Then find the data point farthest from the left child node as the right child node;
[0125] 3. Data point allocation: Let the data points close to the left child node point to the left child node, otherwise point to the right child node, so as to divide the two new areas;
[0126] 4. Calculate hypersphere parameters: Calculate the center points and radii of the two new regions to form two hyperspheres;
[0127] 5. Recursive construction: Repeat the above steps for each child node recursively according to the division process until the number of data points in the divided hypersphere is less than the set value;
[0128] 6. End condition: When the number of data points in the hypersphere is less than the preset threshold, the partitioning ends and the Ball-Tree index is finally constructed.
[0129] S5. When a new entity is input, if there is a corresponding entry between the new entity and the entity replacement dictionary, the entity replacement word is used to directly replace the new entity. If there is no corresponding entry between the new entity and the entity replacement dictionary, the similarity model is used to compare the similarity with the entities in the entity vector library until the similarity is greater than a preset threshold. In this case, the new entity is considered to be unified with the entity in the entity vector library, including:
[0130] When introducing a new entity, first check whether there is an entry corresponding to the new entity in the entity replacement dictionary. If there is an entry corresponding to the new entity, it is directly replaced with the representative entity; if there is no entry corresponding to the new entity, locate it in the corresponding entity vector library according to the entity attributes; then, use the Word2Vec model to vectorize the entity, and then start a similarity search in the entity vector library, which is based on cosine similarity or Euclidean distance;
[0131] In the similarity search, the top 10 to 20 entities in similarity ranking are initially selected as candidate sets. The similarity scores of these candidate entities are recalculated using the BERT-based similarity model. Only when the score is higher than the set threshold, the candidate entity is considered to be semantically consistent with the input entity and is adopted as a replacement. The pseudo code of this process is as follows:
[0132]
[0133]
[0134] The specific implementation process is as follows:
[0135] When the entity "cleaning catkins" enters the system, the entity replacement dictionary is first traversed to check whether there are identical entries. If so, the representative entity of the category in which the same entry is located is directly replaced; if not, the corresponding vector library is located based on the entity attribute - maintenance means. Subsequently, the Word2Vec model is used to vectorize the entity and obtain {-0.6832131743431091,-0.6085225343704224,-0.06460192054510117…0.08478175848722458,-0.13052251935005188}, and the 10 to 20 most similar entities are searched from the vector library based on the Euclidean distance as candidates. For example, the vector expression of the existing entity "cleaning catkins" is:
[0136] {0.3771764636039734,0.5516735315322876,0.03295145556330681…-0.32312124967575073,-0.3187197744846344}, the similarity of the two vectors calculated based on Euclidean is 0.81. To ensure the accuracy of entity matching, the BERT model is used to recalculate the similarity scores of these candidate entities. Only when the score is higher than the set threshold of 0.85 and the score is the highest, the candidate entity is considered to be semantically consistent with the input entity and adopted as a replacement, thus completing the entity unification.
[0137] Example 2
[0138] The wind power knowledge graph entity unification system provided in this embodiment is used to implement the wind power knowledge graph entity unification method described in Example 1, including:
[0139] A data collection module, used to collect text data from wind power maintenance work orders;
[0140] The data preprocessing and preliminary annotation module is used to clean and preprocess the text data, and to preliminarily annotate the preprocessed text data, including:
[0141] Text data is collected from wind power maintenance work orders. The text data is used as the original entity. Regular expressions are defined to clean the original entities, remove punctuation marks, empty characters, and specific wind turbine number information. Then, the Levenshtein distance and Jaccard coefficient similarity algorithms are used to preliminarily pair entities with similar expressions under the same attributes to form a data set T; the entities are preliminarily labeled, entities with the same meaning are positive samples, marked as 1, and entities with different meanings are negative samples, marked as 0, so that the ratio between positive samples and negative samples is 1:1, and divided into a training set Ttrain and a test set Ttest, with a ratio of 4:1 between the training set and the test set;
[0142] The similarity model building module is used to input the preliminarily annotated text data into the BERT-based pre-training model for training and build a BERT-based similarity model, including:
[0143] First, each entity pair is concatenated together using the [SEP] identifier, and then the [CLS] identifier is added before the entity pair. The maximum length of the entity pair is 512. The part of the actual entity pair that exceeds the maximum length needs to be trimmed, and the part of the actual entity pair that does not exceed the maximum length needs to be padded with 0. The obtained entity pair is vectorized and encoded based on the BERT pre-trained model, with a dimension of 768;
[0144] Then build the architecture of the training model. Modify the output dimension on the existing network architecture to achieve the binary classification task. That is, add a fully connected layer with an output dimension of 1 at the end of the network structure of the BERT model, and then add a Sigmoid activation function to the fully connected layer:
[0145]
[0146] Where x is the input value, e is the base of the natural logarithm, and σ(x) is the output value of the Sigmoid activation function. The original output of the fully connected layer is mapped to the interval (0,1) through a linear transformation, which is expressed as the similarity probability p of the entity pair.
[0147] Next, select the loss function and the optimizer used for optimization during training, the binary cross entropy loss for the binary classification task:
[0148] BinaryCross-EntropyLoss=-(y*log(p)+(1-y)*log(1-p))
[0149] Among them, y is the true value, which takes a value of 0 or 1, p is the probability that the model predicts that the sample is a positive sample, that is, the predicted output, log is the natural logarithm, and the optimizer selects AdamW;
[0150] Finally, the BERT model is fine-tuned based on the processed data, the defined model architecture, loss function, optimizer, number of epochs, batch size of data for each training, and the learning rate of the optimizer, and the model effect is evaluated. The evaluation criterion is accuracy:
[0151]
[0152] Among them, TP is the true positive example, which refers to the number of samples correctly predicted by the model as positive; TN is the true negative example, which refers to the number of samples correctly predicted by the model as negative; FP is the false positive example, which refers to the number of negative samples incorrectly predicted by the model as positive; FN is the false negative example, which refers to the number of positive samples incorrectly predicted by the model as negative.
[0153] The similarity clustering and entity replacement dictionary making module makes similarity clustering and entity replacement words according to the similarity model to form an entity replacement dictionary, including:
[0154] The BERT-based similarity model is used to iterate all entities with the same attribute and compare the output similarity scores. When the similarity score is greater than the preset threshold, all entities are classified into the same category to form an entity replacement dictionary; the entity replacement dictionary includes the representative entity at the center of each category and other entities similar to the representative entity.
[0155] The entity vectorization and entity vector library construction module converts text data into entity vectors based on the Word2Vec model, classifies and stores entity vectors, and builds an entity vector library, including:
[0156] Word2Vec converts words into fixed-length vector representations by learning contextual information in text data. That is, the Word2Vec model learns word vectors by optimizing the objective function, which is expressed as:
[0157]
[0158] Among them, ω i is a given word, ω context is the context of the word, θ is the model parameter, and N is the number of training samples;
[0159] All entities are segmented using Jieba's Chinese word segmentation function, and sent to the Word2Vec model for training to obtain the vector expression of each word with a dimension of 100. Then, all word vectors of each entity are averaged to obtain the fixed-dimensional vector expression of the entity. After obtaining the entity vector, the Ball-Tree and KD-Tree spatial index structures are used to store these vectors according to entity attribute classification to build an entity vector library.
[0160] The entity vector library is dynamically updated by adding new entities and updating existing entity vectors. At the same time, the retrieval performance and accuracy are optimized by adjusting the hyperparameters of the Word2Vec model and the configuration of the spatial index structure.
[0161] Entity unification and threshold determination module: when a new entity is input, if there is a corresponding entry between the new entity and the entity replacement dictionary, the new entity is directly replaced with the entity replacement word; if there is no corresponding entry between the new entity and the entity replacement dictionary, the similarity model is used to compare the similarity with the entities in the entity vector library until the similarity is greater than the preset threshold, then the new entity is considered to be unified with the entity in the entity vector library, including:
[0162] When introducing a new entity, first check whether there is an entry corresponding to the new entity in the entity replacement dictionary. If there is an entry corresponding to the new entity, it is directly replaced with the representative entity; if there is no entry corresponding to the new entity, locate it in the corresponding entity vector library according to the entity attributes; then, use the Word2Vec model to vectorize the entity, and then start a similarity search in the entity vector library, which is based on cosine similarity or Euclidean distance;
[0163] In the similarity search, the top 10 to 20 entities in similarity ranking are initially screened out as candidate sets. The similarity scores of these candidate entities are recalculated using the BERT-based similarity model. Only when the score is higher than the set threshold, the candidate entity is considered to be semantically consistent with the input entity and adopted as a replacement.
[0164] Example 3
[0165] This embodiment discloses a non-transitory computer-readable medium storing instructions. When the instructions are executed by a processor, the steps of the wind power knowledge graph entity unification method described in Example 1 are performed.
[0166] The non-temporary computer-readable medium in this embodiment may be a disk, an optical disk, a computer memory, a read-only memory (ROM), a random access memory (RAM), a USB flash drive, a mobile hard disk, or other media.
[0167] Example 4
[0168] This embodiment discloses a computing device, including a processor and a memory for storing a program executable by the processor. When the processor executes the program stored in the memory, the wind power knowledge graph entity unification method described in Example 1 is implemented.
[0169] The computing device described in this embodiment may be a desktop computer, a laptop computer, a smart phone, a PDA handheld terminal, a tablet computer, a programmable logic controller (PLC), or other terminal devices with a processor function.
[0170] The embodiments described above are only preferred embodiments of the present invention and are not intended to limit the scope of implementation of the present invention. Therefore, all changes made according to the shape and principle of the present invention should be included in the protection scope of the present invention.
Claims
1. A wind power knowledge graph entity unification method, characterized in that: The following steps are involved: S1. Collect text data from wind power maintenance work orders, perform pre-processing of the text data by cleaning and pairing, and perform preliminary labeling on the pre-processed text data; S2, input the preliminarily annotated text data into the BERT-based pre-training model for training, and build a BERT-based similarity model; S3, based on the similarity model, making similarity clusters and entity replacement words to form an entity replacement dictionary; S4. Convert text data into entity vectors based on the Word2Vec model, classify and store the entity vectors, and build an entity vector library; S5. When a new entity is input, if there is a corresponding entry between the new entity and the entity replacement dictionary, the entity replacement word is used to directly replace the new entity. If there is no corresponding entry between the new entity and the entity replacement dictionary, the similarity model is used to compare the entities in the entity vector library. When the similarity is greater than a preset threshold, the new entity is considered to be unified with the entity in the entity vector library.
2. A wind power knowledge graph entity unification method according to claim 1, characterized in that: The step S1 comprises: Text data is collected from wind power maintenance work orders. The text data is used as the original entity. Regular expressions are defined to clean the original entities to remove punctuation marks, empty characters and specific wind turbine number information. Then, the Levenshtein distance and Jaccard coefficient similarity algorithms are used to preliminarily pair entities with similar expressions under the same attributes to form a data set T; the entities are preliminarily labeled, entities with the same meaning are positive samples, marked as 1, and entities with different meanings are negative samples, marked as 0, so that the ratio between positive samples and negative samples is 1:1, and they are divided into a training set Ttrain and a test set Ttest, and the ratio of the training set to the test set is 4:
1.
3. A wind power knowledge graph entity unification method according to claim 1, characterized in that: The step S2 comprises: First, each entity pair is concatenated together using the [SEP] identifier, and then the [CLS] identifier is added before the entity pair. The maximum length of the entity pair is 512. The part of the actual entity pair that exceeds the maximum length needs to be trimmed, and the part of the actual entity pair that does not exceed the maximum length needs to be padded with 0. The obtained entity pair is vectorized and encoded based on the BERT pre-trained model, with a dimension of 768; Then build the architecture of the training model. Modify the output dimension on the existing network architecture to achieve the binary classification task. That is, add a fully connected layer with an output dimension of 1 at the end of the network structure of the BERT model, and then add a Sigmoid activation function to the fully connected layer: Where x is the input value, e is the base of the natural logarithm, and σ(x) is the output value of the Sigmoid activation function. The original output of the fully connected layer is mapped to the interval (0,1) through a linear transformation, which is expressed as the similarity probability p of the entity pair. Next, select the loss function and the optimizer used for optimization during training, the binary cross entropy loss for the binary classification task: BinaryCross-EntropyLoss=-(y*log(p)+(1-y)*log(1-p)) Among them, y is the true value, which takes a value of 0 or 1, p is the probability that the model predicts that the sample is a positive sample, that is, the predicted output, log is the natural logarithm, and the optimizer selects AdamW; Finally, the BERT model is fine-tuned based on the processed data, the defined model architecture, loss function, optimizer, and the set training parameters, and the model effect is evaluated. The evaluation criterion is accuracy: Among them, TP is the true positive example, which refers to the number of samples correctly predicted by the model as positive; TN is the true negative example, which refers to the number of samples correctly predicted by the model as negative; FP is the false positive example, which refers to the number of negative samples incorrectly predicted by the model as positive; FN is the false negative example, which refers to the number of positive samples incorrectly predicted by the model as negative.
4. A wind power knowledge graph entity unification method according to claim 3, characterized in that: The set training parameters include the number of iterations epoch, the amount of data batch size for each training, and the learning rate learningrate of the optimizer.
5. A wind power knowledge graph entity unification method according to claim 1, characterized in that: The step S3 comprises: The BERT-based similarity model is used to iterate all entities with the same attribute and compare the output similarity scores. When the similarity score is greater than the preset threshold, all entities are classified into the same category to form an entity replacement dictionary; the entity replacement dictionary includes the representative entity at the center of each category and other entities similar to the representative entity.
6. A wind power knowledge graph entity unification method according to claim 1, characterized in that: The step S4 comprises: Word2Vec converts words into fixed-length vector representations by learning contextual information in text data. That is, the Word2Vec model learns word vectors by optimizing the objective function, which is expressed as: Among them, ω i is a given word, ω context is the context of the word, θ is the model parameter, and N is the number of training samples; All entities are segmented using Jieba's Chinese word segmentation function, and sent to the Word2Vec model for training to obtain the vector expression of each word with a dimension of 100. Then, all word vectors of each entity are averaged to obtain the fixed-dimensional vector expression of the entity. After obtaining the entity vector, these vectors are stored according to entity attribute classification using the spatial index structure to build an entity vector library. The entity vector library is dynamically updated by adding new entities and updating existing entity vectors. At the same time, the retrieval performance and accuracy are optimized by adjusting the hyperparameters of the Word2Vec model and the configuration of the spatial index structure.
7. A wind power knowledge graph entity unification method according to claim 6, characterized in that: The spatial index structure includes Ball-Tree and KD-Tree.
8. A wind power knowledge graph entity unification method according to claim 1, characterized in that: The step S5 comprises: When introducing a new entity, first check whether there is an entry corresponding to the new entity in the entity replacement dictionary. If there is an entry corresponding to the new entity, it is directly replaced with the representative entity; if there is no entry corresponding to the new entity, locate it in the corresponding entity vector library according to the entity attributes; then, use the Word2Vec model to vectorize the entity, and then start a similarity search in the entity vector library, which is based on cosine similarity or Euclidean distance; In the similarity search, the top 10 to 20 entities in similarity ranking are initially screened out as candidate sets. The similarity scores of these candidate entities are recalculated using the BERT-based similarity model. Only when the score is higher than the set threshold, the candidate entity is considered to be semantically consistent with the input entity and adopted as a replacement.
9. A wind power knowledge graph entity unified system, characterized in that: A method for realizing the entity unification of wind power knowledge graphs as described in any one of claims 1 to 8, comprising: A data collection module, used to collect text data from wind power maintenance work orders; The data preprocessing and preliminary annotation module is used to clean and preprocess the text data, and to preliminarily annotate the preprocessed text data; The similarity model building module is used to input the preliminarily annotated text data into the BERT-based pre-training model for training and build a BERT-based similarity model; A similarity clustering and entity replacement dictionary making module makes similarity clustering and entity replacement words according to the similarity model to form an entity replacement dictionary; The entity vectorization and entity vector library construction module converts text data into entity vectors based on the Word2Vec model, classifies and stores entity vectors, and builds an entity vector library; Entity unification and threshold determination module, when a new entity is input, if there is a corresponding entry between the new entity and the entity replacement dictionary, the entity replacement word is used to directly replace the new entity. If there is no corresponding entry between the new entity and the entity replacement dictionary, the similarity model is used to compare the entities in the entity vector library. When the similarity is greater than the preset threshold, the new entity is considered to be unified with the entities in the entity vector library.
10. A wind power knowledge graph entity unified system according to claim 9, characterized in that: The data preprocessing and preliminary annotation module includes: Text data is collected from wind power maintenance work orders. The text data is used as the original entity. Regular expressions are defined to clean the original entities, remove punctuation marks, empty characters, and specific wind turbine number information. Then, the Levenshtein distance and Jaccard coefficient similarity algorithms are used to preliminarily pair entities with similar expressions under the same attributes to form a data set T; the entities are preliminarily labeled, entities with the same meaning are positive samples, marked as 1, and entities with different meanings are negative samples, marked as 0, so that the ratio between positive samples and negative samples is 1:1, and divided into a training set Ttrain and a test set Ttest, with a ratio of 4:1 between the training set and the test set; The similarity model building module includes: First, each entity pair is concatenated together using the [SEP] identifier, and then the [CLS] identifier is added before the entity pair. The maximum length of the entity pair is 512. The part of the actual entity pair that exceeds the maximum length needs to be trimmed, and the part of the actual entity pair that does not exceed the maximum length needs to be padded with 0. The obtained entity pair is vectorized and encoded based on the BERT pre-trained model, with a dimension of 768; Then build the architecture of the training model. Modify the output dimension on the existing network architecture to achieve the binary classification task. That is, add a fully connected layer with an output dimension of 1 at the end of the network structure of the BERT model, and then add a Sigmoid activation function to the fully connected layer: Where x is the input value, e is the base of the natural logarithm, and σ(x) is the output value of the Sigmoid activation function. The original output of the fully connected layer is mapped to the interval (0,1) through a linear transformation, which is expressed as the similarity probability p of the entity pair. Next, select the loss function and the optimizer used for optimization during training, the binary cross entropy loss for the binary classification task: BinaryCross-EntropyLoss=-(y*log(p)+(1-y)*log(1-p)) Among them, y is the true value, which takes a value of 0 or 1, p is the probability that the model predicts that the sample is a positive sample, that is, the predicted output, log is the natural logarithm, and the optimizer selects AdamW; Finally, the BERT model is fine-tuned based on the processed data, the defined model architecture, loss function, optimizer, number of epochs, batch size of data for each training, and the learning rate of the optimizer, and the model effect is evaluated. The evaluation criterion is accuracy: Among them, TP is the true positive example, which refers to the number of samples correctly predicted by the model as positive; TN is the true negative example, which refers to the number of samples correctly predicted by the model as negative; FP is the false positive example, which refers to the number of negative samples incorrectly predicted by the model as positive; FN is the false negative example, which refers to the number of positive samples incorrectly predicted by the model as negative. The similarity clustering and entity replacement dictionary making module includes: The BERT-based similarity model is used to iterate all entities with the same attribute and compare the output similarity scores. When the similarity score is greater than the preset threshold, all entities are classified into the same category to form an entity replacement dictionary; the entity replacement dictionary includes the representative entity at the center of each category and other entities similar to the representative entity. The entity vectorization and entity vector library construction module includes: Word2Vec converts words into fixed-length vector representations by learning contextual information in text data. That is, the Word2Vec model learns word vectors by optimizing the objective function, which is expressed as: Among them, ω i is a given word, ω context is the context of the word, θ is the model parameter, and N is the number of training samples; All entities are segmented using Jieba's Chinese word segmentation function, and sent to the Word2Vec model for training to obtain the vector expression of each word with a dimension of 100. Then, all word vectors of each entity are averaged to obtain the fixed-dimensional vector expression of the entity. After obtaining the entity vector, the Ball-Tree and KD-Tree spatial index structures are used to store these vectors according to entity attribute classification to build an entity vector library. The entity vector library is dynamically updated by adding new entities and updating existing entity vectors. At the same time, the retrieval performance and accuracy are optimized by adjusting the hyperparameters of the Word2Vec model and the configuration of the spatial index structure. The entity unification and threshold determination module includes: When introducing a new entity, first check whether there is an entry corresponding to the new entity in the entity replacement dictionary. If there is an entry corresponding to the new entity, it is directly replaced with the representative entity; if there is no entry corresponding to the new entity, locate it in the corresponding entity vector library according to the entity attributes; then, use the Word2Vec model to vectorize the entity, and then start a similarity search in the entity vector library, which is based on cosine similarity or Euclidean distance; In the similarity search, the top 10 to 20 entities in similarity ranking are initially screened out as candidate sets. The similarity scores of these candidate entities are recalculated using the BERT-based similarity model. Only when the score is higher than the set threshold, the candidate entity is considered to be semantically consistent with the input entity and adopted as a replacement.
Citation Information
Cited By
Data classification and grading method and system based on large model
CN119669475A
Learning resource recommendation method and system based on heterogeneous graph denoising attention network
CN119848659A
Knowledge graph optimization method and system
CN120745782A
