A context-aware column semantic recognition method and system based on GCN and RoBERTa

Abstract

The present invention relates to a context-aware column semantic recognition method and system based on GCN and RoBERTa, comprising the following steps: data preprocessing: setting an incremental synchronous data acquisition task, performing data collection and cleaning, and loading the data into a MySQL environment; column semantic recognition: constructing a vocabulary relationship graph based on the column relationship attributes and attribute relationships of a dataset, and using the graph as the input of a two-layer GCN graph convolutional network to obtain GCN global semantic feature embedding; linearizing and encoding the RoBERTa pre-trained model, inputting preliminary column vectors into a three-layer Tansformer using its multi-head column attention mechanism to obtain local semantic feature embedding, fusing the parallel output embedding vectors with weights through the attention mechanism to obtain global-local interactive contextual semantic information, and using Adaline for classification prediction; the present invention constructs a contextual column semantic recognition model, and performs semantic recognition of metadata based on relational column projection.

Description

Technical Field

[0001] The present invention relates to the field of natural language processing technology, and in particular to a context-aware column semantic recognition method and system based on GCN and RoBERTa. Background Art

[0002] In people's daily life and management process, information management systems and database systems in various industries and fields generate a large amount of complex data.

[0003] Currently, data in various business fields is diversified in terms of type, structure, and source. Structured relational data occupies the most important position in data resources and provides the foundation and basis for data resource management. When focusing on the column projection metadata of relational databases, in tabular data, each column usually represents a specific type of information. For example, in financial statements, one column may represent "sales" and another column may represent "net profit." In medical records, one column may contain "patient name" and another column may contain "diagnosis results." The meaning of these columns is crucial to the interpretation and application of the data, but due to technical protection by business system software manufacturers, the column projection metadata in the database table structure currently does not contain relevant labeling mechanisms or annotation information, resulting in a lack of real semantic information even if the column projection metadata is obtained, and the problem of synonymous column projection metadata may occur.

[0004] Furthermore, research on semantic recognition based on relational data columns still faces numerous challenges: First, text semantic recognition requires manual feature engineering, which is costly. Second, traditional machine learning relies solely on the attribute values ​​of individual database columns for semantic differentiation, lacking the ability to capture the contextual semantic information of relational data tables and accurately distinguishing their column semantics. To obtain contextual semantic information, attention mechanisms can be used to obtain the weight of each word, but these mechanisms focus only on local continuous word sequences, providing only local contextual sequence semantic feature information for relational data tables, limiting their ability to capture the global semantic information of relational tables. Finally, relational table data, unlike general text data, possesses the characteristic of structured data being independent of column order. This means that arbitrarily swapping the column positions of relational data columns does not affect the global semantic representation. However, traditional models are sensitive to the column order of relational data, significantly interfering with the accuracy of model predictions. Summary of the Invention

[0005] In response to the problems existing in the above technologies, the present invention provides a context-aware column semantic recognition method based on GCN and RoBERTa.

[0006] Based on the characteristics of contextual information and the order independence of relational columns, the present invention proposes a co-occurrence attribute interaction column semantic recognition model based on the parallel combination of vocabulary graph convolutional network (GCN) and RoBERTa, in which GCN will be able to effectively capture the vocabulary graph of co-occurrence information of documents, words and global dependencies, and the RoBERTa model efficiently focuses on local continuous word sequences to provide local contextual information. The method first collects multi-business system relational table data from the Hudi data lake as initialization data; secondly, inputs column relational dependencies and attribute relational dependencies, and captures global structural semantic information features and local structural semantic information features respectively through a two-layer GCN network and RoBERTa's multi-head self-attention mechanism. The global context feature output vector of the GCN network and the local context feature output vector of RoBERTa are interactively fused through the attention mechanism, allowing the predicted column projection metadata to learn richer context information. Finally, the classification is predicted by embedding the AdaLine adaptive strategy classification layer. Again, based on the co-occurrence feature semantic dependency of semantic tags of the same relational data topic, the Transformer-Encoder is used to map the above-mentioned incompletely correct label sequence to the correct label. Finally, the cross-entropy function and the incremental data extracted from the data lake within a fixed time period are used to update the optimization model.

[0007] Explanation of terms:

[0008] 1. Metadata: Data that describes data, used to provide descriptive information about data and information resources. In other words, metadata is information about the organization, data domain, and relationships of data, helping people understand, manage, organize, and use data.

[0009] 2. GCN: GCN (Graph Convolutional Network) is a deep learning model that can directly operate on graphs and utilizes structural information. It gradually updates node representations through multiple graph convolutional layers, allowing nodes to transfer and aggregate information, thereby capturing complex relationships in the graph.

[0010] 3. RoBERTa: RoBERTa (A Robustly Optimized BERT Pretraining Approach) is a pre-trained language model in natural language processing (NLP), an improved version of the BERT model with better performance.

[0011] 4. Spark Jobs: Apache Spark is an open-source, fast, general-purpose, and scalable distributed computing framework designed for high-performance data processing and analysis of large datasets. Spark jobs typically refer to data processing, analysis, and computational tasks run on the Apache Spark framework. They typically consist of a series of data transformations and computational operations. These jobs can be executed in parallel on a distributed cluster to provide high-performance data processing capabilities.

[0012] 5. Spark Session: A Spark Session is a high-level programming interface for communicating with a Spark cluster. As the core entry point for Spark, it provides a unified way to access various Spark functions and process distributed data. Built on the underlying Spark core, a Spark Session encapsulates various functions, including SQL queries, DataFrame operations, stream processing, machine learning, and graph processing.

[0013] 6. Hudi: Hudi (Hadoop Upserts Delete and Incremental) is a data lake framework that supports inserts, updates, deletes, and incremental processing. Apache Hudi brings core warehouse and database functionality directly into the data lake. Hudi provides tables, transactions, efficient upserts / deletes, advanced indexing, streaming ingestion services, data clustering / compression optimizations, and concurrency, all while maintaining open file formats for data.

[0014] 7. MySQL: MySQL is an open-source relational database management system (RDBMS) developed by MySQL AB of Sweden for storing, retrieving, and managing data. Relational databases store data in tables based on the relational model. MySQL uses the SQL language, the most commonly used standardized language for accessing databases.

[0015] 8. HDFS: HDFS (Hadoop Distributed File System) is a distributed file system used to store and manage large-scale data. An HDFS cluster usually consists of a name node (NameNode) and multiple data nodes (DataNode), which work together to store and manage data.

[0016] 9. Spark DataFrame: Spark DataFrame is a core abstraction in Spark. It is a distributed dataset based on RDD. DataFrame can be viewed as a table or two-dimensional data structure, similar to a traditional database table or Pandas DataFrame. It provides highly optimized distributed data processing capabilities and is suitable for operating on large datasets.

[0017] 10. Tokenization: Tokenization is the process of breaking raw text data into smaller units, typically words, punctuation marks, subwords, or characters. Common tokenization tools include built-in functions in various NLP toolkits, such as NLTK (Natural Language Toolkit), spaCy, and Tokenizer.

[0018] The technical solution of the present invention is:

[0019] A context-aware column semantic recognition method based on GCN and RoBERTa, including:

[0020] Data preprocessing: Write a Spark job to connect Hudi and MySQL data links to set up incremental synchronization data acquisition tasks, and collect and clean data according to fixed dimension partitions. The collected data is loaded into the MySQL environment in the form of overwriting existing data;

[0021] Column semantic recognition: A column semantic recognition model constructed based on GCN and RoBERTa is used as a prediction model. A vocabulary relationship graph is constructed using the column relationship attributes and attribute relationships of the dataset. This graph is used as the input to a two-layer GCN graph convolutional network to obtain the GCN global semantic feature embedding. Simultaneously, the preliminary column vectors are linearized and encoded using the RoBERTa pre-trained model. The three-layer Tansformer uses its multi-head column attention mechanism to obtain local semantic feature embeddings. The parallel output embedding vectors of GCN and RoBERTa are fused with weights through the attention mechanism to obtain contextual semantic information of global-local interactions. Adaline is then used for classification prediction.

[0022] Label error correction and update optimization: The self-attention mechanism is used to correct co-occurrence errors between labels, and the cross-entropy loss function is used to optimize model parameters and extract incremental data to cyclically update the optimization model.

[0023] Furthermore, in this method, a Spark job is written to connect Hudi and MySQL data links to set up incremental synchronous data acquisition tasks, and data is collected and cleaned according to fixed dimension partitions. The collected data is loaded into the MySQL environment in the form of overwriting existing data; this includes:

[0024] Set up incremental data synchronization by writing a Spark job to connect Hudi to MySQL. This includes importing required libraries into the Spark job, creating a Spark session, and writing code to retrieve incremental data from Hudi's underlying storage, HDFS, and convert it to MySQL format. This data is then written into the MySQL database.

[0025] Data is collected and cleaned according to fixed dimension partitions, and the collected data is loaded into the MySQL environment in the form of overwriting existing data; data cleaning includes missing value processing, outlier processing and text processing operations on the collected data in sequence.

[0026] Furthermore, in this method, a column semantic recognition model constructed based on GCN and RoBERTa is used as a prediction model; the column relationship attributes and attribute relationships of the dataset are used to construct a vocabulary relationship graph, which is used as the input of a two-layer GCN graph convolutional network to obtain the GCN global semantic feature embedding; at the same time, the preliminary column vector is input into the three-layer Tansformer using its multi-head column attention mechanism to obtain the local semantic feature embedding through the linear encoding of the RoBERTa pre-trained model. The embedding vectors of the parallel output of GCN and RoBERTa are fused with weights through the attention mechanism to obtain the contextual semantic information of global-local interaction, and classification prediction is performed using Adaline; this includes:

