Longitudinal federated learning training method, system, application, terminal and medium
By constructing an intelligent agent using a heterogeneous local model and a deep Q-learning self-demonstration algorithm, and dynamically adjusting the quantization configuration parameters, the problems of high communication and computational overhead and rigid architecture in vertical federated learning are solved, and efficient training in a heterogeneous resource environment is achieved.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- SHANGHAI JIAOTONG UNIV
- Filing Date
- 2025-09-19
- Publication Date
- 2026-07-24
AI Technical Summary
Vertical federated learning suffers from technical problems such as high communication and computation overhead, rigid system architecture, and difficulty in adapting to heterogeneous client resources and data characteristics. Existing low-bit training methods are insufficient in balancing efficiency and accuracy.
A heterogeneous local model and a vertical federated framework are adopted, and an intelligent agent is constructed by combining a deep Q-learning self-demonstration algorithm. The quantization configuration parameters are dynamically adjusted, and communication and computation are optimized through low-bit integer quantization to achieve end-to-end intelligent scheduling.
It enhances the flexibility and scalability of vertical federated learning, effectively reduces communication and computing overhead, adapts to the resource utilization of devices with different capabilities, and ensures the accuracy of the global model.
Smart Images
Figure CN121235033B_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of deep learning technology, and more specifically, to a vertical federated learning training method, system, application, terminal, and medium. Background Technology
[0002] With increasingly stringent data privacy regulations such as the General Data Protection Regulation (GDPR), federated learning, which enables joint modeling while protecting raw data from leaving the local environment, has emerged as a new distributed machine learning paradigm to meet privacy compliance requirements. Based on the differences in data distribution in the real world, federated learning is mainly divided into two branches: horizontal and vertical. Vertical federated learning (VFL) was proposed to address a highly challenging scenario: multiple organizations from different fields serve the same user group, thus possessing different dimensions of user characteristics, forming "data silos." For example, in the field of autonomous driving, an automaker possesses massive amounts of sensor data (such as camera and LiDAR data) generated by test vehicles during operation, while a high-precision map service provider holds detailed 3D geographic environment and road structure information of the routes these vehicles travel. VFL allows these organizations to jointly build a more powerful environmental perception or driving decision-making model without exchanging their respective private core data.
[0003] While vertical federated learning effectively breaks down data barriers between industries, its unique training paradigm also brings serious system efficiency issues. During training, participants frequently need to exchange high-dimensional intermediate feature representations and gradients within the network, which undoubtedly generates significant communication overhead. Simultaneously, performing forward and backward propagation of the model locally on each client also poses a significant challenge to their computational resources. Therefore, low-bit training techniques have been introduced as a key optimization path. This technique, by using low-bit-width integers instead of traditional 32-bit floating-point numbers throughout the training process, not only compresses the amount of data to be transmitted by several times, significantly reducing communication latency, but also leverages the efficient support of modern hardware for integer operations, greatly reducing the complexity of local computation and device power consumption.
[0004] Despite the promising prospects of low-bit training, existing technical approaches still have their own bottlenecks, which can be broadly categorized into three types: Using low-bit floating-point format: This method can maintain model accuracy relatively well, but due to the limited acceleration of floating-point operations in hardware, its effect on reducing computational latency is not as significant as integer quantization. Performing full integer quantization on the network: Although this method can compress data to the greatest extent and accelerate computation, its "one-size-fits-all" strategy usually leads to a significant degradation in model performance. Quantizing only a portion of fixed layers (such as convolutional layers): This selective strategy achieves a certain balance between performance and efficiency, but its static quantization scheme ignores the dynamic changes in the model's sensitivity to quantization errors at different training stages and at different layers in the network, thus failing to achieve the optimal trade-off between efficiency and accuracy. Summary of the Invention
[0005] To address the aforementioned shortcomings in the prior art, this invention provides a vertical federated learning training method, system, application, terminal, and medium.
[0006] According to one aspect of the present invention, a longitudinal federated learning training method is provided, comprising:
[0007] Multiple clients obtain local feature embeddings through their respective local models;
[0008] The server trains a global fusion network based on the local feature embedding and pre-set label data, obtains the back-transmitted gradient, and generates quantized configuration parameters through an intelligent agent decision-making process.
[0009] The server distributes the backpropagation gradient and the quantization configuration parameters to the corresponding clients, driving the clients to update their local models based on the backpropagation gradient and the quantization configuration parameters, thus completing the longitudinal federated learning training.
[0010] Preferably, the method for constructing the intelligent agent includes:
[0011] An initial neural network is constructed and trained using a deep Q-learning self-demonstration algorithm;
[0012] Construct a state space for the initial trained neural network, where the state includes at least: time step, current model layer bit width, quantization error of each layer, and historical bit width change time information;
[0013] Construct an action space for the initial trained neural network, where the action terms include: maintaining bit width, increasing weight bit width, increasing activation bit width, and increasing gradient bit width;
[0014] A reward function is set for the initial neural network after training, where the reward is calculated by multiplying the total system efficiency index and the global model accuracy index;
[0015] Based on this, the initial neural network, which has constructed a state space and an action space and has set a reward function, is identified as an intelligent agent.
[0016] Preferably, the client updates the local model based on the returned gradient and the quantization configuration parameters, including:
[0017] Using the backpropagation gradient received from the server, perform local backpropagation to update the local model;
[0018] The local model's weights, gradients, and activation bit widths are configured using low-bit integer quantization, and forward training is completed under the constraints of the quantization configuration parameters to generate local feature embeddings under this low-bit configuration.
[0019] Each client's local model differs in network structure, depth, or width to adapt to its own computing resources.
[0020] Preferably, in updating the local model on the client side, the quantization configuration parameters adjust the layer bit width of the local model to achieve constraints; wherein:
[0021] The server distributes the quantization configuration parameters to the corresponding data nodes;
[0022] If the quantization error of each level in the current local model is greater than or equal to the quantization error threshold, then increase at least one of the weight bit width, activation bit width and gradient bit width of the initialized training node.
[0023] If the time step reaches the preset step adjustment threshold, the activation bit width and gradient bit width will be increased.
[0024] If the time interval between the current time and the last bit width change in the historical model level bit width change time information is greater than or equal to the preset time interval threshold, then increase at least one of the activation bit width and gradient bit width.
[0025] According to a second aspect of the present invention, a longitudinal federated learning training system is provided, comprising: a feature extraction module and a model update module deployed on a local client, a global fusion module and an agent module deployed on a central server, and a communication module; wherein:
[0026] The feature extraction module is used to obtain local feature embeddings through a local model;
[0027] The model update module is used to update the local model based on the backpropagated gradient and quantization configuration parameters;
[0028] The global fusion module trains a global fusion network based on local feature embedding and pre-set label data to obtain the backpropagation gradient.
[0029] The intelligent agent module is used to generate quantitative configuration parameters through intelligent agent decision-making;
[0030] The communication module is used to embed and upload the local features to the central server, and distribute the returned gradient and the quantization configuration parameters to the corresponding local clients.
[0031] According to a third aspect of the present invention, a longitudinal federated learning training method for autonomous driving applications is provided, comprising:
[0032] The clients include automakers with vehicle sensor data, high-precision map service providers with structured road environment information, and / or traffic information service platforms.
[0033] The joint technology platform or cloud service provider used to integrate multi-source information for driving decision research will serve as the server side;
[0034] Multiple clients obtain local feature embeddings through their respective local models;
[0035] The server trains a global fusion network based on the local feature embedding and pre-set label data, obtains the back-transmitted gradient, and generates quantized configuration parameters through an intelligent agent decision-making process.
[0036] The server distributes the returned gradient and the quantization configuration parameters to the corresponding clients, driving the clients to update their local models based on the returned gradient and the quantization configuration parameters, thus completing the longitudinal federated learning training for autonomous driving.
[0037] According to a fourth aspect of the present invention, a computer terminal is provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, it can be used to perform the method described in any one of the above inventions, or to run the system described in the above inventions.
[0038] According to a fifth aspect of the present invention, a computer-readable storage medium is provided having a computer program stored thereon, which, when executed by a processor, can be used to perform the method described in any one of the above-described inventions, or to run the system described in the above-described inventions.
[0039] By adopting the above technical solution, the present invention has at least one of the following beneficial effects compared with the prior art:
[0040] The vertical federated learning training method, system, application, terminal, and medium provided by this invention employs heterogeneous local models and a vertical federated framework, solving the technical challenge of traditional federated learning where all participants must use the same, fixed model architecture. This challenge prevents the system from adapting to the uneven distribution of computing resources (computing power, memory) and data feature complexity (such as image resolution, feature dimension) among participants in the real world. The resulting technical benefits are: This invention allows each client to deploy differentiated local models, enabling nodes with strong computing power to use more complex models to extract richer features, while resource-constrained nodes can use lightweight models for training. This significantly improves the flexibility, scalability, and deployment practicality of the entire federated system, allowing more devices with different capabilities to join the federated network and achieving effective utilization of the network's heterogeneous resources.
[0041] This invention provides a vertical federated learning training method, system, application, terminal, and medium. Through a centralized agent and dynamic decision-making mechanism, it solves the technical problem of existing technologies that rely on static, preset hyperparameters (such as fixed quantization bit width and fixed model structure), making dynamic optimization impossible throughout the complex training process. Manually configuring these parameters is not only time-consuming and labor-intensive, but also makes finding the globally optimal balance point almost impossible. The resulting technical benefits are: By deploying an agent trained using a Deep Q-learning self-demonstration (DQfD) algorithm on the server side, this invention achieves end-to-end intelligent scheduling of the entire training process. This agent can automatically infer and execute optimal quantization configuration decisions based on the training stage, model performance, and other states. This gives the entire federated system adaptive optimization capabilities, achieving higher operating efficiency while maintaining model accuracy compared to static configuration.
[0042] The vertical federated learning training method, system, application, terminal, and medium provided by this invention, through comprehensive optimization of low-bit quantization and system efficiency, simultaneously solves two major efficiency bottlenecks in vertical federated learning: the high communication overhead caused by frequent interactions with high-dimensional intermediate representations (feature embedding, gradients), and the huge computational load when each client executes local model training. The resulting technical effects are: the intelligent agents of this invention can collaboratively adjust the quantization bit width used for local computation and network communication. By using a lower bit width in non-critical stages, the amount of transmitted data can be significantly compressed, reducing network bandwidth requirements; simultaneously, by using efficient integer operations instead of floating-point operations locally on the client, the training process is greatly accelerated and energy consumption is reduced.
[0043] The vertical federated learning training method, system, application, terminal, and medium provided by this invention solve the technical problems of high communication and computing overhead and rigid system architecture in existing vertical federated learning, which are difficult to adapt to heterogeneous client resources and data characteristics. While ensuring the accuracy of the global model, it effectively reduces the computing and communication overhead of the system and improves the training efficiency and deployment feasibility of vertical federated learning in real financial scenarios. Attached Figure Description
[0044] Other features, objects, and advantages of the present invention will become more apparent from the following detailed description of non-limiting embodiments with reference to the accompanying drawings:
[0045] Figure 1 This is a flowchart of the vertical federated learning training method in a preferred embodiment of the present invention.
[0046] Figure 2 This is a schematic diagram of the components of a longitudinal federated learning training system in a preferred embodiment of the present invention.
[0047] Figure 3 This is a schematic diagram illustrating the application of the longitudinal federated learning training method in autonomous driving, as shown in a specific application example of the present invention. Detailed Implementation
[0048] The embodiments of the present invention are described in detail below: These embodiments are implemented based on the technical solution of the present invention, and provide detailed implementation methods and specific operation processes. It should be noted that those skilled in the art can make several modifications and improvements without departing from the concept of the present invention, and these all fall within the protection scope of the present invention.
[0049] Existing vertical federated learning methods typically suffer from high communication and computational overhead, as well as rigid architectures that are difficult to adapt to heterogeneous client resources and data characteristics. To address these issues, one embodiment of this invention provides a vertical federated learning training method. This method is designed for data scenarios where samples have consistent labels but varying feature dimensions, and the client lacks labels. Through an end-to-end framework of "heterogeneous local model + vertical feature interaction + DQfD intelligent body width scheduling," it achieves comprehensive optimization of communication and computational resources while maintaining global accuracy, thereby improving the efficiency and practicality of vertical federated learning in complex environments.
[0050] Specifically, such as Figure 1 As shown, the longitudinal federated learning training method provided in this embodiment may include:
[0051] S100: Multiple clients obtain local feature embeddings through their respective local models;
[0052] S200: The server trains a global fusion network based on local feature embedding and pre-set label data, obtains the back-transmitted gradient, and generates quantized configuration parameters through a smart agent decision.
[0053] In S300, the server distributes the returned gradients and quantization configuration parameters to the corresponding clients, driving the clients to update their local models based on the returned gradients and quantization configuration parameters, thus completing the longitudinal federated learning training.
[0054] The vertical federated learning training method provided in this embodiment will be further described in detail below with reference to the preferred embodiment.
[0055] In this preferred embodiment, the provided longitudinal federated learning training method includes the following steps:
[0056] S1, multiple clients embed local features extracted by their respective local models;
[0057] S2, the central server receives local feature embeddings from at least two clients; the central server deploys a global fusion network and an agent and holds label data; the central server trains the global fusion network based on the local feature embeddings and label data to obtain the backpropagation gradient; the agent is used to make decisions to generate quantized configuration parameters;
[0058] In S3, the central server distributes the returned gradients and quantization configuration parameters to the corresponding clients, driving the clients to update their local models based on the returned gradients and quantization configuration parameters.
[0059] In the above steps,
[0060] The central server receives local feature embeddings extracted by each client through its local model from at least two clients, and the local models of at least two clients remain differentiated.
[0061] The central server deploys a globally converged network and intelligent agents, and holds tag data.
[0062] The central server trains the global fusion network based on local feature embeddings and label data, and generates backpropagation gradients.
[0063] The central server generates quantitative configuration parameters for the client based on intelligent agents;
[0064] The central server distributes the returned gradients and quantization configuration parameters to the corresponding clients, driving the clients to update their local models based on the returned gradients and quantization configuration parameters.
[0065] The client stores local data with sample IDs shared with other clients, but these data have different feature dimensions and lack label data.
[0066] The client uploads the feature embeddings output from the local model.
[0067] In some preferred embodiments, the construction of the agent in S2 above may further include:
[0068] S21. Construct the initial neural network and train it using a deep Q-learning self-demonstration algorithm.
[0069] S22, construct the state space for the initial neural network. The state space includes the time step, the current model layer bit width (weight bit width, activation bit width, gradient bit width), the quantization error of each layer in the current neural network, and the time information of the historical model layer bit width changes.
[0070] S23, construct the action space for the initial neural network. The action terms in the action space include maintaining bit width, increasing weight bit width, increasing activation bit width, and increasing gradient bit width.
[0071] S24, Set the reward function for the initial neural network. The reward function is obtained by calculating the product of the system's total efficiency index and the global model accuracy index.
[0072] S25, the initial neural network with its state space and action space already constructed and its reward function already set is identified as the agent.
[0073] In some preferred embodiments, in S24 above, the overall system efficiency index is calculated as follows: the baseline computation cost determined by the preset reference bit width is subtracted from the current total computation cost determined by the sum of the products of the current weight bit width and the current activation bit width of each client's local model, and the difference is then divided by the baseline computation cost. The result is the index value.
[0074] In some preferred embodiments, in S24 above, the global model accuracy index is calculated as follows: if the accuracy of the currently trained global fusion network is not lower than the baseline accuracy obtained by training with a preset reference bit width under the same training time step, then the global model accuracy index is a preset first value; otherwise, the global model accuracy index is a preset function value. The value of the function value decreases as the difference between the current global model accuracy and the baseline accuracy increases, i.e., it is inversely proportional. The proportionality coefficient is controlled by θ.
[0075] In some preferred embodiments, the above-mentioned S21, which uses a deep Q-learning self-demonstration algorithm for training, may further include:
[0076] S211, Obtain the expert sample dataset, which includes decision samples of the optimal system quantification configuration parameters corresponding to different system states;
[0077] S212, before interacting with the client, the agent is pre-trained based on the expert sample dataset and the supervised loss function preset according to the Deep Q-learning self-demonstration (DQfD) paradigm to obtain initial policy parameters for subsequent decision-making.
[0078] In some preferred embodiments, after the above-mentioned intelligent agent is constructed, it is deployed to a central server for decision-making to generate quantitative configuration parameters, including:
[0079] S261, At the start of training, the central server distributes a set of initial quantization configuration parameters to all clients. These initial quantization configuration parameters set the local computing bit width and communication channel bit width of each client to a preset initial low bit width.
[0080] In S262, during the preset decision cycle in the training process, the agent on the central server obtains the current global system state vector, including the time step, the current local model and global fusion network layer bit width, the quantization error of each layer, and historical bit width change time information. Based on the decision strategy trained by the agent, it infers and generates a set of updated quantization configuration parameters.
[0081] The central server distributes the updated system configuration parameters to the corresponding data nodes to constrain model training.
[0082] In some preferred embodiments, the above constraints are achieved by the client adjusting the bit width of the model layer based on quantization configuration parameters, and may further include:
[0083] If the quantization error of each layer in the current neural network is greater than or equal to the quantization error threshold, then increase at least one of the weight bit width, activation bit width and gradient bit width of the initial node to be trained.
[0084] If the time step reaches the preset step adjustment threshold, the activation bit width and gradient bit width will be increased.
[0085] If the current time and the historical model hierarchical bit width change time information are the last
[0086] If the time interval of the second bit width change is greater than or equal to the preset time interval threshold, then increase at least one of the activation bit width and gradient bit width.
[0087] In some preferred embodiments, the process of updating the local model by the client based on the returned gradient and quantization configuration parameters in S3 may further include:
[0088] S31, using the backpropagation gradient received from the central server, performs local backpropagation to update the local model;
[0089] S32, the local training process of each client is based on low-bit integer quantization, including low-bit configuration of weights, gradients and activation bit widths. Forward training is completed under the constraints of quantization configuration parameters, and local feature embeddings (forward intermediate activations) are generated and uploaded under this low-bit configuration.
[0090] In the above steps, the local models of each client differ in network structure, depth, or width to adapt to the computing resources of each client. The local models of each client are differentiated in the following ways: the local model network structure, depth, or width of each client's local model are different to adapt to its computing resources; the local feature embedding dimension output by each client's local model is different to adapt to its local image feature dimension; the local training process of the client is based on low-bit integer quantization, including low-bit configuration of weights, activations, and gradients, and forward training is completed under the constraints of quantization configuration parameters, thereby generating and uploading local feature embeddings under this low-bit configuration.
[0091] In the above steps, the client applies constraints based on quantization configuration parameters and adjusts the bit width of the model layers. This includes: maintaining the client's current bit width, or increasing at least one of the following: weight bit width, activation bit width, and gradient bit width, preferably increasing them incrementally to the target bit width in a monotonically increasing manner. Specifically, when the quantization error of each layer in the current neural network is not less than the quantization error threshold, at least one of the weight bit width, activation bit width, or gradient bit width is increased; when the time step reaches a preset step size adjustment threshold, the activation bit width and / or gradient bit width are increased; when the time interval between the current time and the last bit width change in the historical model layer bit width change time information is not less than a preset time interval threshold, the activation bit width and / or gradient bit width are increased.
[0092] Based on the same inventive concept, one embodiment of the present invention also provides a vertical federated learning training system.
[0093] Specifically, such as Figure 2 As shown, the vertical federated learning training system provided in this embodiment may include: a feature extraction module and a model update module deployed on a local client, a global fusion module and an agent module deployed on a central server, and a communication module; wherein:
[0094] The feature extraction module is used to obtain local feature embeddings from the local model;
[0095] The model update module is used to update the local model based on the backpropagated gradients and quantization configuration parameters.
[0096] The global fusion module trains a global fusion network based on local feature embeddings and pre-set label data to obtain backpropagation gradients;
[0097] The agent module is used to generate quantified configuration parameters through decision-making by an agent;
[0098] The communication module is used to embed and upload local features to the central server, and distribute the returned gradients and quantization configuration parameters to the corresponding local clients.
[0099] In some preferred embodiments, the above-mentioned intelligent agent module may further include:
[0100] The agent pre-training unit is used to pre-train the central agent based on an expert sample dataset before interacting with the client. The expert sample dataset contains decision samples with different system states and corresponding bit width configurations. The pre-training adopts a large-margin supervised loss of the deep Q-learning self-demonstration (DQfD) paradigm to obtain initial policy parameters that can be deployed online.
[0101] The agent decision unit, used by the central agent, outputs discrete actions based on the state vector. Action types include maintaining bit width, increasing weight bit width, increasing activation bit width, and increasing gradient bit width. The module generates corresponding quantization configuration parameters and distributes them to the communication module to guide each client in conducting local low-bit training.
[0102] In some preferred embodiments, the global fusion module may further include:
[0103] The central server uses local feature embeddings and server-side label data received from the communication module to train the global fusion network in both forward and backward directions, and generates backpropagation gradients by slicing the data according to the client dimension.
[0104] In some preferred embodiments, the model update module may further include:
[0105] The client performs local low-bit training based on the received back-transmitted gradients and quantization configuration parameters: it performs forward computation on the weights, activations, and gradients of the local model using low-bit configuration, generates and uploads local feature embeddings (forward intermediate activations), and adaptively maintains model heterogeneity and updates parameters according to the network structure, depth or width of the differentiated local model and the dimensions of local image features.
[0106] In some preferred embodiments, the communication module may further include:
[0107] Establish a vertical federated data communication channel between the central server and at least two clients, responsible for: receiving the local feature embeddings from the clients; and sending the back gradients and quantization configuration parameters calculated by the central server to the clients.
[0108] It should be noted that the steps in the method provided by the present invention can be implemented using the corresponding components in the system. Those skilled in the art can refer to the technical solution of the system to implement the steps of the method, and can also refer to the technical solution of the method to implement the composition of the system. That is, the embodiments in the system and the embodiments in the method can be understood as preferred examples of each other, which will not be elaborated here.
[0109] The longitudinal federated learning training method and system provided in the above embodiments of the present invention employ differentiated local models by each client based on its computing resources and data characteristics, extracts and embeds local features, and uploads them in low-bit quantization form. The central server holds labels, deploys a global fusion network for forward and backward training, and generates backpropagation gradients for each client. Simultaneously, the central server deploys an agent trained by deep Q-learning self-demonstration (DQfD) to perceive the global system state (including time progress, current model layer bit width, quantization error, and historical bit width change information), outputs quantization configuration parameters online, and monotonically adjusts the weight bit width, activation bit width, and gradient bit width of the clients to dynamically balance communication and computational overhead with global model accuracy.
[0110] An embodiment of the present invention also provides a computer terminal, including a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, it can be used to execute any of the methods in the above embodiments of the present invention, or to run any of the systems in the above embodiments of the present invention.
[0111] Optionally, the memory is used to store programs; the memory may include volatile memory, such as random-access memory (RAM), such as static random-access memory (SRAM), double data rate synchronous dynamic random-access memory (DDR SDRAM), etc.; the memory may also include non-volatile memory, such as flash memory. The memory is used to store computer programs (such as application programs, functional modules, etc. that implement the above methods), computer instructions, etc., and the aforementioned computer programs, computer instructions, etc., can be partitioned and stored in one or more memories. Furthermore, the aforementioned computer programs, computer instructions, data, etc., can be accessed by the processor.
[0112] A processor is used to execute computer programs stored in memory to implement the various steps of the methods or various modules of the systems involved in the above embodiments. For details, please refer to the relevant descriptions in the preceding method and system embodiments.
[0113] The processor and memory can be separate structures or integrated structures. When the processor and memory are separate structures, they can be coupled together via a bus.
[0114] An embodiment of the present invention also provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, can be used to perform the method of any of the above embodiments of the present invention, or to run the system of any of the above embodiments of the present invention.
[0115] Computer-readable media include computer storage media and communication media, wherein communication media include any medium that facilitates the transfer of computer programs from one place to another. Storage media can be any available medium accessible to a general-purpose or special-purpose computer. An exemplary storage medium is coupled to a processor, enabling the processor to read information from and write information to the storage medium. Of course, the storage medium can also be a component of the processor. The processor and storage medium can reside in an ASIC. Alternatively, the ASIC can reside in a user device. Of course, the processor and storage medium can also exist as discrete components in a communication device.
[0116] The technical solution provided by the above embodiments of the present invention will be further described in detail below with reference to a specific application example.
[0117] Figure 3 This is a schematic diagram of the working architecture of the technical solution provided in the above embodiments of the present invention in a specific application example.
[0118] like Figure 3 As shown, the system architecture includes a central server and at least two clients, which communicate with each other via a network. The vertical federated learning training method provided in the above embodiments of the present invention is executed in this architecture.
[0119] Clients (e.g., in autonomous driving applications, this could be an automaker with vehicle sensor data and a high-precision map service provider with structured road environment information) each store local data with shared sample IDs, but their feature dimensions differ and they lack label fields. Each client deploys a local model, and these local models can remain differentiated to adapt to their own computing resources and data characteristics. Their responsibilities include: extracting local feature embeddings using the local model, uploading the local feature embeddings to the central server, receiving the returned gradients and quantization configuration parameters distributed by the central server, and updating the local model accordingly.
[0120] A central server (e.g., in the aforementioned autonomous driving application, this could be a joint technology platform or cloud service provider responsible for integrating multi-source information for driving decision research) holds the label data corresponding to the client sample IDs and deploys a global fusion network and agents. Its responsibilities include: receiving local feature embeddings uploaded by each client, training the global fusion network and generating feedback gradients, generating quantized configuration parameters based on the agent's decisions, and finally distributing the feedback gradients and quantized configuration parameters to each client.
[0121] Indicatively, this application example implements dynamic quantization configuration for the entire vertical federated learning system through an agent deployed on a central server. This technical solution allows each client to maintain local model differentiation to adapt to the uneven resource distribution among participants in real-world scenarios. By dynamically adjusting the quantization bit width, the communication and computational overhead during the interaction process is significantly reduced while ensuring the accuracy of the global model, thereby alleviating the problems of high computational and communication overhead and rigid architecture in traditional VFL solutions.
[0122] First, it should be noted that this application example uses a low-bit training method: during training, weights, activations, and gradients are represented using low-bit integers; before forward computation into convolutional or linear layers, weights and activations are quantized; during backward computation, gradients are symmetrically quantized and backpropagation is completed. The weight bit width, activation bit width, and gradient bit width are all implemented using low-bit training and dynamically configured by the agent.
[0123] The workflow of this application instance includes the following steps:
[0124] The central server receives local feature embeddings from each client. Specifically, each client uses its own local model for forward propagation to extract local feature embeddings. The local models remain differentiated: each client's local model differs in network structure, depth, or width to adapt to its respective computing resources; and the dimensions of the local feature embeddings output by each client's local model can differ to adapt to the dimensions of its local image features.
[0125] The central server performs global training based on local feature embeddings, and the agent generates quantization configuration parameters. Specifically, the central server inputs the received local feature embeddings into the global fusion network, calculates the loss in combination with the held label data, trains the global fusion network, and generates backpropagation gradients; at the same time, the agent deployed on the central server decides to generate quantization configuration parameters for the next round of training based on the current system state.
[0126] The construction of the agent includes: First, constructing an initial neural network and specifying that it be trained using the Deep Q-learning from Demonstrations (DQfD) algorithm; second, constructing a state space for this initial neural network, which includes the time step, the current model layer bit width (i.e., the weight bit width, activation bit width, and gradient bit width of each client), the quantization error of each layer of the current neural network, and historical model layer bit width change time information; third, constructing an action space for this initial neural network, where actions include maintaining bit width, increasing weight bit width, increasing activation bit width, and increasing gradient bit width, which act on the local quantization configuration of one or more clients; in addition, setting a reward function for this initial neural network, which is determined by the product of the computational efficiency index and the global model accuracy index; finally, the initial neural network with the above elements configured is determined as the agent.
[0127] The reward function is determined as follows: Regarding the computational efficiency index, the baseline computational cost determined by the preset reference bit width (e.g., all INT8) is subtracted from the current total computational cost determined by the sum of the products of the current weight bit width and the current activation bit width of each client's local model, and the difference is then divided by the baseline computational cost; Regarding the global model accuracy index, if the global model accuracy obtained from the current training is not lower than the baseline accuracy obtained by training with the preset reference bit width under the same training time step, then a preset first value is taken; otherwise, a preset function value is taken, which decreases as the difference between the current global model accuracy and the baseline accuracy increases.
[0128] The training process of the agent includes: First, acquiring an expert sample dataset, which includes quantized configuration decision samples corresponding to different system states; Second, conducting a pre-training phase before interactive training with the client, training the agent based on the expert sample dataset and a preset DQfD paradigm supervised loss function to obtain initial policy parameters for subsequent decision-making.
[0129] The central server distributes the returned gradients and quantization configuration parameters to the clients, which then update their local models accordingly. Specifically, after training, the agents are deployed to the central server to periodically adjust the local quantization configuration parameters of each client during subsequent federated learning processes. These adjustments include maintaining the client's current bit width, increasing the weight bit width, increasing the activation bit width, and increasing the gradient bit width. Upon receiving new quantization configuration parameters, each client adjusts its local quantizer settings and uses the received returned gradients to update its local model. This process is repeated until the global model converges.
[0130] Based on the above infrastructure, this specific application example applies the aforementioned vertical federated learning training technology to industrial autonomous driving scenarios. For multi-party data with shared sample IDs, it completes the trajectory intention prediction of surrounding dynamic targets (such as vehicles and pedestrians) without exchanging original features and labels, and outputs a scenario risk assessment for the driving planning and decision-making module to call (such as for risk ranking and emergency braking decisions).
[0131] In industrial autonomous driving scenarios, the system architecture may include a central server and at least three clients, with the clients communicating with the central server via a network. Vertical federated learning training methods are executed within this system architecture. Taking target trajectory prediction under multi-source fusion perception as an example, each client conducts collaborative training around a unified sample ID from the same spatiotemporal scene, while the central server maintains label data (the target's future true trajectory or behavior category, etc.) aligned with that sample ID.
[0132] Clients, such as car manufacturer A, high-precision map service provider B, and traffic information service platform C, each store local data with shared sample IDs with other clients, but their feature dimensions differ and they lack labeled data. Client A may hold vehicle camera images and LiDAR point cloud sequences; Client B may hold road topology and V2X communication data from high-precision maps; Client C may hold real-time traffic flow and weather data. Each client deploys a local model, and these local models can remain differentiated to adapt to their own computing resources and data characteristics. For example, Client A may use a 3D convolutional network to generate 128-dimensional feature embeddings, Client B may use a graph neural network to generate 96-dimensional feature embeddings, and Client C may use a temporal network (such as GRU) to generate 64-dimensional feature embeddings. Their main responsibilities are: to extract local feature embeddings using local models with low-bit configurations, to upload the quantized local feature embeddings to a central server, to receive the backpropagation gradients and quantization configuration parameters distributed by the central server, and to complete the backpropagation and update of the local model accordingly.
[0133] A central server (e.g., a trusted third-party platform or a joint technology platform) holds label data corresponding to client sample IDs and deploys a global fusion network and agents. Its main responsibilities are: receiving local feature embeddings uploaded by each client, training the global fusion network and generating backpropagation gradients, performing quantization configuration operations on clients based on agent decisions, and finally distributing the gradients and quantization configuration parameters to each client. Specifically, the central server first dequantizes the quantized embeddings uploaded by each client, then concatenates or aggregates the multi-source embeddings using attention-based methods, feeding them into the fusion network head to output the target trajectory coordinate sequence or intent category probability. The loss function can use cross-entropy with class weights to alleviate the sample imbalance problem in critical and dangerous scenarios of autonomous driving. After obtaining the gradients for each client's embeddings through backpropagation, the central server quantizes them according to the gradient bit width and distributes them.
[0134] This approach illustratively demonstrates how an agent deployed on a central server dynamically quantizes the entire vertical federated learning system. This method allows each client to maintain local model differentiation, adapting to the uneven distribution of resources and data among participants in real-world scenarios. By dynamically adjusting the quantization bit width, it significantly reduces communication and computational overhead during interaction while maintaining global model accuracy, alleviating the high communication and computational costs and rigid architecture issues of traditional vertical federated learning schemes. The bit width employs a monotonically increasing strategy, typically increasing from an initial four bits to six bits and then eight bits, and only applies to model levels that have not reached their upper limit.
[0135] This embodiment employs a low-bit training method: In forward propagation, before entering convolutional or linear layers, the weights and activations are quantized into low-bit integers according to their current bit widths, matrix operations under integer operators are performed, and then dequantized for propagation. In backward propagation, the gradient is symmetrically quantized according to its current gradient bit width before participating in backpropagation, and then dequantized again for parameter updates. The weight bit width, activation bit width, and gradient bit width are all implemented using low-bit training and dynamically configured by the agent. Quantization errors are statistically analyzed layer by layer and smoothed along the batch dimension for subsequent decision-making and threshold judgment.
[0136] The method includes the following steps: A central server receives local feature embeddings sent by each client. In one embodiment of this application, each client performs local forward propagation under the constraints of the current quantization configuration parameters, extracts local feature embeddings, quantizes the embeddings according to the activation bit width, and uploads them. The central server inputs the received local feature embeddings into the global fusion network, calculates the loss by combining them with the held label data, trains the global fusion network, and generates backpropagation gradients; simultaneously, within a preset decision period, the agent deployed on the central server generates quantization configuration parameters for the next round of training based on the current system state. The central server then distributes the backpropagation gradients and quantization configuration parameters to each client, and the client completes local backpropagation based on the gradients; when an update to the quantization configuration parameters is detected, the client updates the bit width and step size settings of the local quantizer and starts the next batch of training under the new configuration. This process is repeated until the global model converges.
[0137] In one embodiment of this application, the construction of the agent includes the following key points. First, an initial neural network is constructed as the agent, and a deep Q-learning self-demonstration algorithm is specified for training. Second, a state space is constructed for the agent, including: training time progress (e.g., normalized by epoch), current weight bit width, current activation bit width, current gradient bit width, weight quantization error after layer aggregation, moving average of activation quantization error and gradient quantization error, and the time interval of the most recent bit width change and a summary of historical changes. Third, an action space is constructed for the agent, including actions such as maintaining bit width, increasing weight bit width, increasing activation bit width, and increasing gradient bit width. These actions can be applied to all clients or a specified group of clients. Then, a reward function is set, where the reward is determined by the product of a computational efficiency index and a global model accuracy index. The computational efficiency index is given by the relative difference between the baseline computational cost and the current computational cost at a reference bit width (e.g., all 8 bits). The current computational cost is obtained by weighted summation of the multiplications of each layer of the local model on each client, multiplied by their weight bit widths and activation bit widths. The global model accuracy index is determined by comparing the current validation set accuracy with the baseline accuracy trained at the reference bit width at the same time step. If the current accuracy is not lower than the baseline, a preset first value is taken; otherwise, the difference between the two is penalized through a monotonically decreasing function. Finally, the initial neural network with the above state, action, and reward configurations is defined as the agent.
[0138] In one embodiment of this application, the training process of the agent includes: First, acquiring an expert sample dataset, which includes quantization configuration decision samples corresponding to different system states; the expert samples can be obtained by heuristic strategies and a small amount of offline search, for example, maintaining a low bit width in the early stage, prioritizing the increase of gradient or activation bit width when there is significant accuracy degradation or quantization error, and then appropriately increasing the weight bit width in the mid-to-late stage. Second, before interactive training with the client, a pre-training stage is performed. In this stage, the agent is trained only based on the expert sample dataset and a preset deep Q-learning self-demonstration supervised loss function to obtain initial policy parameters for subsequent decisions. After pre-training is completed, the agent is deployed on a central server, reads the current system state according to a preset decision cycle, outputs discrete actions and maps them to new quantization configuration parameters; the mapping follows a monotonic up-adjustment rule and a bit width upper limit constraint, only boosting channels that have not reached the upper limit and updating the quantization configuration parameters.
[0139] In one embodiment of this application, the parameter settings matching the autonomous driving task can be configured as follows without limitation: The initial bit width is set to four bits for weights, four bits for activation, and four bits for gradient, with an upper limit of eight bits and a step size of two bits; the decision cycle can be in units of several training rounds, for example, a decision can be made every two rounds; the quantization error threshold can be taken as about two percent, and the time step threshold and time interval threshold can be set according to the empirical stability of the validation set.
[0140] Through the above implementation methods, while ensuring the accuracy of the global model, the computational and communication overhead of the system is effectively reduced, and the training efficiency and deployment feasibility of vertical federated learning in real autonomous driving scenarios are improved.
[0141] The longitudinal federated learning training method, system, application, terminal, and medium provided in the above embodiments of the present invention are designed for data scenarios where samples have consistent identifiers but different feature dimensions, and clients do not possess labels. Each client employs a differentiated local model based on its computing resources and data characteristics, extracts and embeds local features, and uploads them in low-bit quantization form. The central server holds the labels, deploys a global fusion network for forward and backward training, and generates backpropagation gradients for each client. Simultaneously, the central server deploys an agent trained using Deep Q-learning self-demonstration (DQfD) to perceive the global system state (including time progress, current model layer bit width, quantization error, and historical bit width change information), outputs quantization configuration parameters online, and monotonically adjusts the client's weight bit width, activation bit width, and gradient bit width to dynamically balance communication and computational overhead with global model accuracy. The system consists of modules for communication, agent pre-training, fusion network training, agent decision-making, and client training; the program stored in the storage medium is executed by the processor to implement the above steps. This invention utilizes an end-to-end framework of "heterogeneous local model + vertical feature interaction + DQfD intelligent body width scheduling" to achieve comprehensive optimization of communication and computing resources while ensuring global accuracy, thereby improving the efficiency and practicality of vertical federated learning in complex environments.
[0142] Any matters not covered in the above embodiments of the present invention are well-known in the art.
[0143] The specific embodiments of the present invention have been described above. It should be understood that the present invention is not limited to the specific embodiments described above, and those skilled in the art can make various modifications or variations within the scope of the claims, which do not affect the essence of the present invention.
Claims
1. A vertical federated learning training method, characterized in that, include: Multiple clients obtain local feature embeddings through their respective local models; The server trains a global fusion network based on the local feature embedding and pre-set label data, obtains the back-transmitted gradient, and generates quantized configuration parameters through an intelligent agent decision-making process. The server distributes the backpropagation gradient and the quantization configuration parameters to the corresponding client, driving the client to update the local model according to the backpropagation gradient and the quantization configuration parameters, thus completing the longitudinal federated learning training. The client updates its local model based on the returned gradient and the quantization configuration parameters, including: Using the backpropagation gradient received from the server, perform local backpropagation to update the local model; The local model's weights, gradients, and activation bit widths are configured using low-bit integer quantization, and forward training is completed under the constraints of the quantization configuration parameters to generate local feature embeddings under this low-bit configuration. Each client's local model differs in network structure, depth, or width to adapt to the client's respective computing resources. In updating the local model on the client side, the quantization configuration parameters adjust the layer bit width of the local model to achieve constraints; wherein: The server distributes the quantization configuration parameters to the corresponding data nodes; If the quantization error of each level in the current local model is greater than or equal to the quantization error threshold, then increase at least one of the weight bit width, activation bit width and gradient bit width of the initial node to be trained. If the time step reaches the preset step adjustment threshold, the activation bit width and gradient bit width will be increased. If the time interval between the current time and the last bit width change in the historical model level bit width change time information is greater than or equal to the preset time interval threshold, then increase at least one of the activation bit width and gradient bit width.
2. The vertical federated learning training method according to claim 1, characterized in that, The method for constructing the intelligent agent includes: An initial neural network is constructed and trained using a deep Q-learning self-demonstration algorithm; Construct a state space for the initial trained neural network, where the state includes at least: time step, current model layer bit width, quantization error of each layer, and historical bit width change time information; Construct an action space for the initial trained neural network, where the action terms include: maintaining bit width, increasing weight bit width, increasing activation bit width, and increasing gradient bit width; A reward function is set for the initial neural network after training, where the reward is calculated by multiplying the overall system efficiency index and the global model accuracy index; Based on this, the initial neural network, which has constructed a state space and an action space and has set a reward function, is identified as an intelligent agent.
3. The vertical federated learning training method according to claim 2, characterized in that, The training of the initial neural network using a deep Q-learning self-demonstration algorithm includes: Obtain an expert sample dataset, which includes decision samples of optimal system configuration parameters corresponding to different system states; Before interacting with the client, the initial neural network is pre-trained based on the expert sample dataset and the pre-defined supervised loss function according to the deep Q-learning self-demonstration model. The method for calculating the overall system efficiency index includes: The total system efficiency index is obtained by subtracting the current total computation cost, which is determined by the sum of the products of the current weight bit width and the current activation bit width of each client's local model, from the baseline computation cost determined by the preset reference bit width. The difference is then divided by the baseline computation cost. The method for calculating the global model accuracy index includes: If the accuracy of the global fusion network obtained from the current training is not lower than the baseline accuracy obtained by training with a preset reference bit width under the same training time step, then the global model accuracy index is a preset first value; otherwise, the global model accuracy index is a preset function value, and the value of the function value is inversely proportional to the difference between the current global model accuracy and the baseline accuracy.
4. The vertical federated learning training method according to claim 1, characterized in that, The process of generating quantitative configuration parameters through decision-making by an intelligent agent includes: At the start of training, the server distributes a set of initial quantization configuration parameters to all clients. These initial quantization configuration parameters set the local computing bit width and communication channel bit width of each client to a preset initial low bit width. During the preset decision cycle in the training process, the agent on the server side obtains the current global system state vector, including the time step, the current local model and global fusion network layer bit width, the quantization error of each layer and the historical bit width change time information, and infers and generates a set of updated quantization configuration parameters based on the decision strategy trained by the agent.
5. A vertical federated learning training system, characterized in that, include: The system comprises a feature extraction module and a model update module deployed on the local client, a global fusion module and an agent module deployed on the central server, and a communication module; among which: The feature extraction module is used to obtain local feature embeddings through the local model; The model update module is used to update the local model based on the backpropagated gradient and quantization configuration parameters; The global fusion module trains a global fusion network based on local feature embedding and pre-set label data to obtain the backpropagation gradient. The intelligent agent module is used to generate quantitative configuration parameters through intelligent agent decision-making; The communication module is used to embed and upload the local features to the central server, and distribute the returned gradient and the quantization configuration parameters to the corresponding local clients; The model update module updates the local model based on the backpropagated gradients and quantization configuration parameters, including: Using the backpropagation gradient received from the server, perform local backpropagation to update the local model; The local model's weights, gradients, and activation bit widths are configured using low-bit integer quantization, and forward training is completed under the constraints of the quantization configuration parameters to generate local feature embeddings under this low-bit configuration. Each client's local model differs in network structure, depth, or width to adapt to the client's respective computing resources. In updating the local model on the client side, the quantization configuration parameters adjust the layer bit width of the local model to achieve constraints; wherein: The server distributes the quantization configuration parameters to the corresponding data nodes; If the quantization error of each level in the current local model is greater than or equal to the quantization error threshold, then increase at least one of the weight bit width, activation bit width and gradient bit width of the initial node to be trained. If the time step reaches the preset step adjustment threshold, the activation bit width and gradient bit width will be increased. If the time interval between the current time and the last bit width change in the historical model level bit width change time information is greater than or equal to the preset time interval threshold, then increase at least one of the activation bit width and gradient bit width.
6. A longitudinal federated learning training method for autonomous driving applications, characterized in that, include: The clients include automakers with vehicle sensor data, high-precision map service providers with structured road environment information, and / or traffic information service platforms. The joint technology platform or cloud service provider used to integrate multi-source information for driving decision research will serve as the server side; Multiple clients obtain local feature embeddings through their respective local models; The server trains a global fusion network based on the local feature embedding and pre-set label data, obtains the back-transmitted gradient, and generates quantized configuration parameters through an intelligent agent decision-making process. The server distributes the returned gradient and the quantization configuration parameters to the corresponding client, driving the client to update the local model according to the returned gradient and the quantization configuration parameters, thus completing the longitudinal federated learning training for autonomous driving. The client updates its local model based on the returned gradient and the quantization configuration parameters, including: Using the backpropagation gradient received from the server, perform local backpropagation to update the local model; The local model's weights, gradients, and activation bit widths are configured using low-bit integer quantization, and forward training is completed under the constraints of the quantization configuration parameters to generate local feature embeddings under this low-bit configuration. Each client's local model differs in network structure, depth, or width to adapt to the client's respective computing resources. In updating the local model on the client side, the quantization configuration parameters adjust the layer bit width of the local model to achieve constraints; wherein: The server distributes the quantization configuration parameters to the corresponding data nodes; If the quantization error of each level in the current local model is greater than or equal to the quantization error threshold, then increase at least one of the weight bit width, activation bit width and gradient bit width of the initial node to be trained. If the time step reaches the preset step adjustment threshold, the activation bit width and gradient bit width will be increased. If the time interval between the current time and the last bit width change in the historical model level bit width change time information is greater than or equal to the preset time interval threshold, then increase at least one of the activation bit width and gradient bit width.
7. A computer terminal, comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the computer program, it can be used to perform the method of any one of claims 1-4 or 6, or to run the system of claim 5.
8. A computer-readable storage medium having a computer program stored thereon, characterized in that, When executed by a processor, the computer program can be used to perform the method of any one of claims 1-4 or 6, or to run the system of claim 5.