Dynamic text-oriented incremental entity analysis method, readable storage medium and device

Abstract

The invention relates to the technical field of text data processing, in particular to a dynamic text-oriented incremental entity analysis method, a readable storage medium and a device, and the method comprises the steps: filtering obviously mismatched entity description text pairs based on a coarse tuning filtering module of a neural network language model, and generating a candidate entity text pair set; a feature fusion module based on deep semantics generates an entity text pair high-order semantic vector fused with context information; and a fine tuning analysis module based on deep metric learning enhances the capability of capturing the semantic relationship in the text to obtain an analysis result of the entity text pair. And the incremental entity analysis part is used for performing incremental entity analysis on the dynamic text data, and iteratively optimizing parameters of a fine adjustment analysis model by continuously utilizing high-credibility matching and mismatching entity text pairs of each time step. According to the method, incremental entity analysis is performed on the dynamic text data, and the fine tuning analysis model of each time step can analyze a high-credibility annotation data set from the analysis result of the previous time step.

Description

Technical Field

[0001] The present invention relates to the technical field of text data processing, and in particular to an incremental entity parsing method, a readable storage medium and a device for dynamic text. Background Art

[0002] As a key technology of data fusion, entity resolution aims to accurately determine whether two entity text descriptions refer to the same object in the real world, and can provide high-quality data guarantee for intelligent decision-making and analysis in various fields. The entire resolution process is usually divided into two stages: coarse adjustment and fine adjustment. The coarse adjustment stage focuses on reducing the false negative error rate, and the fine adjustment stage focuses on reducing the false positive error rate. The two stages complement each other and jointly guarantee the entity identity of the entire data set. The main task of the coarse adjustment stage is to filter out possible matching entity text pairs from massive data to form a set of candidate entity text pairs, that is, to use a "coarser sieve" to filter candidate entity text pairs to ensure that all potential matching pairs can be included in the candidate set. The so-called sieve is a rough screening method used in the data processing process, such as filtering out all possible matching entity text pairs in the text data set through a series of effective filtering techniques or rules. Its purpose is to reduce the size of the candidate entity text pair set as much as possible while ensuring the recall rate, thereby improving the processing efficiency and accuracy of the subsequent fine adjustment stage. The main task of the fine-tuning stage is to build an accurate entity resolution model based on application requirements and data features to identify the entity text pairs that truly match in the candidate set. Most of these fine-tuning resolution methods use intelligent data processing technologies, such as matching rules, machine learning methods, and deep neural networks, to conduct in-depth analysis of the text semantics of entities to ensure that only those entity text pairs that truly match are identified.

[0003] Academia and industry have proposed some rule-based methods (such as disjunctive normal form and general Boolean formula), machine learning-based methods (such as SVM and random forest), and deep neural network-based methods (such as DeepER, DeepMatcher, and Ditto). These methods have achieved certain results in solving entity resolution problems, but they also have some limitations. Rule-based methods usually rely on a set of rules defined in advance by domain experts, and it is difficult to effectively model dynamically changing complex language environments and diverse entity description texts; compared with rule-based methods, machine learning-based methods have stronger adaptability and generalization capabilities, and can construct effective text semantics or grammatical features through feature engineering, and better handle complex text data in business scenarios. However, machine learning-based methods require a large number of annotated entity text pairs for model training, and are more sensitive to the distribution of text data. If the number of annotated entity text pairs is insufficient or there is a deviation, the generalization ability of such fine-tuning parsing methods will be seriously affected. Deep neural network-based methods can automatically learn text semantic feature representations, thereby showing good generalization capabilities when processing complex tasks. However, existing entity resolution methods based on deep neural networks can only handle static text scenarios and cannot effectively respond to the business needs of dynamic text in real scenarios. The so-called dynamic text refers to the fact that the entity description text in the data set will continue to accumulate over time. For the sake of presentation, assume that and is an incremental data set from two heterogeneous data sources, and both consist of n time steps of incremental data, 0≤n≤+∞. Depend on and Composition, that is in Refers to the incremental text data generated by the first data source in the kth time step. The incremental entity resolution problem is to parse these incremental text data sets (such as and ), and finally predicted and All matching entity description pairs in . However, most of the existing entity resolution methods are static text processing methods, which have significant limitations when processing dynamic texts such as scientific literature. Since the text descriptions of scientific literature have the characteristic of increasing over time, the dynamic entity resolution model needs to continuously optimize itself to adapt to the changes in statistical characteristics and probability distribution of the data set caused by the dynamic changes of data, while static methods usually need to retrain the entire model to adapt to the new data distribution. This approach is not only inefficient but also costly, especially when dealing with large-scale data sets, its limitations are particularly prominent.

[0004] In order to solve this problem, it is urgent to conduct in-depth research on incremental entity resolution technology. This technology focuses on achieving efficient entity resolution for dynamic text. This technology can adapt to the dynamic changes and growth of entity description text by continuously updating model parameters and optimizing the resolution model, thereby significantly improving the resolution efficiency and accuracy of dynamic entity description text, and providing a more intelligent and reliable high-quality data solution for dynamic text-based applications (such as scientific literature data integration). Summary of the invention

[0005] In dynamic text scenarios such as scientific and technological literature, traditional static entity resolution methods often have difficulty coping with the continuous updates and changes of dynamic texts, and static methods are usually unable to identify processed high-confidence matches or mismatches. Traditional static methods may "remember" the noise contained in the annotated text pairs during the training process. When new text that is significantly different from the training text pairs appears, the model may produce erroneous resolution results due to the interference of noise, resulting in a decrease in the resolution effect. In view of this, the present invention proposes an incremental entity resolution method, a readable storage medium and a device for dynamic text, which can perform incremental entity resolution on dynamic text data, and the fine-tuning resolution model at each time step can use a data enhancement strategy based on credibility measurement to analyze a high-confidence annotation data set from the resolution results of the previous time step, which is used to continuously optimize the parameters of the fine-tuning resolution model to compensate for the impact of the insufficient annotated text pairs on the performance of the fine-tuning resolution model.

[0006] To achieve the above purpose, the technical solution adopted is:

[0007] An incremental entity resolution method for dynamic text, including fine-tuning resolution and incremental entity resolution;

[0008] The fine-tuning parsing part includes a coarse-tuning filtering module based on a neural network language model, a feature fusion module based on deep semantics, and a fine-tuning parsing module based on deep metric learning; the coarse-tuning filtering module based on a neural network language model filters out obviously mismatched entity description text pairs and generates a set of candidate entity text pairs; the feature fusion module based on deep semantics generates high-order semantic vectors of entity text pairs that integrate contextual information; the fine-tuning parsing module based on deep metric learning enhances the ability to capture semantic relationships in texts and obtains parsing results for entity text pairs;

[0009] The incremental entity resolution part performs incremental entity resolution on dynamic text data and iteratively optimizes and fine-tunes the parameters of the resolution model by continuously utilizing the high-confidence matching and non-matching entity text pairs at each time step.

