Client data classification method, device and equipment based on longitudinal federated learning

Abstract

The application discloses a kind of based on longitudinal federal learning's client data classification method, device and equipment, including obtaining to be detected client dataset, and to be detected client dataset is input to preset longitudinal federal learning classification model, preset longitudinal federal learning classification model includes feature coding module, feature purification module and server classification module;Data padding is carried out to to be detected client dataset using feature coding module, and output feature embedding dataset;Tensor decomposition is carried out to feature embedding dataset by feature purification module, and low-rank recovery tensor matrix is generated;Low-rank recovery tensor matrix is input to server classification module and is aggregated classification, and output target classification prediction result;The technical problem that the existing longitudinal federal learning data classification method can cause the situation that client data is missing in federal learning, thereby leading to the performance of longitudinal federal learning model is greatly reduced is solved.

Description

Technical Field

[0001] This invention relates to the field of distributed client data processing methods, and in particular to a data classification method, apparatus, and device based on longitudinal federated learning. Background Technology

[0002] As the storage and processing capabilities of smart devices continue to develop, the importance of data science in industrial engineering is becoming increasingly prominent. However, due to limitations in the private data of local clients, its versatility is also limited. Therefore, in practical applications, it is difficult to use traditional centralized learning methods to collect data scattered across various devices. Federated learning aims to achieve a distributed machine learning setup by coordinating multiple clients through a central server.

[0003] Currently, Federated Learning (FL) has become an effective solution to overcome the data silo problem without infringing on user privacy, while simultaneously protecting data privacy. Recently, Vertical Federated Learning (VFL) has attracted increasing attention. VFL is a collaborative machine learning method involving data held by different participants, where feature data is partitioned column-wise, and each participant has its own distinct feature set. While prioritizing privacy, VFL is well-suited for meeting enterprise needs and can efficiently build superior machine learning models. Therefore, VFL technology has been widely adopted in practical applications and is receiving positive support.

[0004] Existing methods for classifying data in vertical federated learning primarily focus on cases involving only two clients. They do not adequately consider the possibility of missing client data due to network transmission failures or storage device malfunctions, which leads to a significant drop in the performance of vertical federated learning models. Summary of the Invention

[0005] This invention provides a client data classification method, apparatus, and device based on vertical federated learning, which solves the technical problem that existing client data classification methods based on vertical federated learning result in missing client data in federated learning, thus leading to a significant decrease in the performance of vertical federated learning models.

[0006] The first aspect of this invention provides a client-side data classification method based on longitudinal federated learning, comprising:

[0007] Obtain the client dataset to be detected and input the client dataset to be detected into a preset vertical federated learning classification model, which includes a feature encoding module, a feature purification module and a server classification module;

[0008] The feature encoding module is used to fill in the data of the client dataset to be detected, and the feature embedding dataset is output.

[0009] The feature purification module performs tensor decomposition on the feature embedding dataset to generate a low-rank recovery tensor matrix.

[0010] The low-rank recovery tensor matrix is ​​input into the server classification module for aggregation classification, and the target classification prediction result is output.

[0011] Optionally, the feature embedding dataset includes multiple feature embedding matrices; the feature encoding module includes a padding layer and a feature extractor; the step of using the feature encoding module to pad the client dataset to be detected and outputting the feature embedding dataset includes:

[0012] Multiple client data filled feature matrices are generated by using a pre-set learnable matrix to fill multiple data feature matrices in the client dataset to be detected through a filling layer;

[0013] The feature extractor is used to fill the feature matrix of each client data and extract features respectively, outputting multiple feature embedding matrices.

[0014] Optionally, the feature purification module includes an average aggregation layer and multiple 1×1 convolutional layers; the step of performing tensor decomposition on the feature embedding dataset through the feature purification module to generate a low-rank recovery tensor matrix includes:

[0015] Data embedding is performed on each of the feature embedding matrices to generate an embedding tensor corresponding to the client dataset to be detected;

[0016] The embedding tensor is input into the average aggregation layer for multi-dimensional average aggregation, and the dimension embedding vector corresponding to the embedding tensor is output.

[0017] The dimensional embedding vectors are respectively input into each of the 1×1 convolutional layers for convolution operations, and multiple rank-one vectors are output, including a first rank-one vector, a second rank-one vector, and a third rank-one vector.

[0018] Perform the Kronecker product operation on each of the first rank-one vectors, each of the second rank-one vectors, and each of the third rank-one vectors to generate multiple rank-one vectors;

[0019] The rank tensors are superimposed to output a low-rank recovery tensor matrix.

[0020] Optionally, the server classification module includes an aggregation layer and a global classifier; the step of inputting the low-rank recovery tensor matrix into the server classification module for aggregation classification and outputting the target classification prediction result includes:

[0021] The aggregation layer is used to aggregate the low-rank recovery tensor matrix to generate multi-faceted customer-dimensional data.

[0022] The global classifier is used to classify and predict the multi-dimensional data of the customer dimension, and the target classification prediction result is output.

[0023] Optionally, before the step of obtaining the client dataset to be detected and inputting the client dataset to be detected into a pre-set longitudinal federated learning classification model, the following steps are included:

[0024] Obtain the client dataset to be trained, and input the client dataset to be trained into the initial longitudinal federated learning classification model, and output the embedding tensor to be trained, the low-rank recovery tensor matrix to be trained, and the classification prediction result to be trained;

[0025] The target loss value is calculated using the embedding tensor to be trained, the low-rank recovery tensor matrix to be trained, and the classification prediction result to be trained.

[0026] If the target loss value has converged, the trained initial longitudinal federated learning classification model is used as the preset longitudinal federated learning classification model.

[0027] A second aspect of the present invention provides a client-side data classification device based on longitudinal federated learning, comprising:

[0028] The acquisition module is used to acquire the client dataset to be detected and input the client dataset to be detected into a preset vertical federated learning classification model. The preset vertical federated learning classification model includes a feature encoding module, a feature purification module and a server classification module.

[0029] The module is used to fill the client dataset to be detected with data using the feature encoding module and output the feature embedding dataset;