[0027] Capture the GCN global semantic feature embedding vector; the GCN global semantic feature embedding vector refers to the feature vector containing global contextual semantic information output after convolution of the double-layer GCN graph convolutional network;

[0028] Based on all the data written to the MySQL database as a relational dataset, the column relationship attributes and attribute relationships in the relational dataset are used to construct a vocabulary relationship graph as the input of the two-layer GCN graph convolutional network;

[0029] Among them, the specific data contained in the cells where rows and columns intersect in the relational dataset is used as the word node of the two-layer GCN graph convolutional network, and all the data in each column of the relational dataset is used as the document node of the two-layer GCN graph convolutional network;

[0030] The constructed vocabulary relationship graph and dependency relationship graph are concat-concatenated to construct a large heterogeneous vocabulary relationship graph, and a two-layer MLP is used for series operation to output the GCN global preliminary vector. The GCN global preliminary vector is input into a two-layer GCN graph convolutional network for convolution operation, and the node embedding vector is derived according to the node's neighborhood attributes.

[0031] Furthermore, a vocabulary relationship graph is constructed, including:

[0032] The vocabulary graph is constructed using the WordNet semantic dictionary and NPMI (Normalized Pointwise Mutual Information) normalized point-wise mutual information, including:

[0033] First, the weight between two word nodes is calculated by NPMI, and the similarity of word nodes is calculated by WordNet clustering operation containing only verbs, nouns, adjectives, and adverbs. If the NPMI of two word nodes is greater than the threshold, a semantically related edge is created between the two word nodes; otherwise, the next step is performed. The calculation formula of NPMI of word node i and word node j is shown in formula (I):

[0034]

[0035] In formula (I), i and j are word nodes, #w is the total number of sliding windows, #w(i) is the number of all sliding windows containing word node i, #w(i,j) is the number of all sliding windows containing word node i and word node j;

[0036] Secondly, when the NPMI of two word nodes is not greater than the set threshold, the WUP (Wu-Palmer Similarity) method in WordNet is used to measure semantic similarity based on the path structure. The semantic similarity of the two word nodes is measured by calculating the distance between the lowest common subsumer (LCS) of the two word nodes and their respective LCSs. Then, a normalization operation is performed to calculate the similarity score. If the NPMI of the two words is not greater than the set threshold but the WUP is greater than the set threshold, a semantically related edge is still created between the two word nodes. The vocabulary graph is obtained. The calculation formula of the WUP of word node i and word node j is shown in formula (II):

[0037]