[0010] According to the incremental entity parsing method for dynamic text of the present invention, further, the processing process of the coarse adjustment filtering module based on the neural network language model is as follows:

[0011] Concatenate all attribute values ​​of each entity in two heterogeneous text sets into a string to construct the attribute signature of each entity;

[0012] A neural network language model is used to generate a high-dimensional vector representation of each word in the attribute signature to obtain a sequence of word embedding vectors;

[0013] Use an autoencoder to aggregate these word embedding vector sequences into two vector sets;

[0014] A set of candidate entity-text pairs is generated using a cosine pairing-based filtering strategy.

[0015] According to the incremental entity parsing method for dynamic text of the present invention, further, a set of candidate entity text pairs is generated by using a cosine pairing-based filtering strategy, including:

[0016] For any entity description text in a text set, calculate the cosine similarity between its embedding vector and all entity embedding vectors in another text set, select the top k most similar entity description texts as the candidate set according to the similarity score, connect an entity with its candidate entity, and form a set of candidate entity text pairs.

[0017] According to the incremental entity resolution method for dynamic text of the present invention, further, the processing process of the feature fusion module based on deep semantics is as follows:

[0018] Use the neural network language model to map a candidate entity to p and Construct the corresponding word embedding vector sequences u1 and u2;

[0019] Since u1 and u2 can serve as each other's context sequences, u1 is regarded as the main input sequence and u2 as the context sequence. A high-order semantic vector of u1's fused context information is constructed by using a bidirectional recurrent neural network with an attention mechanism. Where d is a hyperparameter and m is the number of elements contained in u1. Similarly, consider u2 as the main input sequence and u1 as the context sequence, and repeat the above steps to construct a high-order semantic vector of u2 that integrates the context information. Where n is the number of elements contained in u2;

[0020] A learnable distance function Dis(·) is used for x1 and x2, and a high-order semantic vector x of an entity text pair is obtained by element-by-element comparison. p .

[0021] According to the incremental entity parsing method for dynamic text of the present invention, further, the calculation process of the high-order semantic vector x1 is as follows:

[0022] First, the sequence u2 is encoded by Bi-RNN to obtain the semantics h2 of the sequence u2;

[0023] Then calculate the soft alignment code b1 of sequence u1: ① Use the soft alignment score score between the mth element in sequence u1 and the nth element in sequence u2 m,n Calculate the alignment weight value of sequence u2 to sequence u1 through the softmax layer, that is, the soft alignment matrix W; ② Use the weights obtained from the soft alignment matrix W to perform weighted average on the encoding of each h2[n] to obtain the soft alignment code b1[m]∈b1 of each element u1[m] in sequence u1;

[0024] Finally, the high-order semantic vector x1 of the fused context information of sequence u1 is calculated: ① Calculate the comparison vector of each sequence element; ② Use Bi-RNN and HighWayNet networks to fuse the context information of sequence u1 and generate the corresponding semantic vector x1;

[0025] The soft alignment score m,n The calculation process is: first use a two-layer HighWayNet network with ReLU to obtain the d-dimensional representation q of u1[m] and u2[n] 1,m ,q 2,n ; Then by taking q 1,m and q 2,n The dot product of is an unnormalized score.

[0026] According to the incremental entity resolution method for dynamic text of the present invention, further, calculating the comparison vector of each sequence element includes: firstly encoding the sequence u1 by Bi-RNN to obtain u'1; then using HighwayNet including a ReLU layer to compare u'1 and b1 element by element to generate a comparison vector c1[m], where c1[m] is a comparison representation of u1[m]∈u1;

[0027] The process of generating the corresponding semantic vector x1 using Bi-RNN and HighWayNet networks is as follows: first, use Bi-RNN to re-encode the sequence u2 to obtain the encoding h'2 of the last hidden state of the sequence u2; secondly, concatenate each c1[m] with h'2 to form an extended representation e1[m]; then, a HighwayNet network containing a ReLU layer takes e1[m] as input and calculates its weight through a softmax layer; finally, c1[m] is weighted averaged according to these weights to obtain the final output representation x1.

[0028] According to the incremental entity parsing method for dynamic text of the present invention, further, the processing process of fine-tuning the parsing module based on deep metric learning is as follows:

[0029] Since each category has K different centers, the high-order semantic vector x of the entity-text pair p The similarity measure relationship with a certain category is quantified as a high-order semantic vector x p The highest value of similarity with the center to which this category belongs;

[0030] Since the K different centers of category c follow the probability distribution q, the high-order semantic vector of the i-th entity-text pair is maximized by adjusting the probability distribution q. The weighted similarity with all centers in category c finally obtains the high-order semantic vector of the i-th entity-text pair The relaxed similarity measure S' between category c i,c ;

[0031] Using the relaxed similarity measure S' i,c The SoftTriple loss function is optimized, which not only describes the differences between samples within a class, but also quantifies the distinction between different classes. A regular term that constrains the number of class centers is added to the SoftTriple loss function.

[0032] According to the incremental entity resolution method for dynamic text of the present invention, further, the processing process of the incremental entity resolution part is as follows:

[0033] First, a credibility measure u(i) of the entity text on the prediction result is defined using statistical learning technology;

[0034] Then set the dynamically adjustable credibility metric threshold k p : Credibility measurement threshold k p The initial value of is the median of the credibility measure u(i) in the initial training set; when the enhanced entity text is injected into the data at the next time step, update k p is the median of the credibility measure of the high-confidence entity-text pair and the initial credibility measure;

[0035] Then, at each time step, the credibility measure u(i) of the prediction result and the credibility measure threshold k of the enhanced entity text are used to calculate the credibility measure u(i) of the prediction result. p To calibrate the matching probability value of the enhanced entity text pair, and then compare the calibrated matching probability value with the dynamic threshold to build a highly reliable set of annotated entity text pairs.

[0036] Furthermore, the present invention also provides an incremental entity resolution device for dynamic text, which is used to implement the incremental entity resolution method for dynamic text as described above, and the device comprises:

[0037] A coarse-tuning filtering module based on a neural network language model is used to filter out obviously mismatched entity description text pairs and generate a set of candidate entity text pairs;

[0038] A feature fusion module based on deep semantics is used to generate high-order semantic vectors of entity text pairs that incorporate contextual information;

[0039] A fine-tuned parsing module based on deep metric learning is used to enhance the ability to capture semantic relationships in text and obtain parsing results for entity-text pairs;

[0040] Based on the data augmentation strategy of credibility measurement, incremental entity parsing is performed on dynamic text data, and the parameters of the parsing model are iteratively optimized and fine-tuned by continuously utilizing the high-confidence matching and non-matching entity text pairs at each time step.

[0041] Furthermore, the present invention also provides a readable storage medium having a computer program stored thereon, wherein the computer program implements the steps of the above method when executed by a processor.

[0042] The beneficial effects achieved by adopting the above technical solution are:

[0043] 1. The present invention can effectively handle incremental entity resolution tasks for dynamic texts, and optimizes and fine-tunes the resolution model step by step with data enhancement strategies, so that it can automatically adapt to the new text data distribution, improving the efficiency and response speed of entity resolution without the need to repeatedly train the entire text data set. The present invention uses data enhancement strategies to continuously optimize and fine-tune the resolution model parameters, which can dynamically adapt to changes in data feature distribution, significantly improving the model's adaptability and resolution effect in incremental entity resolution tasks for dynamic texts.

[0044] 2. The present invention proposes a fine-tuning parsing module based on deep metric learning. This module is the first to migrate the SoftTriple technology in the field of computer vision to the entity parsing task. It effectively models multiple information clusters between entities through a multi-center mechanism and constructs an accurate similarity measurement between entity text pairs to accurately determine whether the entity text pairs match.

[0045] 3. The present invention proposes a data enhancement strategy based on credibility measurement, which calibrates the matching probability value of the entity text pair to be determined in the previous time step by fusing the relaxed similarity measurement and the cosine similarity based on TF-IDF, thereby identifying high-credibility matching pairs and non-matching pairs to optimize the fine-tuning parsing model of the next time step. With the continuous accumulation of new texts, the strategy can dynamically adjust and optimize the fine-tuning parsing model of the next stage, so that it can continuously model the data feature distribution of entity description text pairs, thereby significantly improving the accuracy of entity parsing and the robustness of the model, and can make up for the impact of the scarcity of labeled data on the fine-tuning parsing model. BRIEF DESCRIPTION OF THE DRAWINGS

[0046] In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the following briefly introduces the drawings of the embodiments of the present invention, wherein the drawings are only used to illustrate some embodiments of the present invention, but not to limit all embodiments of the present invention thereto.

[0047] Figure 1 It is an overall framework diagram of the incremental entity resolution method for dynamic text according to an embodiment of the present invention;

[0048] Figure 2 It is a workflow diagram of a coarse adjustment filtering module based on a neural network language model according to an embodiment of the present invention. DETAILED DESCRIPTION

[0049] The following will be combined with the drawings of specific embodiments of the present invention to clearly and completely describe the exemplary scheme of the embodiment of the present invention. Unless otherwise defined, the technical terms or scientific terms used in the present invention should be the common meanings understood by people with ordinary skills in the field.

[0050] This embodiment discloses an incremental entity resolution method for dynamic texts (IERDT), which includes two parts: fine-tuning resolution and incremental entity resolution. The overall framework is as follows: Figure 1 shown.

[0051] The core task of the fine-tuning parsing part is to parse entity description text pairs using intelligent data processing technologies such as deep metric learning and pre-trained language models to identify entity description text pairs that describe the same entity in the real world. This part includes a coarse-tuning filtering module based on a neural network language model, a feature fusion module based on deep semantics, and a fine-tuning parsing module based on deep metric learning. The coarse-tuning filtering module based on the neural network language model uses the neural network language model to construct effective text features and filter out obviously mismatched entity description text pairs, thereby effectively removing noise and interfering entity description texts. The feature fusion module based on deep semantics can effectively extract and fuse the dependencies between entity description texts at different positions in the context. The fine-tuning parsing module based on deep metric learning uses the idea of ​​deep metric learning to enhance the model's ability to capture semantic relationships in text, thereby enhancing the model's ability to understand the semantics of entity text.

[0052] (1) Coarse-tuning filtering module based on neural network language model: In order to effectively filter out noise, this module uses a neural network language model to analyze the semantics of attribute text and constructs a coarse-tuning filtering mechanism. First, all attribute values ​​of each entity are connected into a complete text string and converted into a high-dimensional semantic vector set of the entity using a neural network language model. Then, a set of candidate entity text pairs is constructed using the k-nearest neighbor algorithm. Since the entity semantic vector set quantifies the global semantics of the entity description text, in order to screen out candidate entities related to the given entity description semantics, the similarity between these semantic vectors is first calculated, and then the top k entities most similar to the given entity attributes are selected according to the similarity sorting, thereby generating a high-quality candidate entity text pair set for each entity description text.

[0053] Specifically, if we directly use two heterogeneous text sets and For comparison and matching, the definition of Cartesian product shows that the size of the candidate entity text pair set is and This makes it possible to directly access heterogeneous data sources and Analyzing all candidate entity text pairs in the dataset consumes a lot of time, reducing the execution efficiency of the fine-tuning parsing model. On the other hand, it is inevitable that there are noise or interference entities in the huge set of candidate entity text pairs, which affects the parsing accuracy of the model. Therefore, this embodiment uses a neural network language model to model the deep semantics of entities, designs an efficient coarse-tuning filtering mechanism to filter out those obviously mismatched noise entity description texts, and generates a concise and high-quality set of candidate entity text pairs for the feature fusion module based on deep semantics. Figure 2 The workflow of the coarse-tuning filtering module based on the neural network language model is given.

[0054] The core purpose of this module is to reduce the size of the candidate set as much as possible by filtering out noise data, such as obviously mismatched entity text pairs, while ensuring the recall rate. The filtering module translates the high-order semantics of entity descriptions in heterogeneous data sources into vector representations that can be understood by computers through a neural network language model and an autoencoder, and generates a set of candidate entity text pairs through a filtering strategy based on cosine pairing. The specific processing steps are as follows:

[0055] ① and All attribute values ​​of each entity in are concatenated into a string to construct the attribute signature of each entity.

[0056] ② Use a neural network language model (such as fastText) to generate a high-dimensional vector representation of each word in the attribute signature. These vectors contain the semantics, grammar and other information of the word, and obtain a sequence of word embedding vectors.

[0057] ③Use the tuple embedding method based on the autoencoder to aggregate these word embedding vector sequences into two vector sets and Make and Each entity description text in has a corresponding text embedding vector.

[0058] ④ Generate a set of candidate entity text pairs using a cosine pairing-based filtering strategy Specifically, for (or ) in any entity description text, calculate its embedding vector and (or ), selects the top k most similar entity description texts as the candidate set according to the similarity score, connects an entity with its candidate entities, and forms a candidate entity text pair set. This process effectively eliminates entities that are significantly mismatched in attributes and significantly reduces the size of the candidate set.

[0059] (2) Feature fusion module based on deep semantics: In order to overcome the limitation of the lack of contextual information in the initial embedding and model the complex semantic relationship contained in the entity description text, this embodiment uses a bidirectional recurrent neural network with an attention mechanism to enhance the fine-tuning parsing model's ability to understand and integrate the deep semantic connotations of the candidate entity text. First, a neural network language model (such as fastText, etc.) is used to generate high-quality text vector representations. Secondly, the context information is captured in these embedding representations through Bi-RNN, and the deep features of the main input sequence and the context sequence are extracted at the same time. During the traversal of the main input sequence, each word sequence will find its corresponding aligned word sequence in the context sequence through the attention mechanism. By comparing the semantic differences between the main sequence words and their corresponding words in the context sequence, the semantic representation of the words is further enriched to obtain a word comparison vector. Thirdly, the comparison vectors are fused by weighted averaging to obtain a high-order semantic vector of the main input sequence. Similarly, by reversing the positions of the main input sequence and the context sequence, a high-order semantic vector of another main input sequence is obtained. Finally, a learnable distance function is used to obtain a high-order semantic vector representation of all entity text pairs through element-by-element comparison operations.