[0030] The decomposition module is used to perform tensor decomposition on the feature embedding dataset through the feature purification module to generate a low-rank recovery tensor matrix.

[0031] The classification module is used to input the low-rank recovery tensor matrix into the server classification module for aggregation classification and output the target classification prediction result.

[0032] Optionally, the feature embedding dataset includes multiple feature embedding matrices; the feature encoding module includes a padding layer and a feature extractor; the emulation module includes:

[0033] The matrix filling submodule is used to fill multiple data feature matrices in the client dataset to be detected by using a preset learnable matrix through the filling layer, thereby generating multiple client data filled feature matrices.

[0034] The feature extraction submodule is used to extract features from the feature matrix filled by each client data using the feature extractor, and output multiple feature embedding matrices.

[0035] Optionally, the feature purification module includes an average aggregation layer and multiple 1×1 convolutional layers; the decomposition module includes:

[0036] The data embedding submodule is used to embed data into each of the feature embedding matrices to generate an embedding tensor corresponding to the client dataset to be detected.

[0037] The average aggregation submodule is used to input the embedding tensor into the average aggregation layer for multi-dimensional average aggregation and output the dimension embedding vector corresponding to the embedding tensor.

[0038] The convolution operation submodule is used to input the dimension embedding vector into each of the 1×1 convolutional layers for convolution operation and output multiple rank-one vectors, wherein the rank-one vectors include a first rank-one vector, a second rank-one vector and a third rank-one vector;

[0039] The Kronecker product operation submodule is used to perform Kronecker product operations on each of the first rank-one vectors, each of the second rank-one vectors and each of the third rank-one vectors respectively to generate multiple rank-one vectors;

[0040] The superposition submodule is used to superimpose the rank tensors and output a low-rank recovery tensor matrix.

[0041] Optionally, the server classification module includes an aggregation layer and a global classifier; the classification module includes:

[0042] The aggregation submodule is used to aggregate the low-rank recovery tensor matrix using the aggregation layer to generate multi-dimensional customer data.

[0043] The classification prediction submodule is used to perform classification prediction on the multi-source data of the customer dimension through the global classifier and output the target classification prediction result.

[0044] A third aspect of the present invention provides an electronic device, including a memory and a processor, wherein the memory stores a computer program, and when the computer program is executed by the processor, the processor causes the processor to perform the steps of the client data classification method based on longitudinal federated learning as described in any of the preceding claims.

[0045] As can be seen from the above technical solutions, the present invention has the following advantages:

[0046] The above-mentioned technical solution of the present invention provides a client data classification method based on vertical federated learning. First, a client dataset to be detected is acquired and input into a pre-set vertical federated learning classification model, which includes a feature encoding module, a feature purification module, and a server classification module. Next, the feature encoding module fills in the client dataset to be detected, outputting a feature embedding dataset. The feature purification module performs tensor decomposition on the feature embedding dataset to generate a low-rank recovery tensor matrix. Finally, the low-rank recovery tensor matrix is ​​input into the server classification module for aggregation classification, outputting the target classification prediction result. This solution, by using a feature encoding module to fill in the client dataset to be detected and combining it with a feature purification module to perform tensor decomposition on the feature embedding dataset output after data filling, fully considers the situation of missing client data in federated learning, better handles missing client data, and thus maintains the high performance of the model. Attached Figure Description

[0047] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0048] Figure 1 A flowchart illustrating the steps of a client-side data classification method based on vertical federated learning, provided for an embodiment of the present invention;

[0049] Figure 2 This is a schematic diagram of the structure of a pre-built vertical federated learning classification model provided in an embodiment of the present invention;

[0050] Figure 3 A flowchart illustrating the steps of another client-side data classification method based on vertical federated learning provided in this embodiment of the invention;

[0051] Figure 4A schematic diagram of CP (CANDECOMP / PARAFAC) decomposition provided in an embodiment of the present invention;

[0052] Figure 5 This is a structural block diagram of a client-side data classification device based on vertical federated learning, provided as an embodiment of the present invention. Detailed Implementation

[0053] This invention provides a client data classification method, apparatus, and device based on vertical federated learning, which addresses the technical problem that existing client data classification methods based on vertical federated learning result in missing client data in federated learning, leading to a significant decrease in the performance of vertical federated learning models.

[0054] To make the objectives, features, and advantages of this invention more apparent and understandable, the technical solutions of the embodiments of this invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the embodiments described below are only some embodiments of this invention, and not all embodiments. Based on the embodiments of this invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this invention.

[0055] The concept of federated learning was first introduced by Google in 2016. This technology aims to allow multiple data stakeholders to collaboratively build machine learning models while ensuring the privacy and security of individual data are not compromised. Federated learning offers a new solution to the conflict between data privacy and collaboration.

[0056] Vertical federated learning (VFL) is an important branch of federated learning that has received increasing attention in recent years. This is because VFL largely meets the needs of enterprise collaboration, especially for those enterprises that share the same user base but have different data capabilities. Enterprises typically face data fragmentation and diversity, and VFL provides them with an effective way to enable different organizations to collaboratively build machine learning models without sharing sensitive information.

[0057] Significant progress has been made in VFL research. Early VFL work began with the proposal of the first VFL model. Since then, VFL has been extensively studied, involving various machine learning models, including linear regression, decision tree models, and kernel models. This research has provided a solid foundation for applications in different fields, enabling VFL to be more widely applicable to various problems and scenarios.

[0058] Furthermore, some researchers have proposed methods for handling missing features and labeled data, such as semi-supervised longitudinal federated learning, especially in the case of multi-view learning. However, it should be noted that current methods primarily focus on handling cases between two clients, while in practical applications, it may be necessary to address data sharing and privacy issues among more clients.

[0059] Please see Figure 1 , Figure 1 A flowchart illustrating the steps of a client-side data classification method based on vertical federated learning, as provided in an embodiment of the present invention.

[0060] This invention provides a client-side data classification method based on longitudinal federated learning, comprising:

[0061] Step 101: Obtain the client dataset to be detected and input the client dataset to be detected into the pre-set vertical federated learning classification model. The pre-set vertical federated learning classification model includes a feature encoding module, a feature purification module, and a server classification module.