[0038] In formula (II), LCS(i,j) represents the lowest common hypernym of word nodes i and j, depth(LCS(i,j) represents the depth of the lowest common hypernym of word nodes i and j, that is, the length of the path from the root node to LCS, depth(i) represents the depth of word node i in the WordNet hierarchy, depth(j) represents the depth of word node j in the WordNet hierarchy;

[0039] Use the TF-IDF (Term Frequency-Inverse Document Frequency) algorithm to create a vocabulary relationship graph, including:

[0040] If the TF-IDF value is higher than 50% of the set threshold, a semantic dependency edge is created between the word and document nodes. If the TF-IDF value is lower than 50% of the set threshold, no semantic dependency edge is created. A weighted calculation is performed on each word-document node to obtain a dependency graph. The formula for calculating the TF-IDF value of document node i and document node j is shown in formula (III):

[0041]

[0042] In formula (III), n i,j represents the frequency of a specific word appearing in a given document, ∑ k n k,j represents the total number of words in the document, |D| represents the number of all documents, |j:t i ∈d j | indicates that it contains a specific word t i The number of documents;

[0043] The vocabulary graph and dependency graph are concatenated and connected using two layers of MLP (Multi-layer Perceptron) to obtain a vocabulary relationship graph, including:

[0044] The similarity vectors of the vocabulary graph and the relationship dependency graph are obtained for concat splicing, and a two-layer MLP is used for series operation to obtain a large heterogeneous vocabulary relationship graph containing the interactive semantic information of the vocabulary graph of word nodes and the relationship dependency graph of document nodes. The vocabulary relationship graph is represented as G = (V, E), where V is the set of nodes and E is the set of edges.

[0045] Furthermore, the vector is input into the two-layer GCN graph convolutional network for convolution operation, and the node embedding vector is derived according to the neighborhood attributes of the node, including:

[0046] First, a neighborhood computation graph is constructed for each node, and the node vector representation of the 0th layer of the neighborhood computation graph is initialized as the node attribute;

[0047] Secondly, according to the layered propagation rule of aggregating node information of the current node layer and transmitting features to the next layer, message passing is performed from layer 0 to layer 2 to obtain information of adjacent nodes; for a single convolutional layer of the two-layer GCN graph convolutional network, the nodes in the k-th layer are element-wise summed and then divided by the number of connections, that is, the element-wise average operation is performed. The obtained vector is input into the two-layer GCN graph convolutional network, and two layers of convolution operations are performed. The embedding of the K+1-th layer v node is obtained through the activation function, and finally the GCN global semantic feature embedding vector of the node is obtained;

[0048] The single-layer convolution formula followed by the double-layer GCN graph convolution network is shown in formula (IV) and formula (V):

[0049]

[0050]

[0051] In formula (IV) and (V), Represents the vocabulary relationship graph of the dataset, W represents the hidden state of a weight of a single document, and the dimension is |V|*h; m represents the batch size, n represents the vocabulary size, h represents the hidden layer size, and s represents the sentence embedding size.

[0052] Furthermore, the RoBERTa pre-trained model is used for linear encoding, and the preliminary column vector is input into the three-layer Tansformer using its multi-head column attention mechanism to obtain local semantic feature embedding, including:

[0053] First, the column relationship attributes and attribute relationships of the dataset are tokenized, linearized and encoded, and input into the RoBERTa pre-trained model;

[0054] Secondly, by inputting it into Tansformer’s three-layer multi-head column attention mechanism, the key content of the relational data column is calculated using the Q, K, and V matrices to obtain information of different dimensions and types;

[0055] Finally, the outputs of multiple attention heads are concatenated into a deeper context-containing local embedding representation.

[0056] Furthermore, the linear encoding includes:

[0057] The relational columns of the dataset are concatenated row by row to form a text segment. This text is tokenized and used as the input representation of the RoBERTa pre-trained model. After embedding encoding by the RoBERTa pre-trained model, a preliminary column vector is output. A fixed maximum number of rows is set to 512. Each relational table is split into multiple tables according to the same relational theme. The column relational dependencies of each column in the relational table are then linearized by row concatenation. If the length of the linearized input column relational dependency exceeds the set threshold, it is truncated and split. If the length is less than the set threshold, it is padded with zeros to the set threshold.

[0058] Furthermore, we obtain the contextual local embedding representation, including:

[0059] First, the preliminary column vector obtained in the previous step is input into Tansformer's three-layer multi-head column attention mechanism, which uses multiple sets of Q, K, and V matrices to project them into different representation subspaces. Each matrix in each subspace uses Q, K, and V matrices to focus on learning and calculating the relationship between the current word and all other words in the sentence, and continuously adjusts the weight of each word to enhance the vector representation of the local features of the current word. Finally, the output of the three-layer multi-head column attention mechanism is spliced ​​into a deeper level of local embedding representation containing context.

[0060] The formula of Tansformer's single-head self-attention mechanism is shown in (VI):

[0061]

[0062] In formula (VI), Q represents the query matrix, K represents the keyword matrix, V represents the original feature, QK T is the dot product operation, is the dimension size of K;

[0063] Secondly, a three-layer multi-head column attention mechanism is used in the multi-head attention mechanism, with the number of heads set to 12, the hidden layer dimension to 128, and the batch_size to 64. The input word vector is projected into different representation subspaces through multiple sets of QKV matrices, allowing the RoBERTa pre-trained model to fully pay attention to information of different dimensions and types. The 128-dimensional data of the original RoBERTa pre-trained model is linearly projected eight times to obtain eight 128-dimensional outputs. Finally, the outputs of the three-layer multi-head column attention mechanism are spliced ​​into a deeper level of local embedding representation containing context; the formula of the multi-head attention mechanism is shown in (VII):

[0064] Multi(Q,K,V)=Concat(head1,head2,...,head n )W

[0065] where head i =Attention(QW i Q ,KW i K ,VW i V )(VII)

[0066] In formula (VII), head i is the head of the attention mechanism, and n is the number of heads of the attention mechanism.

[0067] Furthermore, information fusion prediction classification includes:

[0068] First, the GCN global semantic feature embedding and the RoBERTa local semantic feature embedding are fused with weights through the attention mechanism to obtain the global-local interactive contextual semantic feature vector;

[0069] Secondly, during the training process of the RoBERTa pre-training model, the output vector is passed through the MLP fully connected layer and the Softmax function normalization operation, and finally the semantic category probability corresponding to each sample is output for prediction and classification; the Adaline algorithm is used to integrate the output semantic category probabilities, including: using a multi-way MLP method to form a vector of the results obtained after different layers of fully connected layers, which is the input of the Adaline algorithm. The Adaline algorithm scores the outputs of different MLPs according to the output semantic category probabilities; the closer the output semantic category probability is to the output value of the label, the higher the score will be; next, according to the distribution of this score, sampling is performed on a normal distribution, and each score is accumulated with different weights according to the sampled value. The weighted score of the current sample is obtained according to the accumulated value, and the probability of the sample's final category is obtained.

[0070] Furthermore, in this method, the co-occurrence error correction between tags is achieved through the Self-Attention mechanism, and the model parameters are optimized through the cross-entropy loss function. In addition, incremental data is extracted to cyclically update the optimization model, including:

[0071] First, the Self-Attention mechanism of the Transformer Encoder is used to realize the co-occurrence between labels, so that each input label obtains a corresponding output vector, which is further classified and mapped to the actual category label.

[0072] Secondly, the loss function uses joint training to update the model parameters;

[0073] Finally, by setting a fixed time period, the incremental data extracted from the Hudi data lake is used to update the optimization model.

[0074] Furthermore, the co-occurrence error correction between tags is implemented through the Self-Attention mechanism, including:

[0075] Build a co-occurrence label construction error correction model, map the incompletely correct label sequence y(1) predicted by the above prediction model to a more correct label sequence y(2); the error correction model selects the Encoder module of the parallel and sequence-independent Transformer model, and the input of the error correction model is the label predicted by the prediction model. Each label is vectorized and the co-occurrence between labels is realized by using the Self-Attention mechanism of the Encoder part of the Transformer model. Each input label gets a corresponding output vector, which is further classified and mapped to the real category label, y = {y0, y1, ..., y n-1}, where each output position maximizes the probability of the input label sequence.

[0076] Furthermore, the optimization model is updated, including:

[0077] First, the ternary entropy loss function is used for joint training to update the prediction model parameters, and the cross entropy loss function is used to optimize and update the error correction model;

[0078] Secondly, by setting a fixed time period, incremental data extracted from the Hudi data lake is used to update and optimize the prediction model;

[0079] Furthermore, the ternary entropy loss function includes:

[0080] The Adam optimizer is used to optimize the objective function, and backpropagation is used to update the various parameters of the prediction model in each iteration until the prediction model meets the fitting requirements. The ternary entropy loss function is used to fine-tune the prediction model parameters through joint training. The distance between the actual output and the expected output is obtained by calculating the cross entropy between each pair and performing average pooling operations.

[0081] For each sample, the prediction model predicts the probability distribution as The actual label truth distribution is expressed as y = {y0,y1,...,y n-1}, for each pair of categories i and j, the cross entropy loss formula is shown in (Ⅸ):

[0082]

[0083] generate Cross entropy loss values ​​are average pooled to obtain the final ternary entropy loss as shown in (X):

[0084]

[0085] A computer device includes a memory and a processor, wherein the memory stores a computer program, and when the processor executes the computer program, it implements the steps of a context-aware column semantic recognition method based on GCN and RoBERTa.

[0086] A computer-readable storage medium stores a computer program, which, when executed by a processor, implements the steps of a context-aware column semantic recognition method based on GCN and RoBERTa.

[0087] The present invention provides a context-aware column semantic recognition system based on GCN and RoBERTa, which is used to implement the above-mentioned context-aware column semantic recognition method based on GCN and RoBERTa, including a data preprocessing module, a column semantic recognition module, and a label error correction and update optimization module;

[0088] The data preprocessing module is used to write Spark jobs to open the Hudi and MySQL data links to set up incremental synchronization data acquisition tasks, and collect and clean data according to fixed dimension partitions. The collected data is loaded into the MySQL environment in the form of overwriting existing data.

[0089] The column semantic recognition module is used to construct a vocabulary relationship graph based on the column relationship attributes and attribute relationships of the dataset, and use it as the input of a two-layer graph convolutional network to obtain the global semantic feature embedding of the GCN. At the same time, the preliminary column vector is linearized and encoded through the RoBERTa pre-trained model, and the three-layer Tansformer is used to obtain the local semantic feature embedding using its multi-head column attention mechanism. The embedding vectors output in parallel by GCN and RoBERta are fused with weights through the attention mechanism to obtain the contextual semantic information of global-local interaction, and Adaline is used for classification prediction.

[0090] The label error correction and update optimization module is used to implement co-occurrence error correction between labels through the Self-Attention mechanism, optimize model parameters through the cross-entropy loss function, and extract incremental data to cyclically update the optimization model;

[0091] Furthermore, the data extraction module includes a data acquisition module and a data cleaning module;

[0092] The data extraction module is used to write Spark jobs to connect Hudi and MySQL data links to set up incremental synchronization data acquisition tasks;

[0093] The data cleaning module is used to collect and clean data according to fixed dimension partitions. The collected data is loaded into the MySQL environment in the form of overwriting existing data. It includes missing value processing module, outlier processing module, and text processing module.

[0094] The missing value processing module is used to fill in missing data using the time series interpolation method and the previous and next valid value interpolation method;

[0095] The outlier processing module is used to delete erroneous outliers;

[0096] The text processing module is used to remove special characters and stop words from the text and perform Jieba word segmentation operations.

[0097] Furthermore, the column semantic recognition module includes a GCN global semantic feature embedding module, a local semantic feature embedding module and an information fusion prediction and classification module;

[0098] The GCN global semantic feature embedding module is used to construct a vocabulary graph using the WordNet semantic dictionary and NPMI, and to create a vocabulary relationship graph using the TF-IDF term frequency-inverse document frequency algorithm. The constructed vocabulary graph and dependency graph are concatenated and connected using a two-layer MLP. The vector is input into a two-layer GCN for convolution, and the node embedding vector is derived based on the node's neighborhood attributes.

[0099] The local semantic feature embedding module is used for linear encoding of the RoBERTa pre-trained model. The preliminary column vector is input into the three-layer Tansformer, and the Q, K, and V matrices in its multi-head column attention mechanism are used to obtain the vector representation of the local features. The multi-head attention mechanism is used to project the input word vector into different representation subspaces for linear learning, and the outputs of multiple attention heads are spliced ​​together to embed deeper local semantic features.

[0100] The information fusion prediction and classification module is used to fuse the global semantic feature information output by GCN with the local semantic feature information obtained by the multi-head self-attention mechanism of the core module Transformer in the RoBERTa pre-training model through the attention mechanism to obtain the contextual semantic information of the global-local interaction and integrate the output prediction classification probability using the Adaline algorithm. The multi-way MLP method is adopted to form a vector with the results obtained through different numbers of fully connected layers. This vector is the input of Adaline, and Adaline will score the outputs of different MLPs according to the probability of the output classification.

[0101] Furthermore, the label error correction and update optimization module includes an error correction module, a loss function update module, and an incremental data update module;

[0102] The error correction module is used to use the Self-Attention mechanism of the Transformer model encoder to realize the co-occurrence between labels, so that each input label can obtain a corresponding output vector, which is further classified and mapped to the real category label;

[0103] The loss function update module is used to update the prediction model parameters by joint training of the ternary entropy loss function and to optimize and update the error correction model parameters by using the cross entropy loss function;

[0104] The incremental data update module is used to update the optimization model by extracting incremental data from the Hudi data lake at a fixed time period.

[0105] The beneficial effects of the present invention are:

[0106] The present invention constructs a context column semantic recognition model and realizes the semantic recognition of metadata based on relational column projection. The present invention forms a complete semantic recognition system, combines the attribute values ​​of individual columns of relational data tables with the contextual semantic information of relational data tables, and proposes a context-aware column semantic recognition model that integrates local feature semantics and global feature semantic information; in addition, the model has the feature of being insensitive to column order, making the model prediction results more accurate. The present invention solves the problem of lack of semantic information in metadata information in database table structures, effectively laying the foundation for a series of subsequent links such as metadata-based data analysis and data governance, and enabling the interconnection and interoperability of semantics in different departmental systems of structured metadata. BRIEF DESCRIPTION OF THE DRAWINGS

[0107] In order to more clearly illustrate the technical solutions in the embodiments of the present application, the following briefly introduces the drawings required for use in the description of the embodiments. Obviously, the drawings described below are only some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without any creative work.

[0108] Figure 1 Schematic diagram of the process of the context-aware column semantic recognition method based on GCN and RoBERTa of the present invention;

[0109] Figure 2 This is a schematic diagram of the framework of the context-aware column semantic recognition model based on GCN and RoBERTa proposed in the present invention;

[0110] Figure 3Schematic diagram of the specific network architecture of the double-layer GCN graph convolutional network of the present invention;

[0111] Figure 4 Schematic diagram of the specific network architecture of the RoBERTa model of the present invention. DETAILED DESCRIPTION

[0112] Obviously, the examples listed in the detailed description are only some examples of the present invention, not all examples. Based on the examples of the present invention, all other examples obtained by technicians without creative work should fall within the scope of protection of the present invention. The present invention is further defined below with reference to the accompanying drawings and embodiments, but is not limited thereto.

[0113] Example 1

[0114] A context-aware column semantic recognition method based on GCN and RoBERTa, such as Figure 1 Shown, including:

[0115] Data preprocessing: Write a Spark job to connect Hudi and MySQL data links to set up incremental synchronization data acquisition tasks, and collect and clean data according to fixed dimension partitions. The collected data is loaded into the MySQL environment in the form of overwriting existing data;

[0116] Column semantic recognition: A column semantic recognition model constructed based on GCN and RoBERTa is used as a prediction model. A vocabulary relationship graph is constructed using the column relationship attributes and attribute relationships of the dataset. This graph is used as the input to a two-layer GCN graph convolutional network to obtain the GCN global semantic feature embedding. Simultaneously, the preliminary column vectors are linearized and encoded using the RoBERTa pre-trained model. The three-layer Tansformer uses its multi-head column attention mechanism to obtain local semantic feature embeddings. The parallel output embedding vectors of GCN and RoBERTa are fused with weights through the attention mechanism to obtain contextual semantic information of global-local interactions. Adaline is then used for classification prediction.

[0117] Label error correction and update optimization: The self-attention mechanism is used to correct co-occurrence errors between labels, and the cross-entropy loss function is used to optimize model parameters and extract incremental data to cyclically update the optimization model.

[0118] Example 2

[0119] According to the context-aware column semantic recognition method based on GCN and RoBERTa described in Example 1, Figure 2 As shown, the difference is:

[0120] In this method, a Spark job is written to execute the operation of打通 the data link between Hudi and MySQL to set up an incremental synchronization data acquisition task, and data is collected and cleaned according to fixed - dimension partitioning. The collected data is loaded into the MySQL environment in a form that overwrites the existing data. It includes:

[0121] Execute the operation of打通 the data link between Hudi and MySQL by writing a Spark job to set up an incremental synchronization data acquisition task. It includes: Import relevant required libraries in the Spark job, specifically referring to Apache Spark - related dependencies (SparkConf, SparkSession), Apache Hudi dependencies (DataSourceWriteOptions, DataSourceReadOptions, HoodieWriteConfig), and the MySQL connection library (java.sql.{Connection, DriverManager}). Then create a Spark session and write code to obtain the incremental data in the underlying storage HDFS of Hudi. The incremental data is the data that has been updated and changed in HDFS, and it is converted into the data format of MySQL. Use the write method of SparkDataFrame to write the data in the MySQL - converted data format into the MySQL database. Finally, use the spark - submit command to submit the job to execute the above steps.

[0122] Data is collected and cleaned according to fixed - dimension partitioning, and the collected data is loaded into the MySQL environment in a form that overwrites the existing data. Data cleaning includes performing missing - value handling, outlier handling, and text processing operations on the collected data in sequence.

[0123] Missing - value handling includes: For time - series data, time - series interpolation methods can be used to estimate missing values; for other types of data, the previous or next valid value in the column attributes is used for filling.

[0124] Outlier handling includes: When dealing with outliers, if the outliers are errors and do not represent the real situation, they will be deleted.

[0125] Text processing includes: Removing special characters, removing stop words, and jieba word segmentation. Removing special characters includes removing special characters such as "%" and special punctuations such as "..." in the text. Removing stop words includes removing common words that do not have analytical value, such as "的" and "是". Jieba word segmentation includes using the jieba.cut word - segmentation function to split the text into words and save them to build a word list.

[0126] It should be noted that the term "打通" in Chinese is not very clear in the context. A more appropriate English expression might be needed depending on the actual meaning. Here, a rough translation is provided.In this method, a column semantic recognition model constructed based on GCN and RoBERTa is used as a prediction model. The column relationship attributes and attribute relationships of the dataset are used to construct a vocabulary relationship graph, which is used as the input of a two-layer GCN graph convolutional network to obtain the GCN global semantic feature embedding. At the same time, the preliminary column vector is input into the three-layer Tansformer using its multi-head column attention mechanism to obtain the local semantic feature embedding through the linear encoding of the RoBERTa pre-trained model. The embedding vectors of the parallel output of GCN and RoBERTa are fused with weights through the attention mechanism to obtain the contextual semantic information of global-local interaction, and the classification prediction is performed using Adaline. The method includes:

[0127] Capture the GCN global semantic feature embedding vector; the GCN global semantic feature embedding vector refers to the feature vector containing global contextual semantic information output after convolution of the double-layer GCN graph convolutional network;

[0128] The capture process of the GCN global semantic feature embedding vector: Based on all the data written to the MySQL database as a relational dataset, the column relationship attributes (all the data in each column in the MySQL database) and attribute relationships (the corresponding label data in all the data in each column in the MySQL database) in the relational dataset are used to construct a large heterogeneous vocabulary relationship graph containing the interactive semantic information of the vocabulary graph of word nodes and the relationship dependency graph of document nodes. After Concat connection, the output of the two-layer MLP fully connected layer is obtained to obtain the GCN global preliminary vector, thereby obtaining the GCN global preliminary semantic features. The GCN global preliminary vector is input into the two-layer GCN graph convolution network for convolution operation, and for each node, a respective neighborhood calculation graph is constructed. The node vector representation of the 0th layer of the neighborhood calculation graph is initialized to the node attribute. According to the node information of the current node layer, the feature is transmitted to the next layer of layer propagation rules, and the message is passed from the 0th layer to the 2nd layer to obtain the neighborhood attributes contained in the neighboring nodes of the node, and finally the GCN global semantic feature embedding vector of the node is obtained.

[0129] Based on all the data written to the MySQL database as a relational dataset, the column relationship attributes (all the data in each column in the MySQL database) and attribute relationships (the corresponding label data in all the data in each column in the MySQL database) in the relational dataset are used to build a vocabulary relationship graph as the input of the two-layer GCN graph convolutional network;

[0130] Among them, the specific data contained in the cells where rows and columns intersect in the relational dataset is used as the word node of the two-layer GCN graph convolutional network, and all the data in each column of the relational dataset is used as the document node of the two-layer GCN graph convolutional network;

[0131] The constructed vocabulary relationship graph and dependency relationship graph are concat-concatenated to construct a large heterogeneous vocabulary relationship graph, and a two-layer MLP (multi-layer perceptron) is used for series operation to output the GCN global preliminary vector. The GCN global preliminary vector is input into the two-layer GCN graph convolutional network for convolution operation, and the node embedding vector is derived according to the node's neighborhood attributes.

[0132] Two-layer GCN graph convolutional network Figure 3 As shown;

[0133] The two-layer GCN graph convolutional network includes input layer, GCN1, hidden layer, GCN2, and output layer;

[0134] Input Layer: The input is a vocabulary relationship graph, represented as an adjacency matrix. The adjacency matrix represents the connection relationship between nodes in the graph, and the node feature matrix contains the feature vector of each node.

[0135] GCN1 (GCN Layer 1): GCN1 receives the attribute features of the input adjacency matrix, finds the first-order neighbor nodes of each node V in the first layer, and performs element-by-element averaging (element-by-element sum and then divided by the number of connections) on the first-order neighbor nodes to obtain their neighborhood information. Then, the ReLU activation function is used to introduce nonlinear features, and finally the GCN1 output contains the embedding vector of the first-order neighborhood information of the V node.

[0136] Hidden layer: The hidden layer is used to learn more advanced feature representations, including multiple neurons that perform linear and nonlinear transformations on the output of the previous layer.

[0137] GCN2 (GCN Layer 2): GCN2 receives the embedding vector of the first-order neighborhood information of node V output by GCN1 as input. Based on each first-order neighbor node M of node V, it finds the neighboring nodes of node M and performs an element-by-element averaging operation (element-by-element sum and then divided by the number of connections) to further obtain its indirect neighborhood information. It then uses the ReLU activation function to introduce nonlinear features to obtain the embedding vector of the indirect neighborhood information of node V output by GCN1.

[0138] Output Layer: Finally outputs the GCN global semantic feature embedding vector.

[0139] Build a vocabulary relationship graph, including:

[0140] The WordNet semantic dictionary and NPMI (Normalized Pointwise Mutual Information) normalized point-by-point mutual information are used to construct a vocabulary graph. The WordNet semantic dictionary and NPMI (Normalized Pointwise Mutual Information) normalized point-by-point mutual information are used to determine the semantic relevance between word-word node sets, thereby constructing a large heterogeneous vocabulary graph containing word nodes. This includes:

[0141] First, the weight between two word nodes is calculated by NPMI, and the similarity of word nodes is calculated by WordNet clustering operation containing only verbs, nouns, adjectives, and adverbs. If the NPMI of two word nodes is greater than a threshold, for example, the threshold is set to 0.86, a semantically related edge is created between the two word nodes; otherwise, the next step is performed. The calculation formula of NPMI of word node i and word node j is shown in formula (I):

[0142]

[0143] In formula (I), i and j are word nodes, #w is the total number of sliding windows, #w(i) is the number of all sliding windows containing word node i, #w(i,j) is the number of all sliding windows containing word node i and word node j;

[0144] Secondly, when the NPMI of two word nodes is not greater than the set threshold, the WUP (Wu-Palmer Similarity) method in WordNet is used to measure semantic similarity based on the path structure. The semantic similarity of the two word nodes is measured by calculating the distance between the lowest common subsumer (LCS) of the two word nodes and their respective LCSs. Then, a normalization operation is performed to calculate the similarity score. If the NPMI of the two words is not greater than the set threshold but the WUP is greater than the set threshold, for example, the set threshold is 0.8, a semantically related edge is still created between the two word nodes; the vocabulary graph is obtained; the calculation formula of the WUP of word node i and word node j is shown in formula (II):

[0145]

[0146] In formula (II), LCS(i,j) represents the lowest common hypernym of word nodes i and j, depth(LCS(i,j) represents the depth of the lowest common hypernym of word nodes i and j, that is, the length of the path from the root node to LCS, depth(i) represents the depth of word node i in the WordNet hierarchy, depth(j) represents the depth of word node j in the WordNet hierarchy;

[0147] Use the TF-IDF (Term Frequency-Inverse Document Frequency) algorithm to create a vocabulary relationship graph, including:

[0148] The importance of word-document node sets is determined using a weighted TF-IDF (term frequency-inverse document frequency) algorithm to construct a large dependency graph. TF represents the frequency of a specific word in a given document, while IDF represents the importance of a specific word across the entire document set. The frequency of a specific word in a given document is counted, and the number of documents containing the word is divided by the total number of documents, and the logarithm is taken. If the TF-IDF value is higher than 50% of the set threshold, a semantic dependency edge is created between the word-document node. If the TF-IDF value is lower than 50% of the set threshold, no semantic dependency edge is created. A weighted calculation is performed on each word-document node, ultimately resulting in a dependency graph. The formula for calculating the TF-IDF value of document node i and document node j is shown in Equation (III):

[0149]

[0150] In formula (III), n i,j represents the frequency of a specific word appearing in a given document, ∑ k n k,j represents the total number of words in the document, |D| represents the number of all documents, |j:t i ∈d j | indicates that it contains a specific word t i The number of documents;

[0151] The vocabulary graph and dependency graph are concatenated and connected using two layers of MLP (Multi-layer Perceptron) to obtain a vocabulary relationship graph, including:

[0152] The similarity vectors of the vocabulary graph and the relationship dependency graph are obtained for concat splicing, and a two-layer MLP is used for series operation to convert the vectors into a representation suitable for a two-layer GCN graph convolutional network, thereby obtaining a large heterogeneous vocabulary relationship graph containing interactive semantic information of the vocabulary graph of word nodes and the relationship dependency graph of document nodes. The vocabulary relationship graph is represented as G = (V, E), where V is a set of nodes and E is a set of edges.

[0153] The vector is input into the two-layer GCN graph convolutional network for convolution operation, and the node's embedding vector is derived based on the node's neighborhood attributes, including:

[0154] First, a neighborhood computation graph is constructed for each node, and the node vector representation of the 0th layer of the neighborhood computation graph is initialized as the node attribute;

[0155] Secondly, according to the layered propagation rule of aggregating node information of the current node layer and transmitting features to the next layer, message passing is performed from layer 0 to layer 2 to obtain information of adjacent nodes; for a single convolutional layer of the two-layer GCN graph convolutional network, the nodes in the k-th layer are element-wise summed and then divided by the number of connections, that is, the element-wise average operation is performed. The obtained vector is input into the two-layer GCN graph convolutional network, and two layers of convolution operations are performed. The embedding of the K+1-th layer v node is obtained through the activation function, and finally the GCN global semantic feature embedding vector of the node is obtained;

[0156] The single-layer convolution formula followed by the double-layer GCN graph convolution network is shown in formula (IV) and formula (V):

[0157]

[0158]

[0159] In formula (IV) and (V), Represents the vocabulary relationship graph of the dataset, W represents the hidden state of a weight of a single document, and the dimension is |V|*h; m represents the batch size, n represents the vocabulary size, h represents the hidden layer size, and s represents the sentence embedding size.

[0160] Through the linear encoding of the RoBERTa pre-trained model, the preliminary column vector is input into the three-layer Tansformer, using its multi-head column attention mechanism to obtain local semantic feature embedding, including:

[0161] First, the column relationship attributes and attribute relationships of the dataset are tokenized, linearized and encoded, and input into the RoBERTa pre-trained model;

[0162] Secondly, by inputting it into Tansformer’s three-layer multi-head column attention mechanism, the key content of the relational data column is calculated using the Q, K, and V matrices to obtain information of different dimensions and types;

[0163] Finally, the outputs of multiple attention heads are concatenated into a deeper context-containing local embedding representation.

[0164] The network architecture of the RoBERTa model is as follows Figure 4 As shown in the figure, the RoBERTa model includes an Embedding module, a Transformer module, and a pre-fine-tuning module.

[0165] Embedding module: responsible for mapping input text to vector representation.

[0166] Transformer module: The Transformer module is the core of RoBERTa and consists of a stack of multiple TransformerEncoder layers. Each Transformer Encoder layer includes a Multi-Head Self-Attention Layer and a Feed-Forward Neural Network Layer.

[0167] Pre-fine-tuning module: After processing by the intermediate Transformer layer, BERT's final layer is adjusted according to the different requirements of the task. This invention adopts the method of adding a multi-way MLP and Adaline algorithm to classify and predict semantic labels.

[0168] Linearized encoding, including:

[0169] The relational columns of the dataset are concatenated row by row to form a text, which is tokenized and used as the input representation of the RoBERTa pre-training model. After being encoded by the RoBERTa pre-training model Embedding, a preliminary column vector is output. Since the number of rows in each relational data table is not uniform and the training requires disrupting the order of all rows in the table, a larger batch of RoBERTa is used and a fixed maximum number of rows of 512 is required. According to the same relational theme, each relational table is split into multiple tables, and then the column relational dependencies of each column in the relational table are linearized by row concatenation. If the length of the linearized input column relational dependency exceeds the set threshold, it is truncated and split. If the length is less than the set threshold, it is padded with 0 to the set threshold.

[0170] Get contextual local embedding representation, including:

[0171] First, the preliminary column vector obtained in the previous step is input into Tansformer's three-layer multi-head column attention mechanism, which uses multiple sets of Q, K, and V matrices to project them into different representation subspaces. Each matrix in each subspace uses Q, K, and V matrices to focus on learning and calculating the relationship between the current word and all other words in the sentence, and continuously adjusts the weight of each word to enhance the vector representation of the local features of the current word. Finally, the output of the three-layer multi-head column attention mechanism is spliced ​​into a deeper level of local embedding representation containing context.

[0172] The formula of Tansformer's single-head self-attention mechanism is shown in (VI):

[0173]

[0174] In formula (VI), Q represents the query matrix, K represents the keyword matrix, V represents the original feature, QK T is the dot product operation, is the dimension size of K;

[0175] Secondly, in order to obtain the features of the column itself and the features after learning the context of the relational table, a three-layer multi-head column attention mechanism is used with the number of heads set to 12, the hidden layer dimension to 128, and the batch_size to 64. The input word vector is projected into different representation subspaces through multiple sets of QKV matrices, allowing the RoBERTa pre-trained model to fully pay attention to information of different dimensions and types. The 128-dimensional data of the original RoBERTa pre-trained model is linearly projected eight times to obtain eight 128-dimensional outputs. Finally, the outputs of the three-layer multi-head column attention mechanism are spliced ​​into a deeper local embedding representation containing context; the formula of the multi-head attention mechanism is shown in (VII):

[0176] Multi(Q,K,V)=Concat(head1,head2,...,head n )W

[0177] where head i =Attention(QW i Q ,KW i K ,VW i V )(VII)

[0178] In formula (VII), head i is the head of the attention mechanism, and n is the number of heads of the attention mechanism.

[0179] Formula (VI) represents the calculation process of Tansformer's column self-attention mechanism: given a task-related query Query vector Q, the attention score is calculated by calculating the attention distribution with the Key and appending it to the Value; Formula (VII) represents the calculation process of the multi-head attention mechanism, which divides the model into N "heads" to form N multiple subspaces. For each head, the attention score of each head is calculated using Formula (VI), and finally merged to form a vector containing multiple aspects of context information.

[0180] Information fusion prediction classification, including:

[0181] First, the GCN global semantic feature embedding and the RoBERTa local semantic feature embedding are fused with weights through the attention mechanism to obtain the contextual semantic feature vector of global-local interaction. The specific process is as follows:

[0182] Get the GCN global semantic feature embedding vector and the RoBERTa local semantic feature embedding vector, denoted as G (Global) and L (Local) respectively

[0183] The weight is calculated using the dot product attention weight function in the self-attention mechanism. The click attention calculation formula is shown in (VIII):

[0184] A[i]=softmax(G·L[i])(VIII)

[0185] Among them, A[i] represents the weights obtained by calculating the dot product between the global feature vector G and the local feature vector L[i], and the softmax function is used to normalize these weights to ensure that they add up to 1.

[0186] Apply the attention weight A to weighted sum the local feature vectors, that is, for each element L[i] in the local feature vector L, use the corresponding weight A[i] to weight it to obtain C[i], thereby obtaining the contextual semantic feature vector of the global-local interaction.

[0187] Secondly, during the training process of the RoBERTa pre-training model, the output vector is normalized by the MLP fully connected layer and the Softmax function, and finally the semantic category probability corresponding to each sample is output for prediction and classification; in order to enhance the robustness of the MLP layer, the present invention adopts the Adaline algorithm to integrate the output semantic category probabilities, including: using a multi-way MLP method to form a vector of the results obtained by passing through different layers of fully connected layers, which is the input of the Adaline algorithm. The Adaline algorithm scores the outputs of different MLPs according to the output semantic category probabilities; the closer the output semantic category probability is to the output value of the label, the higher the score will be; next, according to the distribution of this score, sampling is performed on a normal distribution, and different weights are accumulated for each score according to the sampled value, and the weighted score of the current sample is obtained according to the accumulated value, and the probability of the sample's final category is obtained.

[0188] The MLP model outputs the probability of predicting the semantic category label. The present invention trains four MLP models A, B, C, and D to receive the fused global-local interaction contextual semantic feature vector. The number of MLP model layers includes 3, 4, 5, and 6 fully connected layers, respectively.

[0189] Taking only four semantic labels as an example, the four semantic labels are cat, dog, bear, and bird. Assume that the output of MLP model A is [0.2, 0.7, 0.1, 0.0], the output of MLP model B is [0.1, 0.6, 0.2, 0.1], the output of MLP model C is [0.3, 0.4, 0.2, 0.1], and the output of MLP model D is [0.0, 0.2, 0.6, 0.2]. The probability vectors output by the four MLP models are merged, and the merged vector = [0.2, 0.7, 0.1, 0.0, 0.1, 0.6, 0.2, 0.1, 0.3, 0.4, 0.2, 0.1, 0.0, 0.2, 0.6, 0.2].

[0190] The Adaline algorithm accepts the merge vector, multiplies each probability value by a weight, samples on a normal distribution according to the distribution of the score, and accumulates each score with different weights according to the sampled value to score each semantic category.

[0191] Suppose the following weights are used for scoring: weight of dog: 0.5, weight of cat: 0.7, weight of bear: 0.4, weight of bird: 0.2.

[0192] Score of MLP model A = (0.2*0.5) + (0.7*0.7) + (0.1*0.4) + (0.0*0.2) = 0.39

[0193] Score of MLP model B = (0.1*0.5) + (0.6*0.7) + (0.2*0.4) + (0.1*0.2) = 0.42

[0194] Score of MLP model C = (0.3*0.5)+(0.4*0.7)+(0.2*0.4)+(0.1*0.2)=0.38

[0195] Score of MLP model D = (0.0*0.5)+(0.2*0.7)+(0.6*0.4)+(0.2*0.2)=0.35

[0196] Since MLP model B has the highest score, the final classification of the sample is cat.

[0197] In this method, the co-occurrence error correction between labels is achieved through the Self-Attention mechanism, and the model parameters are optimized through the cross-entropy loss function. In addition, incremental data is extracted to cyclically update the optimization model, including:

[0198] First, the Self-Attention mechanism of the Transformer Encoder is used to realize the co-occurrence between labels, so that each input label obtains a corresponding output vector, which is further classified and mapped to the actual category label.

[0199] Secondly, the loss function uses joint training to update the model parameters;

[0200] Finally, by setting a fixed time period, the incremental data extracted from the Hudi data lake is used to update the optimization model.

[0201] The self-attention mechanism is used to implement co-occurrence error correction between tags, including:

[0202] Build a co-occurrence label error correction model to map the incompletely correct label sequence y(1) predicted by the above prediction model to a more correct label sequence y(2); the error correction model selects the parallel and order-independent Transformer model Encoder module. The core of the Transformer Encoder module is the self-attention mechanism and the feedforward neural network, which are used to model the relationship between elements in the input sequence. The self-attention mechanism is used to model the dependency between different labels in the label sequence y(1) and to capture the association between labels. The self-attention mechanism enables the model to dynamically focus on different parts of the input sequence instead of focusing on a specific position. For each input element, the self-attention mechanism calculates a weighted combination that includes information from all other elements in the input sequence. The feedforward neural network helps capture local patterns and nonlinear relationships in the input sequence. Finally, the corrected label feature vector is output. The input of the error correction model is the label predicted by the prediction model. The label Each label is vectorized and the co-occurrence between labels is realized by using the Self-Attention mechanism of the Encoder part of the Transformer model. Each input label gets a corresponding output vector, which is further classified and mapped to the real category label, y = {y0, y1, ..., y n-1}, where each output position maximizes the probability of the input label sequence.

[0203] Updated optimization models, including:

[0204] First, the ternary entropy loss function is used for joint training to update the prediction model parameters, and the cross entropy loss function is used to optimize and update the error correction model;

[0205] Secondly, by setting a fixed time period, incremental data extracted from the Hudi data lake is used to update and optimize the prediction model;

[0206] Ternary entropy loss function, including:

[0207] The Adam optimizer is used to optimize the objective function to prevent the model from falling into a local minimum. Backpropagation is used to update the various parameters of the prediction model in each iteration until the prediction model meets the fitting requirements. The ternary entropy loss function is used to fine-tune the prediction model parameters through joint training. The cross entropy is calculated pairwise and averaged pooled to obtain the distance between the actual output and the expected output. The smaller the cross entropy value, the smaller the model prediction error loss value, and the closer the actual value is to the target value.

[0208] For each sample, the prediction model predicts the probability distribution as The actual label truth distribution is expressed as y = {y0,y1,...,y n-1}, for each pair of categories i and j, the cross entropy loss formula is shown in (Ⅸ):

[0209]

[0210] generate Cross entropy loss values ​​are average pooled to obtain the final ternary entropy loss as shown in (X):

[0211]

[0212] The cross entropy loss function of the error correction model includes:

[0213] For each sample, the error correction model uses cross entropy loss to calculate the loss between the original label distribution vector and the predicted vector, thereby obtaining a matching result that maximizes the alignment probability.

[0214] Extract incremental data and cyclically update the optimization model, including:

[0215] Incremental updates are performed at fixed time intervals based on the frequency of business data updates. Some business scenarios may require daily updates, such as the dining record table in the dining management system. In this case, Spark is needed to write a data acquisition script to extract incremental data at the daily level. Other tasks are updated weekly or monthly, such as the patent achievement conversion table in the achievement conversion system and the teacher basic information table in the teacher management system. In this case, the daily level can be selected, that is, incremental data extraction is required at the weekly or monthly level. The incremental data is extracted and collected and cleaned in step 1 to perform incremental cyclic updates on the model. That is, Shell-related code is written to enable the Torch model to be routineized. The model obtained by routineization is the model trained using incremental data (same structure, but different parameters). Then the T+1 incremental model replaces the T incremental model to become the inference model.

[0216] Example 3

[0217] A computer device includes a memory and a processor, wherein the memory stores a computer program, and when the processor executes the computer program, it implements the steps of a context-aware column semantic recognition method based on GCN and RoBERTa described in Example 1 or 2.

[0218] Example 4

[0219] A computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps of a context-aware column semantic recognition method based on GCN and RoBERTa described in Example 1 or 2.

[0220] Example 5

[0221] A context-aware column semantic recognition system based on GCN and RoBERTa, used to implement the context-aware column semantic recognition method based on GCN and RoBERTa described in Example 1 or 2, including a data preprocessing module, a column semantic recognition module, and a label error correction and update optimization module;

[0222] The data preprocessing module is used to write Spark jobs to connect Hudi and MySQL data links to set up incremental synchronous data acquisition tasks, and collect and clean data according to fixed dimension partitions. The collected data is loaded into the MySQL environment in the form of overwriting existing data.

[0223] The column semantic recognition module is used to construct a vocabulary relationship graph based on the column relationship attributes and attribute relationships of the dataset. This graph serves as the input to a two-layer graph convolutional network to obtain the global semantic feature embedding of the GCN. Simultaneously, the preliminary column vectors are linearized and encoded using the RoBERTa pre-trained model. The three-layer Tansformer uses its multi-head column attention mechanism to obtain local semantic feature embedding. The parallel output embedding vectors of the GCN and RoBERTa are weighted and fused through the attention mechanism to obtain contextual semantic information of global-local interactions. Adaline is then used for classification prediction.

[0224] The label error correction and update optimization module is used to implement co-occurrence error correction between labels through the Self-Attention mechanism, optimize model parameters through the cross-entropy loss function, and extract incremental data to cyclically update the optimization model;

[0225] The data extraction module includes a data collection module and a data cleaning module; the data extraction module is used to write Spark jobs to open up the Hudi and MySQL data links to set up incremental synchronous data acquisition tasks; the data cleaning module is used to collect and clean data according to fixed dimension partitions, and the collected data is loaded into the Mysql environment in the form of overwriting existing data; it includes a missing value processing module, an outlier processing module, and a text processing module; the missing value processing module is used to fill in missing data using time series interpolation methods and previous and next valid value interpolation methods; the outlier processing module is used to delete erroneous outliers; the text processing module is used to remove special characters and stop words from the text and perform Jieba word segmentation operations.

[0226] The column semantic recognition module includes the GCN global semantic feature embedding module, the local semantic feature embedding module and the information fusion prediction and classification module;

[0227] The GCN global semantic feature embedding module is used to build a vocabulary graph using the WordNet semantic dictionary and NPMI, and to create a vocabulary relationship graph using the TF-IDF term frequency-inverse document frequency algorithm. The constructed vocabulary graph and dependency graph are concatenated and connected using a two-layer MLP (multi-layer perceptron) network. The vector is input into the two-layer GCN for convolution operation, and the node embedding vector is derived based on the node's neighborhood attributes.

[0228] The local semantic feature embedding module is used for linear encoding of the RoBERTa pre-trained model. The preliminary column vector is input into the three-layer Tansformer, and the Q, K, and V matrices in its multi-head column attention mechanism are used to obtain the vector representation of the local features. The multi-head attention mechanism is used to project the input word vector into different representation subspaces for linear learning, and the outputs of multiple attention heads are spliced ​​together to embed deeper local semantic features.

[0229] The information fusion prediction and classification module is used to fuse the global semantic feature information output by GCN with the local semantic feature information obtained by the multi-head self-attention mechanism of the core module Transformer in the RoBERTa pre-training model through the attention mechanism to obtain the contextual semantic information of the global-local interaction and integrate the output prediction classification probability using the Adaline algorithm. The multi-way MLP method is adopted to form a vector with the results obtained through different numbers of fully connected layers. This vector is the input of Adaline, and Adaline will score the outputs of different MLPs according to the probability of the output classification.

[0230] The label error correction and update optimization module includes an error correction module, a loss function update module, and an incremental data update module; the error correction module is used to use the Self-Attention mechanism of the Encoder part of the Transformer model to realize the co-occurrence between labels, so that each input label can obtain a corresponding output vector, which is further classified and mapped to the real category label; the loss function update module is used to update the prediction model parameters through joint training of the ternary entropy loss function and to optimize and update the error correction model parameters using the cross-entropy loss function; the incremental data update module is used to update the optimization model by extracting incremental data from the hudi data lake through a fixed time period.

Claims

1. A context-aware column semantic recognition method based on GCN and RoBERTa, characterized by: include: Data preprocessing: Write a Spark job to connect Hudi and MySQL data links to set up incremental synchronization data acquisition tasks, and collect and clean data according to fixed dimension partitions. The collected data is loaded into the MySQL environment in the form of overwriting existing data; Column semantic recognition: The column semantic recognition model constructed based on GCN and RoBERTa is used as the prediction model; Use the column relationship attributes and attribute relationships of the dataset to build a vocabulary relationship graph, which is used as the input of the two-layer GCN graph convolutional network to obtain the GCN global semantic feature embedding; At the same time, the RoBERTa pre-trained model is used for linear encoding, and the preliminary column vector is input into the three-layer Tansformer, using its multi-head column attention mechanism to obtain local semantic feature embedding. The embedding vectors output by GCN and RoBERTa in parallel are fused with weights through the attention mechanism to obtain contextual semantic information of global-local interactions, and Adaline is used for classification prediction. Label error correction and update optimization: The self-attention mechanism is used to correct co-occurrence errors between labels. The cross-entropy loss function is used to optimize model parameters and incremental data is extracted to cyclically update the optimized model. Information fusion prediction classification, including: First, the GCN global semantic feature embedding and the RoBERTa local semantic feature embedding are fused with weights through the attention mechanism to obtain the global-local interactive contextual semantic feature vector; Secondly, during the training of the RoBERTa pre-training model, the output vector is passed through the MLP fully connected layer and the Softmax function normalization operation, and finally the semantic category probability corresponding to each sample is output for prediction and classification; the Adaline algorithm is used to integrate the output semantic category probabilities, including: using a multi-way MLP method to combine the results obtained after different layers of fully connected layers into a vector, which is the input of the Adaline algorithm. The Adaline algorithm scores the outputs of different MLPs according to the semantic category probabilities of the outputs; the closer the output semantic category probability is to the output value of the label, the higher the score will be; next, according to the distribution of this score, sampling is performed on a normal distribution, and each score is accumulated with different weights according to the sampled values. The weighted score of the current sample is obtained according to the accumulated value, and the probability of the sample's final category is obtained; In this method, the co-occurrence error correction between labels is achieved through the Self-Attention mechanism, and the model parameters are optimized through the cross-entropy loss function. In addition, incremental data is extracted to cyclically update the optimization model, including: First, the Self-Attention mechanism of the Transformer Encoder is used to realize the co-occurrence between labels, so that each input label obtains a corresponding output vector, which is further classified and mapped to the actual category label. Secondly, the loss function uses joint training to update the model parameters; Finally, by setting a fixed time period, the incremental data extracted from the Hudi data lake is used to update the optimization model; The self-attention mechanism is used to implement co-occurrence error correction between tags, including: Build a co-occurrence label construction error correction model, map the incompletely correct label sequence y(1) predicted by the above prediction model to a more correct label sequence y(2); the error correction model selects the Encoder module of the parallel and sequence-independent Transformer model, and the input of the error correction model is the label predicted by the prediction model. Each label is vectorized and the co-occurrence between labels is realized by using the Self-Attention mechanism of the Encoder part of the Transformer model. Each input label gets a corresponding output vector, which is further classified and mapped to the real category label, y = {y0, y1, ..., y n-1 }, where each output position maximizes the probability of the input label sequence; Updated optimization models, including: First, the ternary entropy loss function is used for joint training to update the prediction model parameters, and the cross entropy loss function is used to optimize and update the error correction model; Secondly, by setting a fixed time period, incremental data extracted from the Hudi data lake is used to update and optimize the prediction model; Ternary entropy loss function, including: The Adam optimizer is used to optimize the objective function, and backpropagation is used to update the various parameters of the prediction model in each iteration until the prediction model meets the fitting requirements. The ternary entropy loss function is used to fine-tune the prediction model parameters through joint training. The distance between the actual output and the expected output is obtained by calculating the cross entropy between each pair and performing average pooling operations. For each sample, the prediction model predicts the probability distribution as The actual label truth distribution is expressed as y = {y0,y1,...,y n-1 }, for each pair of categories i and j, the cross entropy loss formula is shown in (Ⅸ): generate Cross entropy loss values ​​are averaged and pooled to obtain the final ternary entropy loss as shown in (X):

2. A context-aware column semantic recognition method based on GCN and RoBERTa according to claim 1, characterized in that: In this method, a Spark job is written to connect Hudi and MySQL data links to set up incremental synchronous data acquisition tasks, and data is collected and cleaned according to fixed dimension partitions. The collected data is loaded into the MySQL environment in the form of overwriting existing data. This includes: Set up incremental data synchronization by writing a Spark job to connect Hudi to MySQL. This includes importing required libraries into the Spark job, creating a Spark session, and writing code to retrieve incremental data from Hudi's underlying storage, HDFS, and convert it to MySQL format. This data is then written into the MySQL database. Data is collected and cleaned according to fixed dimension partitions, and the collected data is loaded into the MySQL environment in the form of overwriting existing data; data cleaning includes missing value processing, outlier processing and text processing operations on the collected data in sequence.

3. A context-aware column semantic recognition method based on GCN and RoBERTa according to claim 2, characterized in that: In this method, a column semantic recognition model constructed based on GCN and RoBERTa is used as a prediction model; the column relationship attributes and attribute relationships of the dataset are used to construct a vocabulary relationship graph, which is used as the input of a two-layer GCN graph convolutional network to obtain GCN global semantic feature embedding; At the same time, the pre-trained RoBERTa model is linearized and encoded, and the preliminary column vector is input into the three-layer Tansformer, using its multi-head column attention mechanism to obtain local semantic feature embedding. The embedding vectors output by the parallel GCN and RoBERTa are fused with weights through the attention mechanism to obtain contextual semantic information of global-local interactions, and Adaline is used for classification prediction. This includes: Capture the GCN global semantic feature embedding vector; the GCN global semantic feature embedding vector refers to the feature vector containing global contextual semantic information output after convolution of the double-layer GCN graph convolutional network; Based on all the data written to the MySQL database as a relational dataset, the column relationship attributes and attribute relationships in the relational dataset are used to construct a vocabulary relationship graph as the input of the two-layer GCN graph convolutional network; Among them, the specific data contained in the cells where rows and columns intersect in the relational dataset is used as the word node of the two-layer GCN graph convolutional network, and all the data in each column of the relational dataset is used as the document node of the two-layer GCN graph convolutional network; The constructed vocabulary relationship graph and dependency relationship graph are concat-concatenated to construct a large heterogeneous vocabulary relationship graph, and a two-layer MLP is used for series operation to output the GCN global preliminary vector. The GCN global preliminary vector is input into a two-layer GCN graph convolutional network for convolution operation, and the node embedding vector is derived according to the node's neighborhood attributes.

4. The context-aware column semantic recognition method based on GCN and RoBERTa according to claim 2, characterized in that: Build a vocabulary relationship graph, including: The WordNet semantic dictionary and NPMI normalized point-wise mutual information are used to construct a vocabulary graph, including: First, the weight between two word nodes is calculated by NPMI, and the similarity of word nodes is calculated by WordNet clustering operation containing only verbs, nouns, adjectives, and adverbs. If the NPMI of two word nodes is greater than the threshold, a semantically related edge is created between the two word nodes; otherwise, the next step is performed. The calculation formula of NPMI of word node i and word node j is shown in formula (I): In formula (I), i and j are word nodes, #w is the total number of sliding windows, #w(i) is the number of all sliding windows containing word node i, #w(i,j) is the number of all sliding windows containing word node i and word node j; Secondly, when the NPMI of two word nodes is not greater than the set threshold, the WUP method in WordNet is used to measure semantic similarity based on the path structure. The semantic similarity is measured by calculating the distance between the lowest common hypernym LCS of the two word nodes and their respective LCSs. Then, a normalization operation is performed to calculate the similarity score. If the NPMI of the two words is not greater than the set threshold but the WUP is greater than the set threshold, a semantically related edge is still created between the two word nodes; the vocabulary graph is obtained; the calculation formula of the WUP of word node i and word node j is shown in formula (II): In formula (II), LCS(i,j) represents the lowest common hypernym of word nodes i and j, depth(LCS(i,j) represents the depth of the lowest common hypernym of word nodes i and j, that is, the length of the path from the root node to LCS, depth(i) represents the depth of word node i in the WordNet hierarchy, depth(j) represents the depth of word node j in the WordNet hierarchy; Use the TF-IDF term frequency-inverse document frequency algorithm to create a vocabulary relationship graph, including: If the TF-IDF value is higher than 50% of the set threshold, a semantic dependency edge is created between the word and document nodes. If the TF-IDF value is lower than 50% of the set threshold, no semantic dependency edge is created. A weighted calculation is performed on each word-document node to obtain a dependency graph. The formula for calculating the TF-IDF value of document node i and document node j is shown in formula (III): In formula (III), n i,j represents the frequency of a specific word appearing in a given document, ∑ k n k,j represents the total number of words in the document, |D| represents the number of all documents, |j:t i ∈d j | indicates that it contains a specific word t i The number of documents; The vocabulary graph and dependency graph are concatenated and connected using two layers of MLP to obtain a vocabulary relationship graph, including: The similarity vectors of the vocabulary graph and the relationship dependency graph are obtained for concat splicing, and a two-layer MLP is used for series operation to obtain a large heterogeneous vocabulary relationship graph containing the interactive semantic information of the vocabulary graph of word nodes and the relationship dependency graph of document nodes. The vocabulary relationship graph is represented as G = (V, E), where V is the set of nodes and E is the set of edges.

5. The context-aware column semantic recognition method based on GCN and RoBERTa according to claim 1, characterized in that: The vector is input into the two-layer GCN graph convolutional network for convolution operation, and the node's embedding vector is derived based on the node's neighborhood attributes, including: First, a neighborhood computation graph is constructed for each node, and the node vector representation of the 0th layer of the neighborhood computation graph is initialized as the node attribute; Secondly, according to the layered propagation rule of aggregating node information of the current node layer and transmitting features to the next layer, message passing is performed from layer 0 to layer 2 to obtain information of adjacent nodes; for a single convolutional layer of the two-layer GCN graph convolutional network, the nodes in the k-th layer are element-wise summed and then divided by the number of connections, that is, the element-wise average operation is performed. The obtained vector is input into the two-layer GCN graph convolutional network, and two layers of convolution operations are performed. The embedding of the K+1-th layer v node is obtained through the activation function, and finally the GCN global semantic feature embedding vector of the node is obtained; The single-layer convolution formula followed by the double-layer GCN graph convolutional network is shown in formula (IV) and formula (V): In formula (IV) and (V), Represents the vocabulary relationship graph of the dataset, W represents the hidden state of a weight of a single document, and the dimension is |V|*h; m represents the batch size, n represents the vocabulary size, h represents the hidden layer size, and s represents the sentence embedding size.

6. The context-aware column semantic recognition method based on GCN and RoBERTa according to claim 1, characterized in that Through the linear encoding of the RoBERTa pre-trained model, the preliminary column vector is input into the three-layer Tansformer, using its multi-head column attention mechanism to obtain local semantic feature embedding, including: First, the column relationship attributes and attribute relationships of the dataset are tokenized, linearized and encoded, and input into the RoBERTa pre-trained model; Secondly, by inputting it into Tansformer’s three-layer multi-head column attention mechanism, the key content of the relational data column is calculated using the Q, K, and V matrices to obtain information of different dimensions and types; Finally, the outputs of multiple attention heads are concatenated into a deeper context-containing local embedding representation.

7. The context-aware column semantic recognition method based on GCN and RoBERTa according to claim 6, characterized in that: Linearized encoding, including: The relational columns of the dataset are concatenated row by row to form a text segment. This text is tokenized and used as the input representation of the RoBERTa pre-trained model. After embedding encoding by the RoBERTa pre-trained model, a preliminary column vector is output. A fixed maximum number of rows is set to 512. Each relational table is split into multiple tables according to the same relational theme. The column relational dependencies of each column in the relational table are then linearized by row concatenation. If the length of the linearized input column relational dependency exceeds the set threshold, it is truncated and split. If the length is less than the set threshold, it is padded with zeros to the set threshold.

8. The context-aware column semantic recognition method based on GCN and RoBERTa according to claim 7, characterized in that: Get contextual local embedding representation, including: First, the preliminary column vector obtained in the previous step is input into Tansformer's three-layer multi-head column attention mechanism, which uses multiple sets of Q, K, and V matrices to project them into different representation subspaces. Each matrix in each subspace uses Q, K, and V matrices to focus on learning and calculating the relationship between the current word and all other words in the sentence, and continuously adjusts the weight of each word to enhance the vector representation of the local features of the current word. Finally, the output of the three-layer multi-head column attention mechanism is spliced ​​into a deeper local embedding representation containing context. The formula of Tansformer's single-head self-attention mechanism is shown in (VI): In formula (VI), Q represents the query matrix, K represents the keyword matrix, V represents the original feature, QK T is the dot product operation, is the dimension size of K; Secondly, a three-layer multi-head column attention mechanism is used in the multi-head attention mechanism, with the number of heads set to 12, the hidden layer dimension to 128, and the batch_size to 64. The input word vectors are projected into different representation subspaces through multiple sets of QKV matrices, allowing the RoBERTa pre-trained model to fully pay attention to information of different dimensions and types. The 128-dimensional data of the original RoBERTa pre-trained model is linearly projected eight times to obtain eight 128-dimensional outputs. Finally, the outputs of the three-layer multi-head column attention mechanism are spliced ​​into a deeper local embedding representation containing context. The formula of the multi-head attention mechanism is shown in (VII): Multi(Q,K,V)=Concat(head1,head2,...,head n )W where head i =Attention(QW i Q ,KW i K ,VW i V )(Ⅶ) In formula (VII), head i is the head of the attention mechanism, and n is the number of heads of the attention mechanism.

9. A computer device comprising a memory and a processor, wherein the memory stores a computer program, wherein: When the processor executes the computer program, it implements the steps of a context-aware column semantic recognition method based on GCN and RoBERTa as described in any one of claims 1-8.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by a processor, the steps of a context-aware column semantic recognition method based on GCN and RoBERTa are implemented.

11. A context-aware column semantic recognition system based on GCN and RoBERTa, characterized by: A context-aware column semantic recognition method based on GCN and RoBERTa for implementing any one of claims 1-8, comprising a data preprocessing module, a column semantic recognition module, and a label error correction and update optimization module; The data preprocessing module is used to write Spark jobs to connect Hudi and MySQL data links to set up incremental synchronization data acquisition tasks, and collect and clean data according to fixed dimension partitions. The collected data is loaded into the MySQL environment in the form of overwriting existing data; The column semantic recognition module is used to construct a vocabulary relationship graph based on the column relationship attributes and attribute relationships of the dataset, which is used as the input of the two-layer graph convolutional network to obtain the GCN global semantic feature embedding; At the same time, the RoBERTa pre-trained model is used for linear encoding, and the preliminary column vector is input into the three-layer Tansformer, using its multi-head column attention mechanism to obtain local semantic feature embedding. The embedding vectors output by GCN and RoBERTa in parallel are fused with weights through the attention mechanism to obtain contextual semantic information of global-local interactions, and Adaline is used for classification prediction. The label error correction and update optimization module is used to achieve co-occurrence error correction between labels through the Self-Attention mechanism, and to optimize model parameters through the cross-entropy loss function and extract incremental data to cyclically update the optimization model.

12. A context-aware column semantic recognition system based on GCN and RoBERTa according to claim 11, characterized in that: The data extraction module includes a data acquisition module and a data cleaning module; The data extraction module is used to write Spark jobs to connect Hudi and MySQL data links to set up incremental synchronization data acquisition tasks; The data cleaning module is used to collect and clean data according to fixed dimension partitions. The collected data is loaded into the MySQL environment in the form of overwriting existing data. It includes missing value processing module, outlier processing module, and text processing module. The missing value processing module is used to fill in missing data using the time series interpolation method and the previous and next valid value interpolation method; The outlier processing module is used to delete erroneous outliers; The text processing module is used to remove special characters and stop words from the text and perform Jieba word segmentation operations.

13. The context-aware column semantic recognition system based on GCN and RoBERTa according to claim 11, characterized in that: The column semantic recognition module includes a GCN global semantic feature embedding module, a local semantic feature embedding module and an information fusion prediction and classification module; The GCN global semantic feature embedding module is used to construct a vocabulary graph using the WordNet semantic dictionary and NPMI, and to create a vocabulary relationship graph using the TF-IDF term frequency-inverse document frequency algorithm. The constructed vocabulary graph and dependency graph are concatenated and connected using a two-layer MLP. The vector is input into a two-layer GCN for convolution, and the node embedding vector is derived based on the node's neighborhood attributes. The local semantic feature embedding module is used for linear encoding of the RoBERTa pre-trained model. The preliminary column vector is input into the three-layer Tansformer, and the Q, K, and V matrices in its multi-head column attention mechanism are used to obtain the vector representation of the local features. The multi-head attention mechanism is used to project the input word vector into different representation subspaces for linear learning, and the outputs of multiple attention heads are spliced ​​together to embed deeper local semantic features. The information fusion prediction and classification module is used to fuse the global semantic feature information output by GCN with the local semantic feature information obtained by the multi-head self-attention mechanism of the core module Transformer in the RoBERTa pre-training model through the attention mechanism to obtain the contextual semantic information of the global-local interaction and integrate the output prediction classification probability using the Adaline algorithm. The multi-way MLP method is adopted to form a vector with the results obtained through different numbers of fully connected layers. This vector is the input of Adaline, and Adaline will score the outputs of different MLPs according to the probability of the output classification.

14. The context-aware column semantic recognition system based on GCN and RoBERTa according to claim 11, characterized in that: The label error correction and update optimization module includes an error correction module, a loss function update module, and an incremental data update module; The error correction module is used to use the Self-Attention mechanism of the Transformer model encoder to realize the co-occurrence between labels, so that each input label can obtain a corresponding output vector, which is further classified and mapped to the real category label; The loss function update module is used to update the prediction model parameters by joint training of the ternary entropy loss function and to optimize and update the error correction model parameters by using the cross entropy loss function; The incremental data update module is used to update the optimization model by extracting incremental data from the Hudi data lake at a fixed time period.

Images