KECO: toward efficient task offloading in mobile edge computing with federated knowledge distillation

System architecture

This article mainly introduces the architecture of the MEC which consists of multiple edge devices and a user, and describes how users can execute a computing task locally and offload the task to multiple edge devices at the same time. In particular, we construct a data processing and transfer model based on the computing latency of a user executing a task locally, the computing latency of a user transferring a task to multiple edge devices, and the computing latency of a task executed on the edge devices.

As shown in the Fig. 2, the MEC assisted offloading calculation model in the scenario of single user and multiple edge devices is constructed. The system consists of multiple edge devices and a single user terminal which together act as a data processing center. The edge equipment and a single user jointly build the federated knowledge distillation model, and perform parameter updating and incremental training. To optimize system energy consumption, this work proposes a joint allocation scheme based on MEC task allocation ratio, user transmit power and bandwidth. The user computes some tasks locally, and then sends the remaining computing tasks to multiple edge devices deployed at the network edge. The edge devices calculate the tasks after receiving the tasks. The calculation delay and transmission delay of the tasks are taken into account so as to construct the system model.

Main idea of proposed method

In this work, an innovative edge federation learning algorithm is designed, which incorporates knowledge distillation technology. Compared with the traditional federated learning style, this marginal federated learning based on knowledge distillation has its unique features in each round of learning process. As shown in the Fig. 3, clients selected to participate in federated learning download not only the global model from the edge server, but also the global soft label. During the local training process, the client uses both the local hard label and the downloaded global soft label as optimization targets. In addition, it generates new sample logits while the client trains the local model. The edge server will collect the local model parameters and sample logits uploaded by the client for aggregation operation. It trains the global model and generates new global soft labels. These new global models and global soft labels will be used for the next round of federated learning. The edge federated learning architecture based on knowledge distillation proposed in this section consists of an edge server and several clients.

In the framework of the edge federated learning algorithm based on knowledge distillation technology designed in this work, we assume that the federated learning training process consists of a total of T iterations. After tth iteration, the client completes the local model update, the member of the client set x, will upload the local model parameters and the sample logits to the edge server. The member of the client set y uploads only the sample logits to the edge server. The edge server then performs an aggregation of the global model based on the received data, which can be defined as follows:

$$W_{\mathrm{t}+1}={\displaystyle \frac{{\sum }_{i=1}^I\left|A_i^{\mathrm{\prime }}\right|\times W_{t+1}^i}{{\sum }_{i=1}^I\left|A_i^{\mathrm{\prime }}\right|},}$$where W represents the parameters of the model. I is the total number of clients in client set x during federated learning. For any client i, after completing tth local training, it uploads the updated model parameters, which is referred to as W_t+1. Meanwhile, A_i′ represents the size of the local data set for the ith client. The server aggregates global soft labels based on this information. The process is as follows:

$$G_{\mathrm{t}+1}={\displaystyle \frac{{\sum }_{i=1}^I\left|A_i^{\mathrm{\prime }}\right|\times G_{t+1}^i}{{\sum }_{i=1}^I\left|A_i^{\mathrm{\prime }}\right|}+{\mathrm{\Delta }}_{G+1},}$$where G_t+1 represents the average logits of the sample uploaded by client i in client set x after completing tth local training; And Δ_G+1 represents the local soft label gradient generated by clients in the client set y at the end of tth local training to supplement and correct the global soft label information.

In the client set y, assume that when the time threshold T ends, it receives from the set the sample logits uploaded by u clients after (t − 1)th training, and receives the sample logits uploaded by v clients in the set after tth local training:

$${\mathrm{\Delta }}_{G+1}={\displaystyle \frac{{\sum }_{i=1}^u\left|A_i^{\mathrm{\prime }}\right|\times G_t^i}{{\sum }_{i=1}^u\left|A_i^{\mathrm{\prime }}\right|}-{\displaystyle \frac{{\sum }_{i=1}^v\left|A_i^{\mathrm{\prime }}\right|\times G_{t+1}^i}{{\sum }_{i=1}^v\left|A_i^{\mathrm{\prime }}\right|}.}}$$

In the process of local training, the client not only trains the local model, but also generates the sample logits. In this process, the local model update method of the client is similar to the local model update method in traditional federated learning, that is, each client adopts gradient descent algorithm to update the weight of the model.

$$W_{t+1}^i=W_t^i-\lambda r_i,$$where λ represents the learning rate of the local model training, and the symbol r_i represents the gradient of the current model parameter W. If client I generates A′ sample logits in Tth local training, then eventually it will upload the average value of these sample logits, as $G_{t+1}^i$, to the edge server, which is defined as follows:

$$G_{t+1}^i=\sum _{a=1}^{A^{\mathrm{\prime }}}{G}_a^i/A^{\mathrm{\prime }}.$$

The edge federation learning based on knowledge distillation can use both hard label and soft label knowledge in model training. The prediction model should adhere not only to the hard label of the local dataset sample, but also to the corresponding soft label. During the local training of each client in federated learning, the model loss function is computed to evaluate the model’s performance in approximating hard and soft labels.

$$Loss(W)=\delta L_s(l_b,G)+(1-\delta )L_k(l_b^{\mathrm{\prime }}\Vert G).$$

G represents the prediction result of the model and $\delta$ is a hyperparameter in the interval (0,1), where l_b′ represents the soft label and l_b represents the hard label. $L_s()$ represents the cross entropy loss function, which measures the difference between the model prediction and the hard label. Meanwhile, $L_k()$ represents the divergence loss function, which measures the difference in distribution between the model prediction and the soft label. If in the ith client, the number of local data sets is d_i, then the calculation of the loss function can be deduced as follows:

$$L_s(l_b,G)=-\sum _{a=1}^{d_i}{l}_b\log {\displaystyle \frac{\exp (G^a)}{{\sum }_{a^{\mathrm{\prime }}}\exp (G^{a^{\mathrm{\prime }}})}.}$$

$$L_k(l_b^{\mathrm{\prime }}\Vert G)=-\sum _{a=1}^{d_i}{l}_b^{\mathrm{\prime }}\log {\displaystyle \frac{\exp (G^a){\sum }_{a^{\mathrm{\prime }}}\exp ({l_b^{\mathrm{\prime }}}^{a^{\mathrm{\prime }}})}{\exp ({l_b^{\mathrm{\prime }}}^a){\sum }_{a^{\mathrm{\prime }}}\exp (G^{a^{\mathrm{\prime }}})}.}$$

Through derivation, the optimization function of this work can be calculated as follows:

$$\begin{array}{rl}& \underset{W}{min}\left(\mathrm{\Gamma }(W)\stackrel{\mathrm{\Delta }}{=}{\sum }_{i=1}^I{f}_i\left(\delta L_s(W)+(1-\delta )L_k(W)\right)\right),\\ & s.t.f_i=\frac{A_i}{{\sum }_{i=1}^I{A}_i}.\end{array}$$

From the optimization function, we can observe that the hyperparameter $\delta$ plays a decisive role in the knowledge distillation process, which regulates the proportion of hard label loss and soft label loss in the total loss. Therefore, the value of $\delta$ has a profound influence on the training effect of the model.

In the initial stage and early stage of model training, the information of hard labels plays an absolutely leading role in improving model performance due to the relatively little knowledge contained in soft labels. However, in the later stage of model training, when the model has fully absorbed the knowledge of hard labels and begins to converge gradually, the introduction of soft label knowledge will further promote the improvement of model performance.

Based on the above considerations, we design a dynamic value method for hyperparameter $\delta$. In the early stage of model training, we let the value be relatively large, so that the model can make full use of the hard label information. Subsequently, we gradually reduce the value until it reaches a minimum threshold. The purpose of this design is to make the model effectively use the hard label information in the training process, and introduce the soft label knowledge at the appropriate time, so as to improve the performance of the model.

Implementation of KECO

The implementation of knowledge distillation in the edge-federated learning method can be carried out by the following process:

Step 1: initialize the global model and the local model (the local model per client). Then select a batch of data D as the dataset of the teacher model.

Step 2: the server sends the global model to each client.

Step 3: each client is trained on the local data set using the global model to get the local model. After the local model is trained, the parameters of the local model are uploaded to the server.

Step 4: the server collects the local model parameters uploaded by all clients. Use integration techniques such as weighted averaging to aggregate all local models into a new global model.

Step 5: soft labels are generated using the teacher model (the original global model) and the integrated model. Through teacher model and integration model, soft labels are obtained respectively. The knowledge distillation (KD) divergence loss between soft labels is calculated, and the global model is optimized.

Step 6: the global model is optimized according to the loss function and updated to a new global model. The updated global model is sent to each client to begin the next round of training.

By distilling multiple local models into one global model, the overhead of model transmission can be significantly reduced. Ensemble learning technology can integrate multiple local models with poor performance into a global model with good performance, thereby improving the overall efficiency. By distilling knowledge using unlabeled data or generated data, models can be trained without exposing client data, protecting user privacy. Through the above steps and strategies, knowledge distillation can effectively improve the performance of the model in the edge-federated learning method, while reducing transmission overhead and protecting user privacy.