[0060] Specifically, the core idea of ​​this module is to draw on the idea of ​​contextual learning, use a bidirectional recurrent neural network with an attention mechanism, analyze the semantic information and embedded representation of the contextual information of the candidate entity text pairs output in the previous stage, and use a learnable distance function to fuse these embedded representations into a high-order semantic vector of the entity text pair. Its input is a set of candidate entity text pairs The output is a set of high-level semantic representations of the candidate set, denoted as Given Any element The high-order semantic vector of the corresponding entity text pair The specific processing process is as follows:

[0061] ① Sequentially match a candidate entity text to p and All attribute values ​​are connected into a word sequence, and the corresponding word embedding vector sequences u1 and u2 are constructed using the neural network language model. Assuming that u1 contains m elements and u2 contains n elements, then u1[m]∈u1 is The embedding representation vector of the mth word in the corresponding word sequence; u2[n]∈u2 is The embedding representation vector of the nth word in the corresponding word sequence.

[0062] ② Since u1 and u2 can both serve as each other’s context sequences, u1 is regarded as the main input sequence and u2 as the context sequence. A high-order semantic vector of u1’s fused context information is constructed by using a bidirectional recurrent neural network with an attention mechanism. Where d is a fixed hyperparameter. Similarly, consider u2 as the main input sequence and u1 as the context sequence, and repeat the above steps to construct a high-order semantic vector of u2 that integrates the context information

[0063] ③ In order to effectively construct a high-order semantic vector of an entity text pair and accurately model the similarity between x1 and x2, a learnable distance function Dis(·) is used to obtain a high-order semantic vector x of an entity text pair through element-by-element comparison operations. p .

[0064] Among them, step ② calculates the text semantics of the context sequence and the soft alignment encoding of the sequence in turn, and uses Bi-RNN and HighwayNet networks to construct a high-order semantic vector of the entity description text sequence that integrates the context information to model the multi-dimensional semantics of the entity. Considering that the calculation process of x1 and x2 is similar, the calculation process of x1 is explained below.

[0065] (i) Calculate the text semantics h2 of the context sequence u2

[0066] In order to better capture the contextual information of the text sequence u2, the sequence u2 is encoded by Bi-RNN to obtain the semantics h2 of the sequence u2. and They represent the forward and backward hidden states of the nth element in u2 respectively. The hidden state sequence h2 of the entire u2 sequence is the connection of the forward and backward hidden states in Bi-RNN, as shown in formula (1).

[0067]

[0068] (ii) Calculate the soft alignment code b1 of sequence u1

[0069] To calculate the soft alignment code of sequence u1, we need to first calculate the alignment weight information of context sequence u2 to sequence u1, that is, the soft alignment matrix W, and then use weighted average to construct the soft alignment code of sequence u1. Take the soft alignment code b1[m] of the mth element of sequence u1 as an example to illustrate.

[0070] The soft alignment matrix W between u1 and u2 captures the alignment relationship between the elements in u1 and u2 through the attention mechanism, and then obtains the soft alignment code b1[m] of each element u1[m] in u1. m,n ∈W represents the weight value between the mth element in sequence u1 and the nth element in sequence u2, and its mathematical calculation formula is shown in formula (2).

[0071]

[0072] Among them, score m,n Indicates the soft alignment score between the mth element in sequence u1 and the nth element in sequence u2. m,n The calculation process is to first use a two-layer HighWayNet network with ReLU to obtain the d-dimensional representation of u1[m] and u2[n] as shown in Equation (3) and Equation (4), and then take q 1,m and q 2,n The dot product of gets an unnormalized score as shown in formula (5).

[0073] q 1,m =h(u1[m]) (3)

[0074] q 2,n =h(u2[n]) (4)

[0075]

[0076] Among them, h represents the HighwayNet network, q 1,m and q 2,n represents the hidden representation of u1[m] and u2[n].

[0077] Next, the weights obtained from the soft alignment matrix W are used to perform weighted averaging on the codes of each h2[n] to obtain the soft aligned code b1[m]∈b1 of u1[m], as shown in Equation (6).

[0078]

[0079] Among them, the contribution of each h2[i] encoding is determined by its corresponding weight w mi Determine, and these weights satisfy: Through this weighted summation method, b1[m]∈b1 not only incorporates the contextual information of h2, but also integrates the alignment relationship between u1 and u2.

[0080] (iii) Calculate the high-order semantic vector of the sequence u1 that integrates the context information

[0081] To calculate the high-order semantic vector x1 of the sequence u1 that integrates the context information, we first calculate the comparison vector of each sequence element (such as the comparison vector of the mth element is c1[m]), and then use the Bi-RNN and HighWayNet networks to fuse the context information of the sequence u1 and generate the corresponding semantic vector x1.

[0082] First, the sequence u1 is encoded by Bi-RNN to obtain u'1; then HighwayNet with ReLU layer is used to compare u'1 and b1 element by element to generate comparison vector c1[m], which is the comparison representation of u1[m]∈u1. This comparison process helps to capture the similarities and differences between u1 and b1, providing rich information for subsequent aggregation.

[0083] In the fusion stage, the weighted average mechanism is used to optimize the comparison vector c1[m] to obtain the final representation x1 of u1, which is a high-order semantic vector that integrates context information. First, a different Bi-RNN is used to encode u2 again to obtain the encoding h'2 of its last hidden state. Secondly, each c1[m] is concatenated with h'2 to form an extended representation e1[m]. Next, a HighwayNet network containing a ReLU layer takes this extended representation as input and calculates its weights through a softmax layer; these weights reflect the contribution of different elements in c1[m] to the final representation x1. Finally, c1[m] is weighted averaged according to these weights to obtain the final output representation x1, as shown in Equation (7).

[0084]

[0085] (3) Fine-tuning parsing module based on deep metric learning: Considering that deep metric learning (such as SoftTriple) has excellent performance in the field of computer vision, this embodiment migrates the SoftTriple technology originally applicable to the field of computer vision to the field of text data processing. In the entity parsing task, the information of each entity is usually composed of multiple attributes, and different attributes contain information clusters of different dimensions, which represent the multi-dimensional semantics of the attribute values. In order to accurately capture the multi-dimensional semantic information contained in the entity description, this embodiment uses SoftTriple to extend the SoftMax loss function to multiple information clusters of each category, so that different values ​​of each entity attribute correspond to multiple possible centers. These centers can effectively capture the multi-dimensional semantics of the attribute value. The SoftTriple loss function can capture the diversity of different attribute values ​​in each category by introducing multiple centers for each category. This method allows the model to take into account the multi-center characteristics of the attribute when calculating the similarity. By calculating the distribution of different categories based on the similarity measurement of each category, the model's ability to understand the semantics of complex entities is improved, so that the similarity between the embedded representations of the same entity is high, while the similarity between the embedded representations of different entities is low.

