Computation and Communication Efficient Lightweighting Vertical Federated Learning
Abstract
The exploration of computational and communication efficiency within Federated Learning (FL) has emerged as a prominent and crucial field of study. While most existing efforts to enhance these efficiencies have focused on Horizontal FL, the distinct processes and model structures of Vertical FL preclude the direct application of Horizontal FL-based techniques. In response, we introduce the concept of Lightweight Vertical Federated Learning (LVFL), targeting both computational and communication efficiencies. This approach involves separate lightweighting strategies for the feature model, to improve computational efficiency, and for feature embedding, to enhance communication efficiency. Moreover, we establish a convergence bound for our LVFL algorithm, which accounts for both communication and computational lightweighting ratios. Our evaluation of the algorithm on a image classification dataset reveals that LVFL significantly alleviates computational and communication demands while preserving robust learning performance. This work effectively addresses the gaps in communication and computational efficiency within Vertical FL.
Index Terms:
Federated Learning, Model PruningI Introduction
Federated learning (FL) is a distributed machine learning paradigm that enables a set of clients with decentralized data to collaborate and learn a shared model under the coordination of a centralized server. In FL, data is stored on edge devices in a distributed manner, which reduces the amount of data that needs to be uploaded and decreases the risk of user privacy leakage. The majority of prior research focuses on horizontal federated learning (HFL), where participants share the same feature space but have distinct sample spaces. There’s growing interest in vertical federated learning (VFL) in recent years. In VFL, clients possess different feature spaces but share a common sample space. An example of VFL implementation is Webank’s collaboration with an invoice company to construct financial risk models for enterprise customers [1]. In this context, both entities possess distinct user feature datasets that, due to information security concerns, cannot be shared or transmitted. During VFL training, each client develops a feature model, converting raw data features into a vector representation known as ‘feature embedding’. Instead of transmitting their feature models, clients in VFL send these feature embeddings to the server. The server then integrates these embeddings into a head model to determine the final loss. A typical workflow of VFL is illustrated in Fig. 1. Clearly, VFL’s methodology diverges from HFL, introducing its own set of unique challenges. Many of these challenges cannot be addressed merely by adapting solutions from HFL. There is a need for an independent approach to address the VFL problem.
During FL training, the diversity among clients results in variations in computational and communication capabilities, raising the need for synchronization solutions. While previous studies within HFL have addressed this, in HFL, local and global models are uniform due to identical feature spaces across clients, necessitating only local model pruning to meet specific client requirements. Conversely, in VFL, feature spaces differ among clients, leading to individual training on local feature models and subsequent uploading of trained feature embeddings to the server. This approach imposes distinct computational and communication demands for each client. Although prior research in VFL has examined feature embedding compression to reduce communication load [2, 3], the critical issue of computational burden has been largely neglected. Addressing this computational load is arguably a more pressing challenge for VFL deployment.
To tackle the diverse computational burdens encountered in the deployment of VFL, this paper introduces the concept of Lightweight Vertical Federated Learning (LVFL), designed to mitigate challenges in both computational and communication efficiency. The principal contributions of this study are summarized as follows: (1) This study introduces the LVFL framework, tailored to accommodate the varied communication and computation capabilities of heterogeneous workers. LVFL dynamically adjusts computational expenses for training feature models and communication costs for updating feature embeddings, ensuring efficiency across diverse system architectures. (2) We establish the comprehensive convergence analysis of the LVFL algorithm and present the convergence bound that elucidates the relationship between the cumulative feature model and feature embedding lightweighting error, as well as the communication and computation lightweighting ratio. (3) Our experiments, conducted on the CIFAR-10 dataset, validate the capability of the LVFL algorithm to adjust the computation and communication lightweighting ratio both constantly and dynamically. The proposed LVFL algorithm yields comparable test accuracy levels while significantly reduced communication and computation burden.
The rest of this paper is organized as follows. In Section II, we discuss related works on VFL and model pruning. Section III presents the system model and formulates the learning objective. In Section IV, we introduce the detail of LVFL algorithm. Section V presents the convergence analysis of LVFL. The experimental results of LVFL are presented in Section VI. Finally, Section VII concludes the paper. The theoretical proof details are accessible in the online supplementary material with the following link: https://github.com/ystex/LVFL/tree/main.
II Related Work
In recent years, VFL has attracted significant attention. The concept of Federated Learning with vertically partitioned data was introduced in [4]. Comprehensive surveys on VFL have been presented in [5, 6, 7]. However, VFL, distinct from HFL, poses its own set of challenges. Some research, such as [8, 9], aims to optimize data utilization to enhance the joint model’s effectiveness in VFL. In contrast, studies like [10] focus on implementing privacy-preserving protocols to counter potential data leakage threats. Beyond these challenges, there has been exploration into improving training efficiency in VFL. These endeavors primarily target reducing communication overhead, either by allowing participants to conduct multiple local updates in each iteration [11, 12] or by compressing the data exchanged between parties [13, 2]. While these studies primarily emphasize reducing communication overhead, a gap in these studies is the oversight of computational efficiency as a means to enhance training efficiency.
Modern DNNs often comprise tens of millions of parameters [14]. Storing and training such highly parameterized models on resource-constrained devices within FL can be challenging. Therefore, the lightweighting of models during training is an indispensable topic [15]. Considering the diverse computational capabilities of training devices, a viable strategy involves dynamically adjusting the size of the local model and diminishing its parameters, primarily via model pruning. Generally, model pruning techniques fall into two categories: unstructured pruning [16, 17] and structured pruning [18, 19, 20]. Unstructured pruning eliminates non-essential weights, specifically the inter-neuronal connections, in neural networks, resulting in significant parameter sparsity [21]. However, the ensuing sparse matrix’s irregularity poses challenges in parameter compression in memory, requiring specialized hardware or software libraries for efficient training [22]. In contrast, structured pruning aims to discard redundant model structures, like convolutional filters [19], without introducing sparsity. Consequently, the derived model can be considered as a subset or sub-configuration of the initial neural network, encompassing fewer parameters, thereby facilitating a reduction in computation overhead.
While a substantial portion of model pruning research centers on centralized learning contexts, recent studies have ventured into its application within FL settings [23, 24]. The work in [23] presents PruneFL, an adaptive FL strategy that commences with initial pruning at a selected client and continues with subsequent pruning throughout the FL process, aiming to reduce both communication and computational overheads. The research outlined in [24] introduces FedMP, a framework that employs adaptive pruning and recovery techniques to enhance both communication and computation efficiency, leveraging a multi-armed bandit algorithm for the selection of pruning ratios. Notably, the aforementioned model pruning techniques predominantly originate from HFL scenarios. However, due to the inherent differences between HFL and VFL, these techniques cannot be seamlessly applied to the VFL setting. Therefore driving the motivation for our study on model and feature embedding pruning in the VFL scenarios.
III System Model
To begin, we define several foundational concepts of the VFL. The VFL system consists of clients and a central server. The dataset, denoted as , has representing the total data samples and indicating the number of features. The row indexed by in x corresponds to a data sample . Each sample, , possesses a unique set of features, retained by client , and identified as a distinct subset. Every instance is paired with a label . The vector represents all sample labels. Client maintains a dataset of local features, , with denoting the number of features for client and -th row signifying the respective features . In this context, we assume that both the server and all clients retain a copy of the labels y, consistent with previous studies.
Each client, represented by has a unique set of feature model parameters, . The server maintains the head model, . The function denotes the feature embedding extracted from sample by client . This feature embedding operation transforms the high-dimensional raw data into a lower-dimensional representation through multiple layers of DNN, effectively capturing essential information from the input data while significantly reducing its dimension. The overall model’s parameters are collectively denoted as . We can then express the learning objective as minimizing the subsequent equation:
(1) |
where denotes the loss function for a single data sample. Within the server model framework, the equation consistently applies. To enhance clarity and ensure consistency in notation throughout this paper, we implement several simplifications in our subsequent discussions. Firstly, the feature embedding for dataset , is represented by , which we frequently abbreviate to . Secondly, we allocate to denote the head model in FC, where for convenience. Finally, we often represent , particularly in the subsequent algorithm details and convergence analysis. In the following section, we will elaborate on the specific algorithmic workflow of LVFL.
IV Lightweighting Vertical Federated Learning
In this section, we introduce the detail of LVFL algorithm. Considering the unique structural attributes of VFL, where computational demands are determined by the model size and communication requirements correlate with feature embedding size, the lightweighting methods derived from HFL are not directly applicable to VFL. To tackle this limitation, we adopt a progressive structured pruning strategy tailored for each client’s feature model and a unstructured pruning strategy tailored for each client’s feature embedding. Those approach is guided by the distinct computational and communication capacities of each client. Through these pruning techniques, we ensure consistent synchronization among all clients and facilitate efficient updates to the server.
In this scenario, we introduce a dual lightweighting ratio mechanism to distinctly optimize computation and communication. We denote as the computation lightweighting ratio and as the communication lightweighting ratio. A higher implies reduced demand for CPU cycles when processing a data sample. Correspondingly, a larger signifies a reduced need for embedding size during uploads. Suppose that each client performs local iterations before transmitting the model to the server, and the training process spans over a total of rounds, resulting in a cumulative duration of local iterations. Algorithm 1 showcases the workflow of LVFL, integrating the dual lightweighting ratio mechanism.
During each global round, when , every client will decide the unstructured pruned feature embedding based on the communication lightweighting ratio (Line 5), and then transmit this pruned feature embedding to the server for the global update (Line 6). Once the server has gathered all embeddings, it proceeds to get the model representation . Subsequently, it distributes the model representation to all clients (Lines 8-9), and is the start of the most recent global round when embeddings were shared. After receiving the model representation, each client needs to prune the feature model according to its computation lightweighting ratio (Line 11). Following this, each client will engage in rounds of local iterations using both the pruned embeddings received during iteration and its own unpruned embedding . The collection of embeddings from other clients, excluding client , is represented as , and all embeddings are collectively denoted as . During each local iteration, client will update the feature model using mini-batch SGD with step size (Lines 15-16).
We utilize an element-wise product to express the pruned feature model and feature embedding. Specifically, the pruned feature model can be represented as , where denotes the original structure of client ’s local model without pruning, and signifies the mask vector, containing zeros for parameters in that are pruned. Similarly, for the pruned feature embedding, we express it as , where represents the initial embedding of client without pruning, and denotes the mask vector with zeros for parameters in that have been pruned. During each global round, the client’s feature model and feature embedding undergo adjustment based on the computation lightweighting ratio and the communication lightweighting ratio . Next we explain in detail how to prune feature model and feature embedding to achieve lightweight separately.
Feature Model Lightweighting. In the feature model, we adopt a structured model pruning method to adjust the feature model from to , guided by the computation lightweighting ratio . This approach is consistent with existing research. To simplify the model and avoid introducing layer-specific hyper-parameters, we apply a uniform pruning ratio across all layers, as suggested by previous studies [19]. Within each layer, filters or neurons are ranked based on their importance scores, and those with lower scores are pruned based on the predetermined lightweighting ratio. We recommend employing the norm to calculate these importance scores.
Feature Embedding Lightweighting. For feature embedding, we employ the unstructured model pruning method to refine the feature embedding from to , guided by the communication lightweighting ratio . This approach involves nullifying weights of the lowest absolute values to meet the pruning criteria. Although this method preserves the structure of the embedding, it substantially reduces communication costs by transmitting only the non-zero values.
Leveraging the aforementioned mechanism, clients can streamline both the feature model and feature embedding, directed by the parameters and . Our approach seeks to optimally diminish the model’s complexity based on demand. Nevertheless, given that structured pruning is applied to the feature model, it is imperative to reassess the necessity for further pruning of the feature model prior to the training begin of each global round. Conversely, for feature embedding, which utilizes unstructured pruning, no additional verification step is required. Subsequently, we elucidate the mechanism for determining the computation lightweighting ratio of the feature model in detail.
-
1.
If . Where denotes the maximum computation lightweighting ratio previously attained by client ’s feature model before global round . In this case further computation lightweighting is executed to meet the required lightweighting ratio for the current round.
-
2.
If . Since the computation lightweighting ratio has been attained, the existing feature model was sufficiently streamlined, negating the need for further lightweighting in the current round.
This iterative process is repeated until the training converges or until predetermined termination conditions are satisfied. The subsequent section will delve into the analysis of the convergence bound of the LVFL algorithm.
V Convergence Analysis
In this section, we will delve into the convergence analysis of our LVFL algorithm. To begin, we need to establish some notations and definitions that will be utilized in the subsequent discussion. Specifically, we will define two types of errors that arise from the lightweighting mechanisms: communication lightweighting error and computation lightweighting error.
Communication Lightweight Error: This error quantifies the degree to which the lightweighting feature embedding is an accurate approximation of the original feature embedding. It is mathematically expressed as . The squared communication lightweighting error from client at round is denoted as .
Computation Lightweight Error: This error assesses how closely the lightweighting feature model resembles the original feature model. It is defined as . The squared computation lightweighting error from client at round as .
Let be the stacked partial derivatives at iteration :
(2) |
Then the global model updates as: .
We define to be the set of embeddings that would be received by each client at iteration if no computation and communication lightweight error were applied: . Here we define be the set of embeddings from other parties , and we have . Our convergence analysis will utilize the following standard assumptions about the VFL.
Assumption 1 (Smoothness).
There exists positive constants and , such that for all , the objective function satisfies: and .
Assumption 2 (Bounded Hessian).
There exists positive constants for such that for all , the second partial derivatives of satisfy: . Where is the Frobenius norm of a matrix .
Assumption 3 (Bounded Embedding Gradients).
There exists positive constants for such that for all , the embedding gradients are bounded: .
Assumption 1 guarantees that the function’s slope changes smoothly without any sudden or drastic alterations. Assumption 2 controls the curvature of the function, preventing it from displaying extreme or erratic behavior. Assumption 3 manages the changes in the embedding, ensuring that they don’t result in severe fluctuations, thereby aiding in the stabilization of the learning process. With those assumptions, we can get the following Lemma.
Lemma 1.
The norm of the difference between the objective function value with computation and communication lightweighting and without computation and communication lightweighting is bounded as:
(3) |
Using Lemma 1, we can bound the effect of lightweighting errors in detail. Afterwards we can derive the Theorem 1:
Theorem 1.
Under Assumption 1-3, the average squared gradient over global rounds of the LVFL is bounded as:
(4) |
The proof can be found in Appendix -D of online supplementary materials. The convergence bound detailed above unveils several insights: The first term illustrates the difference between the initial and final models. The second term highlights the error stemming from the use of the lightweighting feature model, while the third term represents an error caused by lightweighting feature embedding. This analysis reveals that the primary elements influencing the bound are the errors related to communication lightweighting and computation lightweighting. In other words, a larger error will result in a greater bound in the end. To delve deeper into the connection between error and lightweighting ratios, we must turn to the subsequent additional assumptions.
Assumption 4 (Bounded Embedding and Model).
Positive constants and exist such that for , the following conditions are met: .
Assumption 5 (Lipschitz Continuous).
There also exists positive constants and , such that for the all and satisfies: .
Assumption 4 and Assumption 5 are required to build the connection between the lightweighting ratios and the lightweighting error. With these two assumptions, we are able to derive the subsequent result, referred to as Corollary 1.
Corollary 1.
Under Assumption 1-5, with the computation lightweighting ratio and communication lightweighting ratio , we can further obtain the following bound:
(5) |
The detailed proof for this result is located in Appendix -E within the online supplementary materials. As derived from Corollary 1, a key observation to emphasize is that the communication lightweighting error is governed by the communication lightweighting ratio , while the computation lightweighting error is influenced by the computation lightweighting ratio . As a result, higher lightweighting ratios tend to result in more lenient convergence bounds, whereas lower ratios lead to more stringent convergence bounds.
VI Experiment
In this section, we carry out experiments to assess the performance of LVFL. The experiments were run on an Ubuntu 18.04 machine with an Intel Core i7-10700KF 3.8GHz CPU and GeForce RTX 3070 GPU. Specifically, we explore the effectiveness of the algorithm we’ve proposed by utilizing the VFL-based datasets: CIFAR-10. Subsequently, we will provide detailed information about the datasets and the corresponding models used in the experiment.
CIFAR-10: CIFAR-10 is a dataset used for object classification in images. In a specific training setup, there are 4 parties involved, with each party responsible for a different quadrant of each image. The number of training data samples , and the batch size . Every party (client) utilizes VGG16 as feature model for training, while the server focuses on training a 3-layer fully connected networks (FCN) as head model.
In the experiment, the following approaches are used for performance comparison. No Lightweighting (NL), where no computational or communication lightweighting mechanisms are implemented. Computational Lightweighting Only (PL), applying solely computational lightweighting. Communication Lightweighting Only (ML), utilizing exclusively communication lightweighting. Lightweighting (L), incorporating both computational and communication lightweighting strategies to enhance efficiency. Next we first show the performance comparison of the above approaches with dynamic computational and communication lightweighting ratios.
VI-A Performance Comparison
This section presents the learning performance optimized for computational and communication efficiency. At each round each client will be assigned the computational lightweighting ratio and communication lightweighting ratio . These ratios are then applied to individually tailor the lightweighting process to each client’s unique requirements. For illustrative purposes, we assume a uniform set of ratios across all clients, with the specific values depicted in Fig. 2b. The learning performance associated with our approaches are illustrated in Fig. 2a, from which several key observations can be derived. Primarily, computational lightweighting exerts a more significant influence on learning performance compared to communication lightweighting. Notably, computational lightweighting results in a marked decrease in test accuracy at the point of implementation, followed by a gradual recovery. Furthermore, the frequency and intensity of computational lightweighting are directly proportional to its impact on test accuracy.
VI-B Effect of Ratio on Learning Performance
In this section we further investigate the effect of the choice of and on learning performance. Here we explore the effects of computation and communication separately. In the scenario of computational lightweighting, as depicted in Fig. 3a, adjustments to the feature model are made at with . The outcomes indicate that higher values result in more significant reductions in test accuracy, consequently necessitating a longer recovery period. In the context of communication lightweighting, as shown in Fig. 3b, varying communication lightweighting ratios were applied to the feature embedding. The findings illustrate that lower values are associated with quicker convergence rates, particularly noticeable within the range . However, the impact of communication lightweighting is not as substantial as that observed with computational lightweighting.
VII Conclusion
Our paper introduces the concept of Lightweight Vertical Federated Learning (LVFL). Owing to structural distinctions between VFL and HFL, algorithm design and convergence analysis for VFL-based lightweight challenges significantly differ. Our convergence proofs elucidate the correlation between convergence bounds and the ratios of communication and computational lightweighting. Furthermore, the section on experimental results underscores the benefits of employing lightweight mechanisms. In the subsequent research, we intend to extend LVFL to be a more practical problem. We plan to formulate a long-term optimization problem that accurately represents the computational and communication difficulties clients face throughout the training phase. This will facilitate the determination of optimal lightweighting ratios specifically.
References
- [1] Y. Liu, T. Fan, T. Chen, Q. Xu, and Q. Yang, “Fate: An industrial grade platform for collaborative learning with data protection,” Journal of Machine Learning Research, vol. 22, no. 226, pp. 1–6, 2021.
- [2] T. J. Castiglia, A. Das, S. Wang, and S. Patterson, “Compressed-vfl: Communication-efficient learning with vertically partitioned data,” in International Conference on Machine Learning. PMLR, 2022, pp. 2738–2766.
- [3] H. Wang and J. Xu, “Online vertical federated learning for cooperative spectrum sensing,” arXiv preprint arXiv:2312.11363, 2023.
- [4] S. Hardy, W. Henecka, H. Ivey-Law, R. Nock, G. Patrini, G. Smith, and B. Thorne, “Private federated learning on vertically partitioned data via entity resolution and additively homomorphic encryption,” arXiv preprint arXiv:1711.10677, 2017.
- [5] L. Yang, D. Chai, J. Zhang, Y. Jin, L. Wang, H. Liu, H. Tian, Q. Xu, and K. Chen, “A survey on vertical federated learning: From a layered perspective,” arXiv preprint arXiv:2304.01829, 2023.
- [6] K. Wei, J. Li, C. Ma, M. Ding, S. Wei, F. Wu, G. Chen, and T. Ranbaduge, “Vertical federated learning: Challenges, methodologies and experiments,” arXiv preprint arXiv:2202.04309, 2022.
- [7] Y. Liu, Y. Kang, T. Zou, Y. Pu, Y. He, X. Ye, Y. Ouyang, Y.-Q. Zhang, and Q. Yang, “Vertical federated learning,” arXiv preprint arXiv:2211.12814, 2022.
- [8] S. Feng, “Vertical federated learning-based feature selection with non-overlapping sample utilization,” Expert Systems with Applications, vol. 208, p. 118097, 2022.
- [9] Y. Kang, Y. Liu, and X. Liang, “Fedcvt: Semi-supervised vertical federated learning with cross-view training,” ACM Transactions on Intelligent Systems and Technology (TIST), vol. 13, no. 4, pp. 1–16, 2022.
- [10] J. Sun, Y. Yao, W. Gao, J. Xie, and C. Wang, “Defending against reconstruction attack in vertical federated learning,” arXiv preprint arXiv:2107.09898, 2021.
- [11] Y. Liu, X. Zhang, Y. Kang, L. Li, T. Chen, M. Hong, and Q. Yang, “Fedbcd: A communication-efficient collaborative learning framework for distributed features,” IEEE Transactions on Signal Processing, vol. 70, pp. 4277–4290, 2022.
- [12] T. Castiglia, S. Wang, and S. Patterson, “Flexible vertical federated learning with heterogeneous parties,” arXiv preprint arXiv:2208.12672, 2022.
- [13] M. Li, Y. Chen, Y. Wang, and Y. Pan, “Efficient asynchronous vertical federated learning via gradient prediction and double-end sparse compression,” in 2020 16th international conference on control, automation, robotics and vision (ICARCV). IEEE, 2020, pp. 291–296.
- [14] K. Simonyan and A. Zisserman, “Very deep convolutional networks for large-scale image recognition,” arXiv preprint arXiv:1409.1556, 2014.
- [15] Z. Wei, Q. Pei, N. Zhang, X. Liu, C. Wu, and A. Taherkordi, “Lightweight federated learning for large-scale iot devices with privacy guarantee,” IEEE Internet of Things Journal, vol. 10, no. 4, pp. 3179–3191, 2021.
- [16] X. Dong, S. Chen, and S. Pan, “Learning to prune deep neural networks via layer-wise optimal brain surgeon,” Advances in neural information processing systems, vol. 30, 2017.
- [17] V. Sanh, T. Wolf, and A. Rush, “Movement pruning: Adaptive sparsity by fine-tuning,” Advances in Neural Information Processing Systems, vol. 33, pp. 20 378–20 389, 2020.
- [18] X. Ding, G. Ding, Y. Guo, and J. Han, “Centripetal sgd for pruning very deep convolutional networks with complicated structure,” in Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, 2019, pp. 4943–4953.
- [19] H. Li, A. Kadav, I. Durdanovic, H. Samet, and H. P. Graf, “Pruning filters for efficient convnets,” arXiv preprint arXiv:1608.08710, 2016.
- [20] Z. You, K. Yan, J. Ye, M. Ma, and P. Wang, “Gate decorator: Global filter pruning method for accelerating deep convolutional neural networks,” Advances in neural information processing systems, vol. 32, 2019.
- [21] S. Han, J. Pool, J. Tran, and W. Dally, “Learning both weights and connections for efficient neural network,” Advances in neural information processing systems, vol. 28, 2015.
- [22] S. Han, X. Liu, H. Mao, J. Pu, A. Pedram, M. A. Horowitz, and W. J. Dally, “Eie: Efficient inference engine on compressed deep neural network,” ACM SIGARCH Computer Architecture News, vol. 44, no. 3, pp. 243–254, 2016.
- [23] Y. Jiang, S. Wang, V. Valls, B. J. Ko, W.-H. Lee, K. K. Leung, and L. Tassiulas, “Model pruning enables efficient federated learning on edge devices,” IEEE Transactions on Neural Networks and Learning Systems, 2022.
- [24] Z. Jiang, Y. Xu, H. Xu, Z. Wang, J. Liu, Q. Chen, and C. Qiao, “Computation and communication efficient federated learning with adaptive model pruning,” IEEE Transactions on Mobile Computing, 2023.
In this section, we provide the details of proofs. Let’s start by defining a new series of notations.
-A Additional Notation
In this section, we present various notations that will be utilized in subsequent proofs. During each local round , every client trains the local model with the embedding . This process can also be interpreted as the client training the model and for all , where is the last communication iteration when client received the embeddings. Then we have:
(8) |
Which represents the real model that client utilized in the round . We define the column vector to be the client ’s view of global model in the round . Then we define to be the loss with pruning error by client at round t:
(9) |
It is crucial to emphasize that is free from computation and communication pruning errors, while the expression is unaffected by communication pruning errors. Building on this understanding, we can now reform the definition of as follows::
(10) |
In the subsequent proof, we will employ both variations of . Following that, we will define the computation pruning error associated with each embedding utilized in client ’s gradient calculation during round :
(11) |
Given the error, we can derive the following:
(12) |
We apply the chain rule to to get:
(13) |
Using the Taylor series expansion to further expand around the point :
(14) |
To convince, we let the infinite sum of all terms from the second partial derivatives as . Then we can get:
(15) |
Building on the definition provided above, we will now move to the theoretical proof.
-B Proof of Lemma 1
By definition, we know that
(16) | |||
(17) | |||
(18) | |||
(19) |
Where Eq. 18 uses the Taylor series expansion. Then we can get
(20) |
Thus we need to get the bound of the right side first.
(21) |
Then applying expectation we can finally get:
(22) | |||
(23) | |||
(24) | |||
(25) | |||
(26) |
-C Proof of Lemma 2
In this section, we will get the bound of .
(27) | |||
(28) | |||
(29) | |||
(30) | |||
(31) | |||
(32) | |||
(33) |
Where the last term follows the Eq. 21. Then we have:
(34) | |||
(35) | |||
(36) | |||
(37) | |||
(38) | |||
(39) | |||
(40) | |||
(41) | |||
(42) |
Where Eq. 34 follows the assumption 1 and update rule .
Then by set and , we can get:
(43) | |||
(44) | |||
(45) | |||
(46) | |||
(47) |
Here, we set the new notations for each term as follows:
(48) | |||
(49) | |||
(50) | |||
(51) |
We can get . By induction, we can obtain .
(52) |
Then we get the bounds of and with summing over the set of local iterations to respectively:
(53) | |||
(54) |
We can also get
(55) | |||
(56) | |||
(57) |
Plugging all values into, we can get:
(58) | ||||
(59) | ||||
(60) | ||||
(61) | ||||
(62) | ||||
(63) | ||||
(64) | ||||
(65) |
-D Proof of Theorem 1
Here we will derive Theorem 1, first, we set , then we get:
(66) | |||
(67) | |||
(68) | |||
(69) | |||
(70) | |||
(71) | |||
(72) |
where the last term follows . Then we apply the expectation to both sides of the last term.
(73) | |||
(74) | |||
(75) | |||
(76) |
where the Eq.74 follows since we consider the full batch participation in each training round. If mini-batch is considered here there will have additional terms. Then with Lemma 2, we have:
(77) | |||
(78) | |||
(79) |
Then by let , we can get the further bound:
(80) | |||
(81) |
Then we rearranged the terms:
(82) |
summing over all global round with expectation:
(83) |
Then with and averaging over R global rounds, we get:
(84) | |||
(85) | |||
(86) |
where the last term is from . This finishes the proof of Theorem 1.
-E Proof of Corollary 1
To get the corollary 1, we need further bound the and respectively. We begin by giving the bound of .
(87) | ||||
(88) | ||||
(89) | ||||
(90) |
The last term is derived under the Assumption 4 and are valued within the . Then we will show the bound of as:
(91) | ||||
(92) | ||||
(93) | ||||
(94) | ||||
(95) |
Where Eq. 92 is due to Assumption 5. And the last term is also derived under the Assumption 4 and are valued within the . This finishes the proof of Corollary 1.