Additive homomorphic encryption

To ensure the security of private data, additive homomorphic encryption technology is adopted in this study. This technique can effectively prevent the leakage of task information, and at the same time, it can provide corresponding algorithm support for elements in plain text space. In this article, a method is proposed, which can not only encrypt two numbers, but also calculate the encryption results of these numbers. For illustration purposes, we set the real number a to be encrypted in the form <a>. Based on this setting, for any two unencrypted numbers a and b, their encryption sum satisfies the relationship <a> + <b> = <a + b>. In addition, we also implement the multiplication between ciphertext and plaintext, i.e., b·<a> = <ba>, where b remains unencrypted. In this way, we can calculate the sum product of plaintext and ciphertext without leaving the encrypted digital environment.

Further, we extend this operation mechanism to the operation of vectors and matrices. Specifically, we can use b^T<a> = <b^Ta> to compute the inner product of vectors of plaintexts a and b, and $b\circ <a>=<b\circ a>$ to compute their component product. As for the specific details of matrix operation, because of its similarity with vector operation, we will not go into details here. It is worth noting that our approach enables the sharing of parameters without exposing information from the edge computing center. Relying on our federated learning model, we are able to efficiently aggregate task request data while ensuring privacy.

During the initialization stage of the federated learning system, a trusted third party (or coordination server) generates a homomorphic encryption public-private key pair. The public key is distributed to all participating clients, while the private key is kept by the designated party. Subsequently, the server issues the initial teacher model (or the locally pre-trained teacher model on the client side), and the architecture of the student model is customized by each client. In the local knowledge extraction stage, the client uses local data to generate probabilistic outputs (logits) through the teacher model, and softens the distribution through a temperature parameter. Subsequently, the client encrypts the soft labels using the homomorphic public key, and may also choose to encrypt intermediate features. In the secure knowledge aggregation stage, the client uploads the encrypted knowledge representation to the aggregation server. The server performs the aggregation operation on the ciphertext, utilizing the homomorphic addition property. In the distributed distillation stage, the authorized party decrypts the aggregated result using the private key, or directly distributes the ciphertext for the client to decrypt. The client trains the student model based on the decrypted global knowledge using the KL divergence loss. Finally, in the model iteration optimization stage, the parameters of the student model are updated to the global model through federated averaging (FedAvg) or other aggregation algorithms. Then, the temperature parameter and the homomorphic encryption level are adaptively adjusted according to the convergence situation.

Experimental setup

In the model training session, the first convolution layer is configured with 32 convolution cores, the size of each convolution kernel is set to 6 × 6, and the step size is set to 1. The matrix size of the maximum pooling layer is set to 2 × 2, and the step size is also 2. As for the second convolution layer, it is equipped with 64 convolution cores, and the remaining parameters are consistent with the first layer. The training cycle of the designed model is usually between 1.5 and 2 h. We set the learning rate of the model to 0.001 and introduced Adam optimization algorithm to achieve dynamic updating of step size. In the early training phase, we set the weight loss ratio at 1:3 to achieve knowledge transfer. While in the later training stage, we adjusted the ratio to 3:1 to accomplish the learning of the specific task objectives. To simulate the scenario where multiple users jointly participate in the training of a federated model, it is set that this deep model has five participants. The dataset is randomly divided into five parts and sent to the five parties. Each party then trains its local model locally and conducts 50 rounds of iterative training simultaneously. The dataset is divided into a training dataset and a test dataset, so as to achieve the cross-validation during training. As the number of training sessions increases, the method gradually improves its performance in terms of accuracy and other metrics, and its results stabilize in the final few rounds of training. The overall training time remains generally between 30 and 58 min, ranging from 25 to 50 rounds, while ensuring the security of the data.

In terms of experimental environment construction, we create a virtualization scenario using OpenStack and deployed Spark, a big data processing framework. All experiments are performed on the same Linux workstation with an Intel Xeon processor, three 3.4 GHz CPU cores and 512 GB of RAM. We create 32 processing nodes with different configurations to simulate MEC nodes and resource pools.

Comparison of energy consumption