[0062] It should be noted that Federated Learning (FL) is a machine learning framework proposed to address the data silo problem. It allows multiple clients located in different locations to collaboratively train a shared global machine learning model on a central server while protecting the privacy of each client. Federated Learning provides a new paradigm for privacy-preserving machine learning, enabling multiple clients to collaborate on model training without sharing private data. Vertical Federated Learning (VFL), as a variant of Federated Learning, aims to address the privacy protection and collaborative machine learning problems of vertically partitioned data among different participants. In Vertical Federated Learning, different participants (usually organizations, institutions, or individuals) possess different feature data but share the same label information. This situation typically occurs in cross-organizational collaboration or privacy-sensitive data scenarios. In this application, based on the basic setup of a typical Vertical Federated Learning (VFL) framework, the task of training a VFL model by M participants using a set of N training data is defined as follows:

[0063]

[0064] with

[0065]

[0066] h n,m =g m (x n,m ;θ m ), m=1,...,M

[0067] Among them, f ω The global model for learning by the machine and server; Θ = [θ1,…,θ M [This refers to the local model parameter set;] To obtain the accuracy loss of the global model parameters; r is a client-by-client regularization that limits the complexity of the local model parameters or encodes prior knowledge about the local model parameters; x n,m For the nth data sample from the mth client; θ m These are the model parameters for the m-th client; The classification result obtained; y n Let n be the label of the nth data item.

[0068] Based on the above, this application is available for a set of clients. In this process, the client data to be detected for each client is obtained, thus forming a client dataset to be detected. Each client is associated with a specific type of feature, and client m holds data of length p. m Feature X (m) , It can also be represented as client m having a size of N×p m The data feature matrix, therefore the client dataset to be detected includes data with... Different types of features Each sample (multiple data feature matrices) is the client dataset to be detected. Among them, real labels It is represented as a vector of length N.

[0069] Further, please refer to Figure 2 The pre-built vertical federated learning classification model provided in this application consists of a feature encoding module, a feature purification module, and a server classification module, corresponding to... Figure 2 The process involves three stages: client-side missing feature encoding, tensor low-order feature extraction, and server training. The feature encoding module is used to process input client-side datasets that may contain randomly missing data. Different types of features The system uses a feature sample to fill in the data; the feature purification module performs tensor decomposition on the input data; and the server classification module performs aggregation and classification on the input data.

[0070] In this embodiment, a client dataset to be detected is obtained and input into a pre-set vertical federated learning classification model. The pre-set vertical federated learning classification model includes a feature encoding module, a feature purification module, and a server classification module.

[0071] Step 102: Use the feature encoding module to populate the client dataset to be detected and output the feature embedding dataset.

[0072] The feature embedding dataset includes multiple feature embedding matrices.

[0073] The feature encoding module includes a padding layer and a feature extractor.

[0074] The client dataset to be detected includes multiple data feature matrices and labels corresponding to each data feature matrix. The data feature matrix includes multiple feature samples.

[0075] It should be noted that when dealing with client data (the client dataset to be detected) that may have random data loss, this application first fills the feature matrices of each data using a pre-set learnable matrix through a filling layer to generate multiple client data filled feature matrices. Then, a feature extractor is used to extract features from each client data filled feature matrix and output multiple feature embedding matrices. The pre-set learnable matrix includes a random initialization matrix and a priori matrix.

[0076] In this embodiment, a feature encoding module is used to populate the client dataset to be detected and output a feature embedding dataset.

[0077] Step 103: Perform tensor decomposition on the feature embedding dataset using the feature purification module to generate a low-rank recovery tensor matrix.

[0078] The feature purification module includes an average aggregation layer and multiple 1×1 convolutional layers.

[0079] Multiple 1×1 convolutional layers include multiple first-direction 1×1 convolutional layers, multiple second-direction 1×1 convolutional layers, and multiple third-direction 1×1 convolutional layers.

[0080] It should be noted that, firstly, data embedding is performed on each feature embedding matrix to generate an embedding tensor corresponding to the client dataset to be detected. Then, a multi-dimensional average aggregation layer is used to aggregate the input embedding tensor, outputting the dimensional embedding vectors corresponding to the embedding tensor. Specifically, the input embedding tensor is averaged and aggregated along three different dimensions to obtain three embedding vectors of different sizes: a first-dimensional embedding vector, a second-dimensional embedding vector, and a third-dimensional embedding vector. The first-dimensional embedding vector is then input into each 1×1 convolutional layer in the first direction for convolution operations, and the second-dimensional embedding vector is input into each 1×1 convolutional layer in the second direction. The layers perform convolution operations, and the third-dimensional embedding vectors are input into the third-dimensional 1×1 convolutional layers for convolution operations, outputting multiple first-rank vectors, multiple second-rank vectors, and multiple third-rank vectors. Finally, Kronecker product operations are performed on each first-rank vector and the corresponding second-rank and third-rank vectors to generate multiple rank tensors. The rank tensors are then superimposed to output a low-rank recovery tensor matrix. Here, the first-dimensional embedding vector, the second-dimensional embedding vector, and the third-dimensional embedding vector constitute the dimensional embedding vector, and the first-rank vector, the second-rank vector, and the third-rank vector constitute the rank vector.

[0081] In this embodiment, the feature embedding dataset is decomposed into a low-rank recovery tensor matrix by the feature purification module.

[0082] Step 104: Input the low-rank recovery tensor matrix into the server classification module for aggregation classification and output the target classification prediction result.

[0083] The server classification module includes an aggregation layer and a global classifier.

[0084] It should be noted that the aggregation layer performs aggregation on the low-rank recovery tensor matrix to generate multi-faceted customer-dimensional data. Then, a global classifier is used to classify and predict the multi-faceted customer-dimensional data, thereby outputting the target classification prediction result, i.e., the target classification prediction matrix. Specifically, the data processing procedure of the aggregation layer is as follows:

[0085]

[0086] Where H represents multi-source data on the customer dimension; M represents the number of clients corresponding to each data feature matrix; To recover the low-rank tensor matrix For the i-th front slice, the size of the low-rank recovery tensor matrix is ​​N×h; h is the length of each feature sample; N is the number of feature samples in the client dataset to be detected.

[0087] The data processing procedure for the global classifier is as follows:

[0088]

[0089] Where Pre is the target classification prediction result; H is the multi-faceted data of the customer dimension; cls(·) is the global classifier; c is the number of predicted categories; and N is the number of feature samples in the client dataset to be detected.

[0090] In this embodiment, the low-rank recovery tensor matrix is ​​input to the server classification module for aggregation classification, and the target classification prediction result is output.

[0091] In this embodiment of the invention, this application provides a client data classification method based on vertical federated learning. First, a client dataset to be detected is obtained and input into a pre-set vertical federated learning classification model, which includes a feature encoding module, a feature purification module, and a server classification module. Next, the feature encoding module fills in the client dataset to be detected, outputting a feature embedding dataset. The feature purification module performs tensor decomposition on the feature embedding dataset to generate a low-rank recovery tensor matrix. Finally, the low-rank recovery tensor matrix is ​​input into the server classification module for aggregation classification, outputting the target classification prediction result. This scheme, by using a feature encoding module to fill in the client dataset to be detected and combining it with a feature purification module to perform tensor decomposition on the feature embedding dataset output after data filling, fully considers the situation of missing client data in federated learning, better handles missing client data, and thus maintains the high performance of the model.

[0092] Please see Figure 3 , Figure 3 A flowchart illustrating the steps of another client-side data classification method based on vertical federated learning provided in this embodiment of the invention.

[0093] Step 301: Obtain the client dataset to be trained, and input the client dataset to be trained into the initial longitudinal federated learning classification model, outputting the embedding tensor to be trained, the low-rank recovery tensor matrix to be trained, and the classification prediction results to be trained.

[0094] The client dataset to be trained includes multiple feature matrices of the data to be trained and labels corresponding to each feature matrix of the data to be trained. The feature matrix of the data to be trained includes multiple feature samples to be trained.

[0095] The initial longitudinal federated learning classification model includes an initial feature encoding module, an initial feature purification module, and an initial server classification module.

[0096] It should be noted that the client dataset to be trained is input into the initial feature encoding module for data filling, and the output is the feature embedding dataset to be trained. The initial feature purification module performs tensor decomposition on the feature embedding dataset to be trained, generating the low-rank recovery tensor matrix to be trained. The initial server classification module performs aggregation classification on the low-rank recovery tensor matrix to be trained, and outputs the classification prediction result to be trained (the classification prediction matrix to be trained).

[0097] In this embodiment, the client dataset to be trained is obtained and input into the initial longitudinal federated learning classification model, which outputs the embedding tensor to be trained, the low-rank recovery tensor matrix to be trained, and the classification prediction result to be trained.

[0098] Step 302: Calculate the target loss value using the embedding tensor to be trained, the low-rank recovery tensor matrix to be trained, and the classification prediction results to be trained.

[0099] It should be noted that, unlike existing Alternating Least Squares (ALS) optimization algorithms, this application updates model parameters through end-to-end training using backpropagation, allowing the network to adapt to different client datasets. The reconstruction loss is calculated using the training embedding tensor and the training low-rank recovery tensor, specifically as follows:

[0100]

[0101] Among them, L lr To reconstruct the loss value; Embed tensors to be trained; The low-rank recovery tensor to be trained; The Frobenius norm (F-norm) represents the norm of the Frobenius system. Squaring and summing each value in the set.

[0102] Furthermore, based on the classification prediction results to be trained, i.e., based on the classification prediction matrix to be trained, the cross-entropy loss value is determined. The calculation process of the cross-entropy loss value is as follows:

[0103]

[0104] Among them, L ce Y is the cross-entropy loss value; N is the number of feature samples in the data feature matrix; i Let Pre be the true label of the i-th data feature matrix in the client dataset to be trained; i Let be the i-th classification prediction vector in the classification prediction matrix to be trained.

[0105] Furthermore, to encourage the local encoder to encode better representations when client data is lost, and to encourage the global classifier to make better predictions, the target loss value is calculated using reconstruction loss and cross-entropy loss, specifically:

[0106]

[0107] in, L represents the target loss value. ce λ is the cross-entropy loss value; λ is a hyperparameter, generally fixed at 0.1, with a value range of [0,1]; L lr To reconstruct the loss value.

[0108] In this embodiment, the target loss value is calculated using the embedding tensor to be trained, the low-rank recovery tensor matrix to be trained, and the classification prediction result to be trained.

[0109] Step 303: If the target loss value has converged, then the trained initial longitudinal federated learning classification model is used as the preset longitudinal federated learning classification model.

[0110] It should be noted that if the target loss value does not converge, a new client dataset to be trained is used to continue training the untrained pre-built longitudinal federated learning classification model until the target loss value converges, thereby obtaining a trained pre-built longitudinal federated learning classification model.

[0111] In this embodiment, if the target loss value has converged, the trained initial longitudinal federated learning classification model is used as the preset longitudinal federated learning classification model.

[0112] Step 304: Obtain the client dataset to be detected and input the client dataset to be detected into the preset vertical federated learning classification model. The preset vertical federated learning classification model includes a feature encoding module, a feature purification module, and a server classification module.

[0113] In this embodiment, a client dataset to be detected is obtained and input into a pre-set vertical federated learning classification model. The pre-set vertical federated learning classification model includes a feature encoding module, a feature purification module, and a server classification module.

[0114] Step 305: Use the feature encoding module to populate the client dataset to be detected and output the feature embedding dataset.

[0115] The feature embedding dataset includes multiple feature embedding matrices.

[0116] The feature encoding module includes a padding layer and a feature extractor.

[0117] The pre-set learnable matrix includes a random initialization matrix and a priori matrix.

[0118] Furthermore, step 305 may include the following sub-steps:

[0119] S51. Multiple client data filled feature matrices are generated by using a pre-set learnable matrix to fill multiple data feature matrices in the client dataset to be detected through the filling layer.

[0120] S52. Use a feature extractor to fill the feature matrix of each client's data and extract features respectively, outputting multiple feature embedding matrices.

[0121] It should be noted that, generally speaking, in VFL, the server connects to each client individually. Each client is trained by θ. m The corresponding parameterized feature extractor g m And obtain the feature embedding dataset, i.e. H (m) =g m (X (m) ,θ m For m = 1, ..., M; In this application, considering that the feature samples in the client dataset may be randomly missing, when faced with client data (the client dataset to be detected) that may have random data loss, this application first uses a pre-set learnable matrix to fill in the data feature matrix of the client dataset to be detected that has data loss, and then inputs it into the feature extractor g. m Thus, the feature embedding dataset H is obtained. (m) Then it is uploaded to the server, specifically:

[0122]

[0123] Among them, H (m) For feature embedding datasets; g m (·) represents the feature extractor; X (m) The dataset to be detected is the client dataset; E (m) To randomly initialize the matrix; Q (m) Let θ be the prior matrix containing available and missing features for the m-th client; m These are the parameters of the feature extractor.

[0124] Furthermore, the prior matrix is ​​as follows:

[0125]

[0126] in, This is the nth data point in the prior matrix; This is the nth feature sample in the client dataset to be detected.

[0127] In this embodiment, a feature encoding module is used to populate the client dataset to be detected and output a feature embedding dataset.

[0128] Step 306: Perform tensor decomposition on the feature embedding dataset using the feature purification module to generate a low-rank recovery tensor matrix.

[0129] The feature purification module includes an average aggregation layer and multiple 1×1 convolutional layers.

[0130] Multiple 1×1 convolutional layers include multiple first-direction 1×1 convolutional layers, multiple second-direction 1×1 convolutional layers, and multiple third-direction 1×1 convolutional layers.

[0131] It's important to note that tensor decomposition is a mathematical and data analysis method used to decompose a multidimensional array (tensor) into a set of low-rank components, often called factors or patterns. This technique has wide applications in many fields, including data dimensionality reduction, signal processing, image processing, natural language processing, machine learning, and data mining. In tensor decomposition, the original data can be represented as a product of multiple parts, typically a product of a set of factor tensors. CP decomposition, also known as CANDECOMP / PARAFAC (CP) decomposition, is a tensor decomposition method used to represent a high-dimensional tensor as a product of a set of low-rank factors. This decomposition method is very useful in multidimensional data analysis and multidimensional signal processing. CP decomposition involves decomposing a three-dimensional or higher-dimensional tensor (usually denoted as X) into a product of three or more factor matrices, where the factor matrix refers to a combination of vectors from the first-order components.

[0132] Further, please refer to Figure 4 This application selects regularized multidimensional (CP) decomposition as the standard for learning low-order priors of tensors. Through CP decomposition, the low-rank tensors are learned from the training set, and then the lost tensor information is recovered. CP decomposition decomposes a tensor into the sum of R rank tensors. Assuming a given N-order tensor... Specifically:

[0133]

[0134] Where R is an integer; These are first-order Kroneker basis vectors; For the Kronecker product; α r is the scalar weight parameter; x is the Nth order tensor.

[0135] Furthermore, step 306 may include the following sub-steps:

[0136] S61. Perform data embedding on each feature embedding matrix to generate the embedding tensor corresponding to the client dataset to be detected;

[0137] S62. Input the embedding tensor into the average aggregation layer to perform multi-dimensional average aggregation, and output the dimension embedding vector corresponding to the embedding tensor.

[0138] S63. Input the dimension embedding vectors into each 1×1 convolutional layer for convolution operation, and output multiple rank-one vectors, including the first rank-one vector, the second rank-one vector and the third rank-one vector.

[0139] S64. Perform the Kronecker product operation on each first rank vector, each second rank vector, and each third rank vector to generate multiple rank tensors.

[0140] S65. Superimpose the tensors of each rank to output the low-rank recovery tensor matrix.

[0141] The dimensional embedding vectors include the first-dimensional embedding vector, the second-dimensional embedding vector, and the third-dimensional embedding vector.

[0142] A rank-one vector includes a first rank-one vector, a second rank-one vector, and a third rank-one vector.

[0143] It should be noted that, in order to obtain complementary information among different customers and reduce the impact of missing data, this application adopts a low-order representation method based on tensor feature embedding to learn the interaction information of all clients and recover the feature embeddings of the lost data. First, the collected feature embedding matrices are embedded into a tensor, specifically as follows:

[0144]

[0145] in, For embedding tensors; H (M) Let N be the embedding matrix of the Mth feature; N×h×M is the size of the embedding tensor.

[0146] Furthermore, in existing techniques, CP decomposition typically employs the Alternating Least Squares (ALS) algorithm. However, the complexity of the data makes the solution unstable. Most importantly, this solution strategy may be insufficient to capture nonlinear feature interactions, and the rank R needs to be pre-estimated based on the dataset size, specifically:

[0147]

[0148]

[0149] Where R is an integer; These are first-order Kroneker basis vectors; For the Kronecker product; α r These are scalar weight parameters; The low-rank recovery tensor to be trained; The Frobenius norm (F-norm) represents the norm of the Frobenius system. Squaring and summing each value in the set.

[0150] Based on the above, this application designs a deep learning-based computational method. Considering the similarity between different features of the same data, a low-order tensor CP decomposition is performed on the server side. The reconstructed tensor is obtained by optimizing the decomposition factor. Specifically, the input embedding tensor is subjected to multi-dimensional average aggregation through an average aggregation layer, and the corresponding dimension embedding vectors of the embedding tensor are output. That is, the obtained embedding tensor is averaged and aggregated according to three different dimensions to obtain three embedding vectors of different dimensions (first-dimensional embedding vector, second-dimensional embedding vector, and third-dimensional embedding vector), specifically:

[0151]

[0152]

[0153]

[0154] Among them, h (1) h is the first-dimensional embedding vector; (2) h is the second-dimensional embedding vector. (3) Agg1(·) is the embedding vector in the third dimension; Agg2(·) is the operator that performs average aggregation of the embedding tensor in the first dimension direction; Agg3(·) is the operator that performs average aggregation of the embedding tensor in the second dimension direction; Agg3(·) is the operator that performs average aggregation of the embedding tensor in the third dimension direction. For embedding tensors;

[0155] Furthermore, after obtaining the first-dimensional embedding vector, second-dimensional embedding vector, and third-dimensional embedding vector output after performing the average aggregation operation, this application designs R 1×1 convolutional kernels for vectors in three directions, namely multiple first-direction 1×1 convolutional layers, multiple second-direction 1×1 convolutional layers, and multiple third-direction 1×1 convolutional layers, to generate corresponding rank-one vectors. Specifically, the first-dimensional embedding vector is input into each first-direction 1×1 convolutional layer for convolution operation, the second-dimensional embedding vector is input into each second-direction 1×1 convolutional layer for convolution operation, and the third-dimensional embedding vector is input into each third-direction 1×1 convolutional layer for convolution operation, outputting multiple first-rank-one vectors, multiple second-rank-one vectors, and multiple third-rank-one vectors, as follows:

[0156]

[0157]

[0158]

[0159] in, It is a first-rank vector; It is a second-rank vector; The vector is a rank-one vector; σ(·) is the Sigmoid activation function; Conv(·) is the convolution function with a 1×1 kernel; h (1) h is the first-dimensional embedding vector; (2) h is the second-dimensional embedding vector. (3) w1 is the embedding vector in the third dimension; w2 is the parameter of the 1×1 convolutional layer in the first direction; w3 is the parameter of the 1×1 convolutional layer in the second direction; w4 is the parameter of the 1×1 convolutional layer in the third direction.

[0160] Furthermore, in the CP tensor model, This can be interpreted as a factor vector, generating a rank-1 tensor (rank-one tensor) with the Kroneckor product from these rank-1 vectors. Specifically, the Kroneckor product is performed on each first rank-1 vector and its corresponding second and third rank-1 vectors to generate multiple rank-one tensors, as follows:

[0161]

[0162] in, A rank-one tensor; It is a first-rank vector; It is a second-rank vector; It is a third-rank vector.

[0163] Furthermore, by superimposing the R rank tensors, that is, by stacking the rank tensors, we can obtain the low-rank recovery tensor, specifically:

[0164]

[0165] in, For low-rank recovery tensor matrix; R is a rank-one tensor; R is the number of rank-one tensors.

[0166] In this embodiment, the feature embedding dataset is decomposed into a low-rank recovery tensor matrix by the feature purification module.

[0167] Step 307: Input the low-rank recovery tensor matrix into the server classification module for aggregation classification and output the target classification prediction result.

[0168] The server classification module includes an aggregation layer and a global classifier.

[0169] Furthermore, step 307 may include the following sub-steps:

[0170] S71. Use an aggregation layer to aggregate the low-rank recovery tensor matrix to generate multi-dimensional customer data.

[0171] S72. Use a global classifier to classify and predict the multi-dimensional data of the customer and output the target classification prediction results.

[0172] It should be noted that the downstream task of the model designed in this application is a common classification problem, in which the server needs to train a global classification network (global classifier) ​​to perform classification prediction. Therefore, this application performs aggregation on the low-rank recovery tensor matrix to capture multi-faceted information along the customer dimension of the downstream classification task, i.e., customer-dimensional multi-faceted data; then, the customer-dimensional multi-faceted data H is input into the parameterized global classifier, and the target classification prediction result (target classification prediction matrix) is output.

[0173] In this embodiment, the low-rank recovery tensor matrix is ​​input to the server classification module for aggregation classification, and the target classification prediction result is output.

[0174] For comparison of technical effects, existing technologies can be referenced. In current federated learning, the reasons for data loss can be varied. For example, problems may occur during data collection or transmission, leading to partial data loss. This could be due to network transmission errors, hardware problems, data corruption, etc. Simultaneously, some data may be intentionally protected by the client, such as sensitive information, personally identifiable information, or data protected by laws and regulations. In federated learning, some clients can choose not to share certain sensitive data to ensure privacy and security. Furthermore, there are data collection issues: client data collection can be affected by many factors, such as the quality of the collection equipment, sampling frequency, and data storage methods. These factors may lead to partial data loss or incompleteness. Hardware or software problems may cause data storage or transmission failures on client devices, resulting in data loss.

[0175] Furthermore, missing data can lead to several problems, such as: reduced model performance: Missing data prevents the model from fully utilizing information from the client, thus impacting performance. Model accuracy and predictive power may decrease because the missing data contains useful information. Increased communication overhead: Missing data requires more communication overhead because model parameter updates need to be frequently transmitted between clients to fill in the missing data. This can result in additional network overhead. Bias and unfairness: Missing data can lead to biases in model training because the missing data is usually not random and may introduce bias. This can result in unfair models with inconsistent predictive accuracy across different groups. Unstable models: Model performance may become unstable when faced with missing data. Model performance may vary across different clients, making it difficult for the model to maintain consistency across different data distributions. Model generalization problems: Missing data can lead to generalization problems, meaning the model performs poorly on new data. The model may overfit the available data and be unable to cope with future data changes.

[0176] However, existing algorithms largely ignore this issue and do not adequately consider the data gaps in federated learning. For example, the existing method FedCVT primarily focuses on handling cases involving only two clients, while in real-world applications, it is often necessary to address data sharing and privacy issues among more clients.

[0177] Furthermore, vertical federated learning is a collaborative machine learning approach involving data held by different participants, where feature data is partitioned by columns, and each participant possesses its own distinct feature set. For example, one participant's data might include user ID, age, and gender, while another might contain user ID and purchase history. However, in practical applications, client data is often affected by various unpredictable factors, such as network transmission failures and storage device malfunctions, leading to frequent data gaps. This constitutes the data gap problem in vertical federated learning; in traditional vertical federated learning frameworks, missing data is typically ignored or imputed with zero or random values. However, it is clear that missing data can severely impact model performance, and inappropriate imputation methods can also harm the model's effectiveness. Therefore, we need to seek a reasonable method to handle missing feature data to ensure that model performance is not significantly compromised.

[0178] Based on the above, the main problem addressed in this application is how to handle missing feature data in longitudinal federated learning (VFL) to reduce model performance loss and ensure relatively stable model performance even when facing missing data. This involves effectively filling in missing data to maintain model accuracy and robustness. Furthermore, the main objective of this invention is to address the negative impact of missing data on VFL algorithms by mitigating its impact on model performance, thereby improving VFL's robustness and efficiency in the face of missing data. This aims to provide a more comprehensive solution to address the challenges of missing data in multi-client scenarios in practical applications, ensuring that the model can still work effectively under these conditions.

[0179] To address the aforementioned issues, this invention proposes a client-side data classification method based on longitudinal federated learning. By combining CP decomposition with longitudinal federated learning, we can not only better handle missing data but also maintain model performance. Unlike traditional tensor computation methods, this invention introduces a network-based CP computation interaction method, which allows the model to better capture nonlinear information in the data, thereby improving the model's accuracy and robustness. By introducing a network structure, the model can better understand the complex relationships in the data, enabling it to perform well when processing highly complex data. Furthermore, the network-based CP computation interaction method introduced in this invention has broad applicability, not only addressing traditional federated learning problems but also playing a role in a wider range of machine learning scenarios, possessing potential cross-domain application value and providing strong support for data processing and analysis in different fields.

[0180] Furthermore, the client data classification method proposed in this invention, based on longitudinal federated learning, is grounded in tensor decomposition and aims to effectively alleviate the performance degradation caused by missing feature data in longitudinal federated learning. By utilizing advanced mathematical tools, the model can better handle missing data, maintain its predictive accuracy, and reduce the adverse effects of missing data on the results. Unlike traditional methods, it is not limited by the number of clients and can easily adapt to federated learning scenarios of different scales. This makes the method more versatile and applicable to applications of various scales and complexities, exhibiting excellent flexibility and scalability in terms of the number of clients. Unlike traditional methods, it is not limited by the degree of missing client data. Even in the face of high missing data, the algorithm can still produce relatively good results and maintain model performance. This robustness makes the method of this invention perform well when dealing with unstable or variable data, and has broader application potential.

[0181] In this embodiment of the invention, this application provides a client data classification method based on vertical federated learning. First, a client dataset to be detected is obtained and input into a pre-set vertical federated learning classification model, which includes a feature encoding module, a feature purification module, and a server classification module. Next, the feature encoding module fills in the client dataset to be detected, outputting a feature embedding dataset. The feature purification module performs tensor decomposition on the feature embedding dataset to generate a low-rank recovery tensor matrix. Finally, the low-rank recovery tensor matrix is ​​input into the server classification module for aggregation classification, outputting the target classification prediction result. This scheme, by using a feature encoding module to fill in the client dataset to be detected and combining it with a feature purification module to perform tensor decomposition on the feature embedding dataset output after data filling, fully considers the situation of missing client data in federated learning, better handles missing client data, and thus maintains the high performance of the model.

[0182] Please see Figure 5 , Figure 5 This is a structural block diagram of a client-side data classification device based on vertical federated learning, provided as an embodiment of the present invention.

[0183] The acquisition module 501 is used to acquire the client dataset to be detected and input the client dataset to be detected into a preset vertical federated learning classification model. The preset vertical federated learning classification model includes a feature encoding module, a feature purification module and a server classification module.

[0184] Module 502 is used to fill the client dataset to be detected with data using the feature encoding module and output a feature embedding dataset;

[0185] The decomposition module 503 is used to perform tensor decomposition on the feature embedding dataset through the feature purification module to generate a low-rank recovery tensor matrix.

[0186] The classification module 504 is used to input the low-rank recovery tensor matrix into the server classification module for aggregation classification and output the target classification prediction result.

[0187] Furthermore, module 502 is adopted, including:

[0188] The matrix filling submodule is used to fill multiple data feature matrices in the client dataset to be detected by using a preset learnable matrix through the filling layer, thereby generating multiple client data filled feature matrices.

[0189] The feature extraction submodule is used to extract features from the feature matrix filled by each client data using the feature extractor, and output multiple feature embedding matrices.

[0190] Furthermore, the decomposition module 503 includes:

[0191] The data embedding submodule is used to embed data into each of the feature embedding matrices to generate an embedding tensor corresponding to the client dataset to be detected.

[0192] The average aggregation submodule is used to input the embedding tensor into the average aggregation layer for multi-dimensional average aggregation and output the dimension embedding vector corresponding to the embedding tensor.

[0193] The convolution operation submodule is used to input the dimension embedding vector into each of the 1×1 convolutional layers for convolution operation and output multiple rank-one vectors, wherein the rank-one vectors include a first rank-one vector, a second rank-one vector and a third rank-one vector;

[0194] The Kronecker product operation submodule is used to perform Kronecker product operations on each of the first rank-one vectors, each of the second rank-one vectors and each of the third rank-one vectors respectively to generate multiple rank-one vectors;

[0195] The superposition submodule is used to superimpose the rank tensors and output a low-rank recovery tensor matrix.

[0196] Furthermore, classification module 504 includes:

[0197] The aggregation submodule is used to aggregate the low-rank recovery tensor matrix using the aggregation layer to generate multi-dimensional customer data.

[0198] The classification prediction submodule is used to perform classification prediction on the multi-source data of the customer dimension through the global classifier and output the target classification prediction result.

[0199] Optionally, it also includes:

[0200] The training module is used to acquire the client dataset to be trained, input the client dataset to be trained into the initial longitudinal federated learning classification model, and output the embedding tensor to be trained, the low-rank recovery tensor matrix to be trained, and the classification prediction result to be trained.

[0201] The loss calculation module is used to calculate the target loss value using the embedding tensor to be trained, the low-rank recovery tensor matrix to be trained, and the classification prediction result to be trained.

[0202] The convergence module is used to use the trained initial longitudinal federated learning classification model as the preset longitudinal federated learning classification model if the target loss value has converged.

[0203] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working processes of the devices, modules, and sub-modules described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

[0204] This invention also provides an electronic device, which includes a processor and a memory:

[0205] The memory is used to store program code and transfer the program code to the processor;

[0206] The processor is used to execute the client data classification method based on vertical federated learning according to the instructions in the program code of the above embodiments of the present invention.

[0207] In the several embodiments provided in this application, it should be understood that the disclosed apparatus and methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some interfaces; the indirect coupling or communication connection between apparatuses or units may be electrical, mechanical, or other forms.

[0208] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0209] The above-described embodiments are only used to illustrate the technical solutions of the present invention, and are not intended to limit it. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. A client-side data classification method based on vertical federated learning, characterized in that, include: Obtain the client dataset to be detected and input the client dataset to be detected into a preset vertical federated learning classification model, which includes a feature encoding module, a feature purification module and a server classification module; The feature encoding module is used to fill in the data of the client dataset to be detected, and the feature embedding dataset is output. The feature purification module performs tensor decomposition on the feature embedding dataset to generate a low-rank recovery tensor matrix. The low-rank recovery tensor matrix is ​​input into the server classification module for aggregation classification, and the target classification prediction result is output. The feature embedding dataset includes multiple feature embedding matrices; The feature encoding module includes an padding layer and a feature extractor; the step of using the feature encoding module to pad the client dataset to be detected and outputting a feature embedding dataset includes: Multiple client data filled feature matrices are generated by using a pre-set learnable matrix to fill multiple data feature matrices in the client dataset to be detected through a filling layer; The feature extractor is used to fill the feature matrix of each client data and perform feature extraction respectively, outputting multiple feature embedding matrices; The feature purification module includes an average aggregation layer and multiple 1×1 convolutional layers; the step of performing tensor decomposition on the feature embedding dataset through the feature purification module to generate a low-rank recovery tensor matrix includes: Data embedding is performed on each of the feature embedding matrices to generate an embedding tensor corresponding to the client dataset to be detected; The embedding tensor is input into the average aggregation layer for multi-dimensional average aggregation, and the dimension embedding vector corresponding to the embedding tensor is output. The dimensional embedding vectors are respectively input into each of the 1×1 convolutional layers for convolution operations, and multiple rank-one vectors are output, including a first rank-one vector, a second rank-one vector, and a third rank-one vector. Perform the Kronecker product operation on each of the first rank-one vectors, each of the second rank-one vectors, and each of the third rank-one vectors to generate multiple rank-one vectors; The rank tensors are superimposed to output a low-rank recovery tensor matrix.

2. The client data classification method based on vertical federated learning according to claim 1, characterized in that, The server classification module includes an aggregation layer and a global classifier; the step of inputting the low-rank recovery tensor matrix into the server classification module for aggregation classification and outputting the target classification prediction result includes: The aggregation layer is used to aggregate the low-rank recovery tensor matrix to generate multi-faceted customer-dimensional data. The global classifier is used to classify and predict the multi-dimensional data of the customer dimension, and the target classification prediction result is output.

3. The client data classification method based on vertical federated learning according to claim 1, characterized in that, Before the steps of obtaining the client dataset to be detected and inputting the client dataset to be detected into a pre-set longitudinal federated learning classification model, the following steps are included: Obtain the client dataset to be trained, and input the client dataset to be trained into the initial longitudinal federated learning classification model, and output the embedding tensor to be trained, the low-rank recovery tensor matrix to be trained, and the classification prediction result to be trained; The target loss value is calculated using the embedding tensor to be trained, the low-rank recovery tensor matrix to be trained, and the classification prediction result to be trained. If the target loss value has converged, the trained initial longitudinal federated learning classification model is used as the preset longitudinal federated learning classification model.

4. A client-side data classification device based on vertical federated learning, characterized in that, include: The acquisition module is used to acquire the client dataset to be detected and input the client dataset to be detected into a preset vertical federated learning classification model. The preset vertical federated learning classification model includes a feature encoding module, a feature purification module and a server classification module. The module is used to fill the client dataset to be detected with data using the feature encoding module and output the feature embedding dataset; The decomposition module is used to perform tensor decomposition on the feature embedding dataset through the feature purification module to generate a low-rank recovery tensor matrix. The classification module is used to input the low-rank recovery tensor matrix into the server classification module for aggregation classification and output the target classification prediction result; The feature embedding dataset includes multiple feature embedding matrices; The feature encoding module includes a padding layer and a feature extractor; The adopted module includes: The matrix filling submodule is used to fill multiple data feature matrices in the client dataset to be detected by using a preset learnable matrix through the filling layer, thereby generating multiple client data filled feature matrices. The feature extraction submodule is used to extract features from each of the client data by filling the feature matrix with the feature extractor and output multiple feature embedding matrices. The feature purification module includes an average aggregation layer and multiple 1×1 convolutional layers; the decomposition module includes: The data embedding submodule is used to embed data into each of the feature embedding matrices to generate an embedding tensor corresponding to the client dataset to be detected. The average aggregation submodule is used to input the embedding tensor into the average aggregation layer for multi-dimensional average aggregation and output the dimension embedding vector corresponding to the embedding tensor. The convolution operation submodule is used to input the dimension embedding vector into each of the 1×1 convolutional layers for convolution operation and output multiple rank-one vectors, wherein the rank-one vectors include a first rank-one vector, a second rank-one vector and a third rank-one vector; The Kronecker product operation submodule is used to perform Kronecker product operations on each of the first rank-one vectors, each of the second rank-one vectors and each of the third rank-one vectors respectively to generate multiple rank-one vectors; The superposition submodule is used to superimpose the rank tensors and output a low-rank recovery tensor matrix.

5. The client-side data classification device based on vertical federated learning according to claim 4, characterized in that, The server classification module includes an aggregation layer and a global classifier; the classification module includes: The aggregation submodule is used to aggregate the low-rank recovery tensor matrix using the aggregation layer to generate multi-dimensional customer data. The classification prediction submodule is used to perform classification prediction on the multi-source data of the customer dimension through the global classifier and output the target classification prediction result.

6. An electronic device, characterized in that, The system includes a memory and a processor, wherein the memory stores a computer program that, when executed by the processor, causes the processor to perform the steps of the client data classification method based on longitudinal federated learning as described in any one of claims 1-3.

Images