[0086] Specifically, in order to build an incremental entity resolution model for dynamic text, the entity resolution problem is modeled as a two-classification problem, so that it is possible to determine whether the entity description text pairs refer to the same entity based on their similarity. In view of the excellent performance of SoftTriple in distinguishing samples of different categories in computer vision tasks that need to capture the relative relationship between data points, this embodiment uses SoftTriple technology as the core of the classifier. In the traditional SoftMax loss function, each category has only one center in the last fully connected layer, resulting in all samples in the same category being forced to be summarized into this center. In order to overcome this limitation, multiple centers are introduced for each category to optimize the traditional SoftMax loss function. This strategy allows each category to no longer be represented by a single center, but to be composed of multiple "soft centers", thereby more comprehensively capturing the local geometric information of each category and more accurately depicting the internal structure of the category.

[0087] In the entity resolution task, since the distribution of matching entity description text pairs may contain multiple information clusters, there are huge differences between the matching entity text pairs. In order to more accurately describe and capture this complex distribution feature, the sample distribution of each category is modeled and regarded as having multiple centers (such as K Since each category has K different centers, the high-order semantic vector x of the entity-text pair p The similarity measure relationship with a certain category is quantified as a high-order semantic vector x pThe highest value of similarity with the center of the category; such as S i,c is the high-order semantic vector of the i-th entity-text pair The similarity measure with category c is calculated as shown in formula (8).

[0088]

[0089] in, represents the high-order semantic vector of the i-th entity-text pair, The weight vector representing the k-th center of category c.

[0090] Since the K different centers of category c follow the probability distribution q, substituting the probability distribution of different centers into equation (8) yields equation (9). The core idea is to maximize the high-order semantic vector of the i-th entity-text pair by adjusting the probability distribution q. Weighted similarity with all centers in category c.

[0091]

[0092] in, is a probability distribution cluster with K centers, q k is the probability of the kth center under the q distribution. To ensure q k is a valid probability. According to the KKT condition, q k There is a closed-form solution, as shown in formula (10).

[0093]

[0094] Among them, λ is an adjustable parameter, and its value determines the trade-off of the uncertainty (entropy) of the distribution q during the optimization process.

[0095] Put q k Substituting into equation (9), we get the high-order semantic vector of the i-th entity-text pair: The relaxed similarity measure S' between category c i,c , as shown in formula (11).

[0096]

[0097] Using the relaxed similarity measure S' i,cThe optimized SoftTriple loss function is formula (12). This loss function not only describes the differences between samples within a class, but also quantifies the distinction between different classes. By minimizing the SoftTriple loss function, the center vectors of samples belonging to the same class in the feature space can be made closer, while the center vectors of samples from different classes are further away, which effectively improves the accuracy of entity matching and makes those semantically similar hard-to-determine entity text pairs more likely to be correctly matched.

[0098]

[0099] The scaling factor γ is used to adjust the scale of the similarity score, and the margin parameter δ is used to define a gap between the scores of the true matching categories and the scores of other non-target categories.

[0100] Specifically, for truly matching categories, by adjusting the value of γ, the model's sensitivity to the difference in similarity between different categories can be affected. A larger γ value will make the score difference more significant, prompting the model to pay more attention to distinguishing categories with close similarity; while a smaller γ value will smooth out this difference, making the model more robust during training.

[0101] On the other hand, as the interval parameter δ, the similarity score is calculated by subtracting this interval value δ. This causes the score of the true matching category to be offset downward relative to the scores of other non-matching categories in subsequent comparisons or loss calculations. This requires the model to not only identify the correct category during classification, but also ensure that the difference between the score of the target category and the scores of all other categories exceeds the preset interval δ. Although this increases the learning complexity of the model, it can ultimately learn a more accurate and robust model to better identify the correct matching category.

[0102] In the above description, the number K of different category centers (or cluster centers) in an entity is usually not fixed, and is generally determined according to the specific attributes of the sample and the distribution of the text data. Determining the appropriate number of centers is a challenging task. If the distribution of each class is not known in advance, it is difficult to set K accurately. This embodiment adopts a soft-constrained optimization strategy, using regularization terms to control the number of class centers of each class accordingly, so that the model shows higher flexibility and robustness during the training process. The specific processing steps are as follows.

[0103] First, we set K large enough and then encourage similar centers to merge with each other. This can maintain the diversity of generated centers while reducing the number of unique centers. jc , using regularization to obtain the distance between the two centers within the class and As shown in formula (13).

[0104]

[0105] Then use the regularizer to get a new loss function As shown in formula (14), N is the total number of samples.

[0106]

[0107] After the training is completed, for the new input sample, its similarity with the center vector of each category is calculated, and then it is classified into the category with the highest similarity to obtain the parsing result of the entity text pair.

[0108] In summary, by migrating the SoftTriple technology, this embodiment constructs an efficient and robust fine-tuning parsing module based on deep metric learning to handle entity parsing tasks. This module not only fully utilizes the advantages of deep metric learning in processing similarity comparison and matching tasks, but also uses the SoftTriple technology to deeply explore the diverse features of entity text pairs, further improving the performance and accuracy of the fine-tuning parsing model.

[0109] The core task of the incremental entity resolution part is to perform incremental entity resolution on dynamic text data and iteratively optimize the parameters of the fine-tuned resolution model by continuously using the highly confident matching and non-matching entity text pairs at each time step. Whenever new incremental text data flows in, it is first parsed using the fine-tuned resolution model optimized at the previous time step to determine the matching between entities. Then, based on the parsing results of the previous time step and its entity text pair information, a data augmentation strategy based on credibility measurement is used to screen out high-quality annotated text pairs to optimize the fine-tuned resolution model for the next time step. This strategy offsets the poor calibration results produced by poor training text pairs by predicting uncertainty, and sets a reasonable threshold based on the similarity measurement between entities to screen out highly matching entity text pairs from the candidate entity set parsed at the previous time step. These screened high-quality annotated data are then used for retraining and iterative optimization of the fine-tuned resolution model. After multiple training and iterative optimization, the fine-tuned resolution model can continuously improve its semantic understanding and resolution capabilities of entity descriptions, and has higher accuracy when processing new data. With the continuous optimization of the fine-tuned resolution model, the model can better adapt to the distribution changes of incremental text and continuously improve its performance in the incremental entity resolution task of dynamic text.

[0110] This part aims to perform entity resolution on the incremental entity description texts that flow in over time in sequence. However, due to the unknowability and diversity of the incoming data, the training model of the previous time step is often unable to effectively resolve the entity resolution task of the next time step. In this embodiment, the probability distribution of the relaxed similarity metric calculated by the fine-tuning parsing module based on deep metric learning is used as the probability of predicting whether the entity text pair matches. It is observed that the matching and unmatched entity text pairs generated in each incremental processing process imply rich entity matching clues, but they are not fully utilized, which causes great waste. In order to give full play to the value of these entity text pairs, this embodiment proposes a data enhancement strategy based on credibility measurement to select high-quality annotated data to achieve data enhancement. This strategy can construct a highly credible training set for continuous optimization of the parameters of the fine-tuning parsing model, so as to improve the parsing efficiency of the model and enhance the model's adaptability and generalization capabilities to unknown data.

[0111] The following is a detailed explanation of the data enhancement strategy based on credibility measurement.

[0112] After the fine-tuned parsing model of the previous time step completed the prediction, it was able to identify some matching or non-matching entity text pairs. If these prediction results are directly used in the training process of the fine-tuned parsing model of the next time step, the gain may be relatively limited. On the other hand, if the fine-tuned parsing model is not well calibrated, these prediction results may contain a large number of wrong labels, which will affect the parsing accuracy of the model in the next stage. Therefore, it is very important to build a high-quality enhanced entity text pair collection. Because these enhanced entity text pair collections can not only improve the parsing effect of the fine-tuned parsing model, but also reduce the interference of noisy entity description texts and improve the overall performance.

[0113] Based on this, a data augmentation strategy based on credibility measure is proposed. This strategy can use credibility measure to offset the impact of poor calibration in the prediction results of each time step. The core idea is to first define a credibility measure and a dynamic credibility measure threshold k using statistical learning techniques such as variance. p , and then calibrate the matching probability value of the entity text pair according to the credibility measurement of the prediction result of the entity text pair. The specific calibration algorithm is described as follows.

[0114] First, a credibility measure is defined using statistical learning techniques, and a dynamic credibility measure threshold k is implemented. p Set up a plan.

[0115] The credibility metric can effectively quantify the credibility of the matching probability value of the entity text pair to calibrate the matching probability value output by the matching model. This metric improves the fine-tuning parsing model based on deep metric learning through the random perturbation mechanism MC-Dropout, so that it outputs the probability values ​​of the matching possibilities of multiple entity text pairs through multiple random forward propagations. Then, the negative of the standard deviation of these probability values ​​is calculated as the credibility metric u(i) of the i-th entity text pair, as shown in formula (15).

[0116]

[0117] Where i represents the i-th entity-text pair, n represents the number of random forward propagation completed, and p' ij represents the probability of the i-th entity text to the j-th random forward propagation output, Represents the random forward propagation output probability p' of the i-th entity i The larger the value of u(i), the higher the credibility of the matching result of the i-th entity text pair.

[0118] Credibility measurement threshold k p The setting of k is crucial. In the incremental entity resolution scenario, due to the static k p The inability to adapt to the text data that continues to increase over time will lead to error transmission. To alleviate this situation, this embodiment implements a dynamic credibility measurement threshold k p Setting scheme. This scheme can dynamically adjust the credibility measurement threshold k according to the statistical characteristics of the set of highly credible annotated entity text pairs generated by the data enhancement strategy based on credibility measurement. p . Credibility measurement threshold k p The initial value of is the median of the credibility measure u(i) in the initial training set. When the enhanced entity text is injected into the data in the next time step, update k p is the median of the credibility measure of the high-confidence entity text pair and the initial credibility measure. Similarly, whenever new enhanced entity text pair data is injected, repeat the above steps to continuously update k p .

[0119] Then, at each time step, the credibility metric u(i) and credibility metric threshold k are used p Build a collection of highly confident annotated entity-text pairs.

[0120] From the fine-tuning parsing process, we can know that the probability p(i) of predicting whether an entity text pair matches can be calculated using the relaxed similarity measure S' output by the fine-tuning parsing model. i,c The following takes the i-th entity text pair as an example to introduce the judgment mechanism of highly reliable annotated entity text pairs.

[0121] (i) According to the credibility measure of the entity text pair, the probability of whether the untrusted entity text pair matches is calibrated, as shown in formula (16). The so-called trusted entity text pair refers to the entity text pair whose credibility measure u(i) is greater than or equal to the credibility measure threshold k p The so-called untrusted entity text pair refers to the entity text pair whose credibility measure u(i) is less than the credibility measure threshold k p In other words, p(i) of the entity text pair is unreliable and needs to be calibrated. The calibration probability p'(i) of whether the entity text pair matches is the relaxed similarity measure S' of multiple rounds of entity text pairs. i,c The weighted average of the average metric and the TF-IDF cosine similarity between entity text pairs is shown in formula (16). is the TF-IDF cosine similarity between samples in the i-th entity text pair.

[0122]

[0123] (ii) Based on the calibrated probability value of the entity text pair, determine whether the entity text pair is a high-confidence matching pair / unmatching pair. The set of highly-confidence labeled entity text pairs consists of highly-confidence matching pairs and highly-confidence unmatching pairs. The dynamic threshold α for entity text pair matching m The average value of multiple rounds of prediction results is used to determine. If the calibration probability p'(i) of the i-th entity text pair is greater than α m , then the entity-text pair is a high-confidence matching pair, otherwise it is a high-confidence mismatching pair, as shown in formula (17).

[0124]

[0125] The high-quality annotated data selected by the data enhancement strategy based on the credibility metric is injected into the fine-tuned parsing model for retraining and iterative optimization. The fine-tuned parsing model can gradually improve its processing efficiency and have higher accuracy when processing new data. With the continuous optimization and improvement of the performance of the fine-tuned parsing model, the model can better adapt to various changes and further improve its entity parsing ability in a dynamic data environment.

[0126] Corresponding to the above method, this embodiment also provides an incremental entity parsing device for dynamic text, the device comprising:

[0127] The coarse-tuning filtering module based on the neural network language model is used to filter out obviously mismatched entity description text pairs and generate a set of candidate entity text pairs.

[0128] The deep semantics-based feature fusion module is used to generate high-order semantic vectors of entity text pairs that incorporate contextual information.

[0129] A fine-tuned parsing module based on deep metric learning is used to enhance the ability to capture semantic relationships in text and obtain parsing results for entity-text pairs.

[0130] Based on the data augmentation strategy of credibility measurement, incremental entity parsing is performed on dynamic text data, and the parameters of the parsing model are iteratively optimized and fine-tuned by continuously utilizing the high-confidence matching and non-matching entity text pairs at each time step.

[0131] This embodiment also provides a readable storage medium on which a computer program is stored. When the computer program is executed by a processor, the steps of the above method are implemented.

[0132] The effectiveness and advancement of the method of the present invention are verified by experiments below.

[0133] 1. Evaluation indicators

[0134] This experiment uses the F1 score, which is widely used in the field of entity resolution, to evaluate the prediction results. F1 is the harmonic mean of precision and recall, and the specific calculation formula is shown in formula (20). Precision refers to the proportion of all instances predicted by the model as positive that are actually positive, and the specific calculation formula is shown in formula (18). Recall refers to the proportion of all instances that are actually positive that are correctly predicted by the model as positive, and the specific calculation formula is shown in formula (19). Among them, TP (True Positive) represents true positive examples, that is, the number of entity text pairs that the model predicts to be matched and are actually matched; FP (False Positive) represents false positive examples, that is, the number of entity text pairs that the model predicts to be matched but are actually mismatched; FN (False Negative) represents false negative examples, that is, the number of entity text pairs that the model predicts to be mismatched but are actually matched.

[0135]

[0136] This experiment calculates the overall F1 score based on the prediction results of all time steps to evaluate the performance of the model under dynamic text. With the continuous injection of highly reliable entity text into data and the continuous optimization of the model, IERDT can gradually adapt to new text data distribution and text feature patterns, thereby improving the model's semantic understanding and entity resolution capabilities for unknown or newly emerging entity description texts.

[0137] (II) Experimental setup

[0138] IERDT is an incremental entity resolution method for dynamic texts, which aims to solve the incremental entity resolution problem for dynamic texts. Due to dynamic text data, IERDT only needs a training set in the first time step to train the initial entity resolution model. Considering that in dynamic text scenarios such as scientific literature, the entity text pair set changes dynamically in each time step, making it difficult to estimate the number of samples used for training in the first time step. To estimate the number of samples used for training in the first time step, assume that at any time step (such as T k ), the number of matching pairs (such as ) and the number of candidate entity text pairs (such as ) is the same as the overall statistical characteristics. The number of entity-text pairs in the training set required for the first time step The number of matching entity text pairs The calculation steps are as follows. (1) Use the random sampling algorithm to estimate the expected ratio of the number of matching pairs to entity text pairs in the first time step, as shown in formula (21). Where M1 and C1 represent the set of matching entity text pairs and the set of candidate entity text pairs in the first time step, respectively. (2) According to the ratio λ of the training set and the test set in the field of neural networks, it can be calculated The value of is shown in formula (22). λ is a fixed parameter used to adjust the proportion of the training set in the candidate entity text pair set. Since the candidate entity pair set at the first time step is essentially equivalent to the test set. If the ratio of the training set to the test set is 6:4, the value of λ is 6 / 4. (3) According to the expected ratio and formula (23), the number of matching entity text pairs in the training set required at the first time step can be estimated.

[0139]

[0140] (III) Experimental data

[0141] This experiment uses public benchmark text datasets in the field of entity resolution, such as Amazon-Google (AG), DBLP-Scholar (DS), DBLP-ACM (DA), and Fodors-Zagats (FZ) to evaluate the parsing effect of IERDT. These datasets truly reflect the characteristics of text data, as shown in Table 1. Each dataset provides two entity descriptions from different data sources and a set of manually annotated entity matching pairs. Among them, each entity description has multiple attributes. For example, the data sources of the DBLP-Scholar (DS) dataset are DBLP and Scholar, and each entity description has four attributes: title, author, conference location, and year. The number of truly matched entity text pairs is 5347.

[0142] Table 1 Benchmark text datasets

[0143]

[0144] (IV) Comparative experiment

[0145] In order to objectively evaluate the entity resolution performance of the IERDT proposed in the present invention in a dynamic data scenario, the present invention improves three baseline entity resolution models, and after multiple rounds of training, selects the model with the best effect for entity resolution comparison experiments under dynamic text. The detailed descriptions of these baseline models are as follows.

[0146] (1)DM_d DeepMatcher is an entity resolution model based on deep learning. This method uses a pre-trained language model to build attribute embeddings, learns high-dimensional vector representations of entity attribute similarities through attribute summarization and attribute comparison operations, and predicts whether two entities match through a multi-layer perceptual network. The improved DeepMatcher, which can process dynamic text, is denoted as DM_d.

[0147] (2) Ditto_d Ditto models the entity resolution problem as a sequence pair classification problem and is an entity matching model based on a pre-trained Transformer language model. The improved Ditto, which can process dynamic text, is denoted as Ditto_d.

[0148] (3) Ditto+_d is the most effective entity resolution method at present. Based on Ditto, this method further improves Ditto's matching ability by injecting domain knowledge, summarizing long strings, and enhancing training data with difficult examples. The improved Ditto+ can handle dynamic text and is denoted as Ditto+_d.

[0149] The experimental results of the comparison between IERDT and the baseline methods are shown in Table 2. The initial training set and the incremental data flowing in over time are the same for the same dataset. The best results are bolded and marked with the symbol ↑. Δ1F1 represents the difference in F1 between the parsing results of ER-DML and DM_d. Similarly, Δ2F1 represents the difference in F1 between IER-DML and Ditto+_d, and Δ3F1 represents the difference in F1 between IER-DML and Ditto_d.

[0150] Table 2 Comparative experimental results

[0151]

[0152] The experimental results show that (1) Compared with DM_d, the F1 value of IERDT is better than that of DM_d on all datasets. On the four datasets of AG, DS, DA and FZ, the F1 value of IERDT is improved by 4.73%, 1.22%, 4.64% and 2.37%, respectively. On average, the F1 value of IERDT is improved by 3.24%. (2) Compared with Ditto_d, the F1 value of IERDT is better than that of Ditto_d on all datasets. On the four datasets of AG, DS, DA and FZ, the F1 value of IERDT is improved by 1.65%, 0.71%, 2.17% and 4.34%, respectively. On average, the F1 value of IERDT is improved by 2.22%. (3) Compared with Ditto+_d, the F1 value of IERDT is better than that of Ditto+_d on most datasets. On average, the F1 value of IERDT improves by 1.03%.

[0153] The above experimental results show that IERDT can cope with the distribution changes of data sets with fewer annotated training sets under dynamic text by effectively utilizing highly reliable entity-text pairs, the multi-center mechanism of SoftTriple technology, and the iterative optimization strategy.

[0154] Finally, it should be noted that the above-described embodiments are only specific implementations of the present invention, which are used to illustrate the technical solutions of the present invention, rather than to limit them. The protection scope of the present invention is not limited thereto. Although the present invention is described in detail with reference to the above-described embodiments, ordinary technicians in the field should understand that any technician familiar with the technical field can still modify the technical solutions recorded in the above-described embodiments within the technical scope disclosed by the present invention, or can easily think of changes, or make equivalent replacements for some of the technical features therein; and these modifications, changes or replacements do not make the essence of the corresponding technical solutions deviate from the spirit and scope of the technical solutions of the embodiments of the present invention, and should be included in the protection scope of the present invention. Therefore, the protection scope of the present invention shall be subject to the protection scope of the claims.

Claims

1. An incremental entity resolution method for dynamic text, characterized in that: It includes two parts: fine-tuning parsing and incremental entity parsing; The fine-tuning parsing part includes a coarse-tuning filtering module based on a neural network language model, a feature fusion module based on deep semantics, and a fine-tuning parsing module based on deep metric learning; the coarse-tuning filtering module based on a neural network language model filters out obviously mismatched entity description text pairs and generates a set of candidate entity text pairs; the feature fusion module based on deep semantics generates high-order semantic vectors of entity text pairs that integrate contextual information; the fine-tuning parsing module based on deep metric learning enhances the ability to capture semantic relationships in texts and obtains parsing results for entity text pairs; The incremental entity resolution part performs incremental entity resolution on dynamic text data and iteratively optimizes and fine-tunes the parameters of the resolution model by continuously utilizing the high-confidence matching and non-matching entity text pairs at each time step.

2. The incremental entity parsing method for dynamic text according to claim 1 is characterized in that: The processing process of the coarse adjustment filtering module based on the neural network language model is as follows: Concatenate all attribute values ​​of each entity in two heterogeneous text sets into a string to construct the attribute signature of each entity; A neural network language model is used to generate a high-dimensional vector representation of each word in the attribute signature to obtain a sequence of word embedding vectors; Use an autoencoder to aggregate these word embedding vector sequences into two vector sets; A set of candidate entity-text pairs is generated using a cosine pairing-based filtering strategy.

3. The incremental entity resolution method for dynamic text according to claim 2 is characterized in that: The candidate entity text pair set generated by the cosine pairing-based filtering strategy includes: For any entity description text in a text set, calculate the cosine similarity between its embedding vector and all entity embedding vectors in another text set, select the top k most similar entity description texts as the candidate set according to the similarity score, connect an entity with its candidate entity, and form a set of candidate entity text pairs.

4. The incremental entity resolution method for dynamic text according to claim 1, characterized in that: The processing process of the deep semantic-based feature fusion module is as follows: Use the neural network language model to map a candidate entity to p and Construct the corresponding word embedding vector sequences u1 and u2; Since u1 and u2 can serve as each other's context sequences, u1 is regarded as the main input sequence and u2 as the context sequence. A high-order semantic vector of u1's fused context information is constructed by using a bidirectional recurrent neural network with an attention mechanism. Where d is a hyperparameter and m is the number of elements contained in u1. Similarly, consider u2 as the main input sequence and u1 as the context sequence, and repeat the above steps to construct a high-order semantic vector of u2 that integrates the context information. Where n is the number of elements contained in u2; A learnable distance function Dis(·) is used for x1 and x2, and a high-order semantic vector x of an entity text pair is obtained by element-by-element comparison. p .

5. The incremental entity resolution method for dynamic text according to claim 4 is characterized in that: The calculation process of the high-order semantic vector x1 is as follows: First, the sequence u2 is encoded by Bi-RNN to obtain the semantics h2 of the sequence u2; Then calculate the soft alignment code b1 of sequence u1: ① Use the soft alignment score score between the mth element in sequence u1 and the nth element in sequence u2 m,n Calculate the alignment weight value of sequence u2 to sequence u1 through the softmax layer, that is, the soft alignment matrix W; ② Use the weights obtained from the soft alignment matrix W to perform weighted average on the encoding of each h2[n] to obtain the soft alignment code b1[m]∈b1 of each element u1[m] in sequence u1; Finally, the high-order semantic vector x1 of the fused context information of sequence u1 is calculated: ① Calculate the comparison vector of each sequence element; ② Use Bi-RNN and HighWayNet networks to fuse the context information of sequence u1 and generate the corresponding semantic vector x1; in Soft alignment score m,n The calculation process is: first use a two-layer HighWayNet network with ReLU to obtain the d-dimensional representation q of u1[m] and u2[n] 1,m ,q 2,n ; Then by taking q 1,m and q 2,n The dot product of is an unnormalized score.

6. The incremental entity resolution method for dynamic text according to claim 5 is characterized in that: Calculating the comparison vector for each sequence element involves: first encoding the sequence u1 through Bi-RNN to obtain u'1; then using HighwayNet with ReLU layer to compare u'1 and b1 element by element to generate the comparison vector c1[m], which is the comparison representation of u1[m]∈u1; The process of generating the corresponding semantic vector x1 using Bi-RNN and HighWayNet networks is as follows: first, use Bi-RNN to re-encode the sequence u2 to obtain the encoding h'2 of the last hidden state of the sequence u2; secondly, concatenate each c1[m] with h'2 to form an extended representation e1[m]; then, a HighwayNet network containing a ReLU layer takes e1[m] as input and calculates its weight through a softmax layer; finally, c1[m] is weighted averaged according to these weights to obtain the final output representation x1.

7. The incremental entity resolution method for dynamic text according to claim 4 is characterized in that: The process of fine-tuning the parsing module based on deep metric learning is as follows: Since each category has K different centers, the high-order semantic vector x of the entity-text pair p The similarity measure relationship with a certain category is quantified as a high-order semantic vector x p The highest value of similarity with the center to which this category belongs; Since the K different centers of category c follow the probability distribution q, the high-order semantic vector of the i-th entity-text pair is maximized by adjusting the probability distribution q. The weighted similarity with all centers in category c finally obtains the high-order semantic vector of the i-th entity-text pair The relaxed similarity measure S' between category c i,c ; Using the relaxed similarity measure S' i,c The SoftTriple loss function is optimized, which not only describes the differences between samples within a class, but also quantifies the distinction between different classes. A regular term that constrains the number of class centers is added to the SoftTriple loss function.

8. The incremental entity resolution method for dynamic text according to claim 1, characterized in that: The incremental entity resolution part of the process is as follows: First, a credibility measure u(i) of the entity text on the prediction result is defined using statistical learning technology; Then set the dynamically adjustable credibility metric threshold k p : Credibility measurement threshold k p The initial value of is the median of the credibility measure u(i) in the initial training set; when the enhanced entity text is injected into the data at the next time step, update k p is the median of the credibility measure of the high-confidence entity-text pair and the initial credibility measure; Then, at each time step, the credibility measure u(i) of the prediction result and the credibility measure threshold k of the enhanced entity text are used to calculate the credibility measure u(i) of the prediction result. p To calibrate the matching probability value of the enhanced entity text pair, and then compare the calibrated matching probability value with the dynamic threshold to build a highly reliable set of annotated entity text pairs.

9. An incremental entity parsing device for dynamic text, characterized in that: The device is used to implement the incremental entity resolution method for dynamic text according to any one of claims 1 to 8, comprising: A coarse-tuning filtering module based on a neural network language model is used to filter out obviously mismatched entity description text pairs and generate a set of candidate entity text pairs; A feature fusion module based on deep semantics is used to generate high-order semantic vectors of entity text pairs that incorporate contextual information; A fine-tuned parsing module based on deep metric learning is used to enhance the ability to capture semantic relationships in text and obtain parsing results for entity-text pairs; Based on the data augmentation strategy of credibility measurement, incremental entity parsing is performed on dynamic text data, and the parameters of the parsing model are iteratively optimized and fine-tuned by continuously utilizing the high-confidence matching and non-matching entity text pairs at each time step.

10. A readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by a processor, the steps of the method according to any one of claims 1 to 8 are implemented.

Images