In this section, we compare the performance of two task offloading methods based on DDPG and CNN with the method proposed in this work in terms of system energy consumption. In this work, the local computing power consumption (Shi et al., 2023) and data transmission power consumption during the offloading of MEC tasks are used to measure the energy saving advantages. As can be seen from the Fig. 4A, in terms of local calculation, the energy consumption of each method gradually increases with the increase of data scale. On the whole, the energy consumption of the method proposed in this work is always lower than the other two methods. The energy saving effect of the system proposed in this work is basically equal to the other two methods in the initial stage of task offloading, and its performance is gradually superior to the other two methods in the later stage. In the data transmission process, as shown in the Fig. 4B, we can observe that the three methods produce less system energy consumption in the case of smaller task scale. However, communication costs for all three are increasing as missions scale up. However, the communication energy consumption of CNN method in the later stage is gradually higher than that of the other two methods. For DDPG method, the communication energy consumption in mobile edge environment is higher when the task scale is small, but its value in the later stage is lower than CNN, and it is always greater than the cost of the method proposed in this work. For the method proposed in this work, the energy consumption value is not much different from the other two methods in the early stage, and gradually lower than the other two methods in the later stage.

This is mainly because the method proposed in this work can realize the guidance based on the global soft label knowledge according to the parameters and sample logic learned during model training, so as to calculate the effect and total energy consumption of each feasible scheme. In the process of searching for the optimal scheme, the current optimal scheme obtained by each iteration is taken as the basis. Gradually search and try to find a solution that consumes less energy and costs less computing resources, so as to find a suitable task processing node for the corresponding computing task. This effectively ensures the resource utilization of the whole field to a great extent. In general, we can observe that the method proposed in this work has a good performance in system energy saving. It reduces the extra consumption of valuable computing resources, realizes the reasonable offloading of distributed computing tasks, and improves the overall benefits of the system in the long run.

Comparison of external service performance

In this section, the method proposed in this work is compared with the other two methods in terms of system performance to external services. This work takes system throughput as the main evaluation criterion of external service performance. As shown in Fig. 5A, when the task volume is 8500, the external service performance effects of each of the three methods used for comparison are different. For the CNN method, the external service performance of the system seems to be relatively good in the early stage, but the performance is not very stable in the later stage. For DDPG, the throughput value is low in the initial phase. With the passage of time, its system performance gradually becomes stable, and gradually exceeds the CNN method. The algorithm proposed in this work can reasonably analyze the computing task requirements and make a reasonable resource allocation strategy, and its external service performance is generally better than the other two methods. With the passage of external service time, its throughput value gradually tends to be stable, and it is slightly higher than the throughput value of CNN and DDPG in the later stage. In another group of experiments, when the task volume is 10,500, as shown in Fig. 5B, in general, the throughput value of the method proposed in this work is gradually higher than that of the other two methods in the later period. For CNN method, in the MEC environment, its external service performance is obvious in the initial stage, but its value is always lower than DDPG. When t = 500 s, the throughput growth rate of these two methods begins to decrease gradually.

As for the method proposed in this work, its performance of external service is not much different from the other two methods in the early stage, and gradually exceeds the other two methods in the later stage. On the whole, we can conclude that the method proposed in this work is relatively efficient and stable in terms of external service effects, which helps to efficiently perform large-scale distributed tasks.

Comparison of number of task offloading failures

In the actual scenario of MEC tasks offloading, some distributed computing tasks often fail to be uninstalled because some selected computing task processing nodes cannot meet the corresponding task requests. In this section, we use simulation tools to simulate some dynamic node failures, take CPU and memory pressure (Li, Chen & Song, 2023) as examples to simulate the impact of real pressure environment on task offloading, and compare with the other two methods in terms of the number of task offloading failures. As shown in Figs. 6A and 6B, with the expansion of task scale, the number of task offloading failures of CNN and DDPG increases rapidly during task deployment. For the algorithm proposed in this work, with the expansion of task scale, the number of task offloading failures increases significantly slower than that of the other two methods, and the number of task deployment failures remains at a minimum.

This is mainly because the other two methods are difficult to carry out a reasonable and thorough analysis of the current remaining resource information in each computing task processing node and the MEC task requirements in the MEC network. If the resource requirement of a computing task is greater than or equal to the remaining resources of the node that processes the computing task, the computing task may fail to be uninstalled. On the contrary, the method proposed in this work uses the federated knowledge distillation network model to reasonably guide the selection of the current task offloading strategy according to labels and logical values, which can ensure that the remaining resources of each selected node are greater than the resource demand of the corresponding task and obtain certain system benefits under the condition of ensuring effective calculation and communication. Therefore, to a large extent, it can dynamically and adaptively find the appropriate task processing node from the cluster for most mobile computing task requests, so as to complete the efficient execution of collaborative computing tasks.