Motivation

The demand for Mobile Computing (MC) is rising due to the portability of User Equipment (UE). MC has a large number of applications due to the successful embedding of more resources on smaller chips, and computational offloading is one of them. Nowadays, a UE has enough processing capabilities to support online gaming [1], and applications based on Augmented Reality (AR), Virtual Reality (VR) [2], big data analysis, healthcare, automation, smart control, and video analysis [3–6]. The other applications include collaborative computing, memory replication, content delivery, and web content optimization [7]. Nowadays, due to the heavy software and run-time interaction with other players, most of the games are played on the cloud server. These games require a high-speed update in the game logic and score, which is attained via MEC [1, 8]. In healthcare, the 3-tier architecture is used by medical advisors to attend to and treat patients anywhere in the world in the least amount of time [9]. Another application of MC in healthcare is the usage of UE sensors like gyroscopes and accelerometers to detect the fall of a person in case of a stroke or any other accident and generate an alert message [10]. Big data analysis in the Internet of Things (IoT) also requires high bandwidth and other architecture to deliver the data to the cloud using Mobile Cloud Computing (MCC). As the UEs are situated near the IoT devices, they are used to deliver the data to the cloud server and then deliver the actions accordingly to the receiving nodes [11]. MC is used in Vehicle-to-Vehicle (V2V) communication for the same purposes as the usage of UEs to deliver the data to edge nodes eradicating the need to install new resources [12]. The usage of mobile applications based on AR and VR has also increased in the recent era. The redundancy in AR and VR application data creates a bottleneck in the back-haul link, which is reduced by intelligent caching introduced in the system by Mobile Edge Computing (MEC) [2]. MEC and MCC are also used in AR and VR to reduce the latency and energy consumption of UE [13]. To mitigate the risks to IoT device data in case of cyber-attacks (e.g. spoofing, DDoS, MITM, etc.), the data is analyzed using different applications deployed in UEs, or edge/cloud servers [14]. In case of a threat or attack, hardware or software-based solutions can be implemented in a short amount of time. The high processing also costs the UE in the form of latency and more battery consumption [4].

The high processing capability in MC costs the UE in the form of latency and higher battery consumption [4]. To overcome these issues, researchers introduced a model of Mobile Cloud Computing (MCC) [15], in which the tasks are offloaded and processed on the cloud server. Due to the high latency introduced in the system because of the distance between UE and the cloud server [16], researchers introduced partial offloading in MCC [17], in which a task is divided into a fixed number of sub-tasks, and is then partially offloaded to the cloud server. To further decrease the latency issues, researchers shifted towards Mobile Edge Computing (MEC) [18], which comprises an edge server nearer to the UE as compared to the cloud server. This model eliminates the latency issue, but it has resource limitations, as compared to the cloud. The service rate of MEC is improved by the introduction of partial offloading, with the number of partitions of the task being fixed [19]. The technique of partial offloading in MEC has reduced the latency and energy consumption of the UE, along with an increase in the service rate [20]. The rapid growth in production and demand for the aforementioned applications require more processing hardware, which cannot yet be integrated on a smaller scale. The other solution is the intelligent usage of existing resources, which is explored in this research.

Problem definition

The processing capability of a UE is constrained by its battery, memory, and Central Processing Unit (CPU). In the case of MCC, the resources are unlimited, but the latency introduced in the system is unsolicited. The battery consumption of a UE is also high in the case of MCC [16]. MEC reduces the energy consumption along with the latency of processing but has a limited amount of resources because of which the service rate of MEC drops in high traffic cases. In the case of a time-sensitive task, higher traffic in the network can cause a bottleneck. The usage of Machine Learning (ML) can help solve these issues, but the selection of an optimal algorithm and parameters is quite difficult by manual testing.

The identification of the optimal number of partitions and calculation of the offloading destination for them, with the least energy and time consumption, can take a lot of time if done using traditional mathematical calculations. The usage of ML algorithms can help solve this issue in time complexity of O(1) but the selection of an optimal model and parameters is quite difficult by manual testing. Due to a huge number of ML algorithms, it is nearly impossible to test the data on each one, with each possible combination of parameters.

Contributions

This research introduces an algorithm, called Priority-based Hybrid task Partitioning and Offloading (PHyPO), which introduces a hybrid mobile-edge-cloud server-based system where the architecture is 3-tier, which uses a router for cloud server communication, as shown in Fig 1. The figure presents the network scenario considered in this research, in which there are several edge servers and a single cloud server, which are used for partial offloading by multiple UEs. The lower tier consists of UEs, where the resources are most limited, and the applications require processed data. The second tier consists of edge servers deployed along with cellular towers, containing more resources as compared to the UEs, and routers, which are required to transfer and receive data from the cloud and have no processing resources of their own. The upper tier consists of cloud servers, which have a greater amount of resources as compared to the rest, because of which their resources are considered to be unlimited. The distance between the second and last tier is larger as compared to the distance between UEs and the second tier. The difference in distances is utilized to prioritize the task offloading in PHyPO.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 1. Overview of mobile-edge-cloud server-based system.

https://doi.org/10.1371/journal.pone.0314198.g001

To resolve the aforementioned problems, a comprehensive algorithm is formulated that uses the existing hardware components and provides solutions for the mentioned problems by use of the latest ML trends. A data-oriented optimal partitioning scheme is introduced, along with the utilization of an ensemble model, namely Adaptive Boosting (AdaBoost) for the reduction of computational complexity and prediction time. The use of Automated Machine Learning (AutoML) resolves the issue of selecting an optimal ML model for the given data, along with tuning the hyper-parameters until it finds global minima. The contributions of the proposed algorithm can be summed up as follows.

1. Development of an optimal task partitioning algorithm to minimize the cost before offloading.
2. Use of a 3-tier architecture to increase the service rate, by offloading time-sensitive tasks only on the nearby edge servers and the rest on either of the devices.
3. Use of AutoML to predict the optimal ML algorithm along with tuning its hyper-parameters.
4. Use of AdaBoost to eradicate the need for exhaustive search and optimize optimal partitioning and offloading problems in O(1) complexity.

Paper organization

The rest of the paper is organized as follows. Second section contains the literature review, which is followed by the proposed methodology in the third section. Fourth section illustrates the results and the fifth section contains the conclusions along with the future research directions.

Algorithms for optimal offloading without learning

Kao et al. [23] developed a model for optimal offloading policy, consisting of a network with all the UEs connected via a direct link. In run-time, each UE was considered a node and when an application started, the node with resource demand was made a leader node. The purpose of the leader node was to collect information regarding the resources of all nearby nodes and then predict where the data was to be offloaded. The model was evaluated based on CPU performance and latency of task execution. However, this model has a high probability of resource contention. A context-aware offloading scheme was introduced in MCC by Chen et al. [24], where the cost function depended upon the services provided by the resources, and a significant amount of execution time and power consumption were reduced. The main limitations of this model are its 2-tier architecture and high complexity. Tran et al. [25] modeled an algorithm to offload data as a service in a fog architecture comprising many devices connected on the Internet of Things (IoT) treated as edge. Chang et al. [26] proposed a fog architecture-based model, but with energy-efficient optimization at UE. These models provide sub-optimal results, with more time complexity.

Maio et al. [27] proposed a mobile-edge-cloud-based model on simulated data to determine optimal offloading schemes, based on the preference of the user. Monte-Carlo simulations were also carried out to evaluate the proposed methodology, where to save the battery and lessen the application’s run-time, the model traded off tasks between the edge server and cloud. This model is also stationary, and the results are produced with relatively high computational complexity. A dynamic programming-based optimal scheduling and offloading model in MEC was developed by Hong et al. [28], which scheduled and offloaded tasks based on the priority of the user. Based on the tendency of a user, the model traded off between energy and latency. Additionally, the scheduling of tasks depended on the resources available in the MEC. The complexity of this model increases exponentially with the increase in task size, which makes it unsuitable to be used for larger task sizes. Another model was proposed by Chen et al. [29] in which the application of MEC in IoT was introduced for the development of a stochastic optimization algorithm for minimal energy consumption during transmission. It is an energy-oriented model with polynomial time complexity.

A model to secure the data on the physical layer during offloading in IoT-edge computing was developed by Liu et al. [30], using blockchain, which also worked on computational offloading. The resources with higher utility were given priority, and energy efficiency was also considered. However, this model is a binary offloading model with a complexity of more than O(1). Zhou et al. [31] proposed a reverse auction-based computation offloading and resource allocation mechanism for the mobile-edge-cloud computing architecture, with polynomial computational complexity.

Algorithms for optimal offloading with machine learning

Researchers have worked on various unsupervised ML algorithms for optimal offloading scheme development. An energy-aware offloading scheme was developed by Xu et al. [32], which determined the nearest offloading node to the UE to consume less energy in transferring the data. Offloading time was optimized using GA, along with optimizing the energy consumption of all nodes. However, this model has a low convergence rate to the solution. The reliability of data in MEC for software-defined network-based internet of the vehicle was improved by Hou et al. [33] by Particle Swarm Optimization (PSO) based computational offloading. Another PSO-based model for the optimization of sub-carrier allocation was developed by Dai et al. [34]. The research focused on the number of resource-demanding devices in the network (i.e., UEs and IoT devices), and increasing the rate of service provided by the edge server. The model also resulted in generating the optimal policy in a lesser number of iterations. Kuang et al. [35] developed a task offloading algorithm in edge computing for smart IoT, and to reduce complexity, a GA-based model was developed.

Wang et al. [36] proposed a mechanism to reduce the workload during the offloading of tasks and optimize the performance of edge servers by formulation of a utility function, based on GA. A multi-problem scenario was solved by a model called BeCome by Xu et al. [37] to ensure data integrity by blockchain, optimal offloading, and resource allocation strategy generation via GA. Yang et al. [38] introduced an offloading time optimization scheme using a stochastic technique of the Markov Decision Process (MDP). This scheme was applied in the MEC. A Bayesian Learning Automata (BLA) based scheme for computational offloading in MEC was developed by Farahbaksh et al. [39]. Along with energy consumption and latency improvements, this model improved network usage by managing traffic. However, these models produce binary offloading decisions, along with high complexity.

Using supervised ML, Huang et al. [40] proposed a distributed Deep Learning (DL)-based model to optimize the binary offloading scheme in MEC. A gradient descent algorithm was also applied to optimize the input parameters of different DL models to improve the efficiency of the system. This model is application-constrained and only works better for gaming, AR, and VR applications, along with media services. Wu et al. [41] proposed an optimal MEC offloading model in a vehicle-to-vehicle network. To incorporate the issues raised by the mobility of vehicles, a Support Vector Machine (SVM) based model was developed that increased the speed of offloading by using roadside units for transfer purposes. With a time constraint, each server had to finish executing the task and send the data back to the vehicle. This model has more offloading overhead.

Sun et al. [42] developed a DL-based transfer learning model for optimal code computing in industrial IoT to improve service accuracy while minimizing latency. This model was centralized as it was deployed on an edge server. Hence, it increases the chances of the whole network malfunctioning in the event of any error on the edge server. Moreover, this model has a large overhead, which was solved by Ali et al. [43]. The authors in [43] developed an energy-efficient offloading scheme for optimal offloading in MEC, with a fixed number of partitions. To reduce the computational overhead, the data was generated for different iterations, and a model was trained using a supervised classifier of a Deep Neural Network (DNN), which resulted in an average accuracy of 70%.

Abbas et al. [20] proposed energy and latency optimizing cost function using UE and edge server architecture, for partial computational offloading. A DL technique was also applied with the resulting accuracy of 71%. Irshad et al. [44] proposed a time allocation scheme along with reducing the energy consumption of UE using a hybrid access point to connect to the MEC. This scheme also used a DL model and achieved an accuracy of about 72%. Shahidinejad et al. [45] developed a cloud and edge server-based model for mobile computing in which a cost function was generated using latency, energy, and the power utilization of the UE. The results showed an improvement in the network availability and the data was also secured using a federated learning framework.

An improved version of [43] was developed by Ali et al. [46] where different delays were considered for task offloading in MEC along with a DNN algorithm with a faster prediction speed in comparison with the previously developed models. These prediction models use the architecture of MEC and provide a binary offloading scheme, i.e., the subtask is offloaded only on the edge server or processed on the UE. There is more classification error in each model, except [45], but this model has more complexity as compared to the others, along with providing no solution for the time-sensitive applications. An edge-cloud-based offloading strategy was also developed by Mao et al. [47] where a DNN-based algorithm was used to optimize the energy consumption and reduce the latency for 6G-IoT devices.

Xu et al. [48] proposed a Reinforcement Learning (RL) based algorithm for the problems of offloading and auto-scaling in an energy-harvesting MEC. The data was trained for multiple iterations and compared with the Q-learning algorithm where the RL model learned better than the former model, in terms of the optimal cost function, and power consumption of the base station, along with average time consumption. This study does not consider the load balancing problem, which was resolved by Dinh et al. [49], who developed an RL-based offloading method in MEC to learn the pattern of offloading for known Channel State Information (CSI) and then applied it to all unknown CSIs of different games. The main constraint of this model is its binary offloading policy.

Zhang et al. [50] proposed a model for computational offloading in MEC based on Deep Q-Learning (DQL) along with an offloading algorithm to improve reliability in case of data transmission failure. Liu et al. [51] introduced a vehicular mobile-edge server-based architecture and by generating the data through stochastic routing, the computational offloading problem was learned and modeled by a DQL method, and a Deep Reinforcement Learning (DRL) model was proposed for the resource allocation problem. Both of the models are highly computationally complex. Min et al. [52] proposed an energy harvesting-based offloading scheme in MEC for IoT devices, using RL for online learning. Given the trained data, the model predicted an optimal partial offloading policy in run-time along with the offloading rate. In addition to the limitation of binary offloading, this model has high complexity.

Huang et al. [53] formulated a model for optimal task offloading in a dense network, along with optimizing the bandwidth allocation to each of the UEs in MEC. The model used an offline DQL algorithm to learn a nearly optimal model after around 8000 iterations. This model is centralized and does not apply to all types of applications. Yu et al. [54] proposed a Deep Imitation Learning (DIL) based model for optimizing the offloading policy with a fixed number of partitions in a mobile-edge-cloud server-based architecture. A large amount of data was generated to incorporate the changes in environmental conditions, and then DIL learned and cloned those changes to provide the classification label. This model was application-oriented, and to make its application more vast, a multi-problem-solving model was developed by Yu et al. [55], which used the DRL algorithm for offloading and resource allocation in MEC. Liao et al. [56] proposed an algorithm to offload tasks with priority to the edge servers. The proposed double reinforcement learning computation offloading algorithm not only makes the offloading decision but also predicts the transmit power and the CPU frequency required. This complex model is deployed on UE, and handles the tasks with high priority only, while the rest are processed on the UE. Mao et al. [57] also proposed an algorithm to jointly optimize energy and latency during task offloading for V2V network using DQL, which resulted in an improved performance in terms of average task completion ratio. Table 1 summarizes the related work presented in this section.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 1. Comparison of related work.

https://doi.org/10.1371/journal.pone.0314198.t001

Proposed architecture

The proposed architecture consists of a 3-tier architecture, which includes UEs, edge servers, and cloud servers, as shown in Fig 1. The communication between UEs and edge servers is carried out directly, while cloud communication is carried out via a router. The time sensitivity of a task is also considered using a parameter of priority. The tasks with high time sensitivity are given priority over other tasks. As the latency for cloud communication is high due to the distance between UE and the cloud, for high-priority tasks, PHyPO considers the offloading scheme using only UE and edge resources. For the low-time sensitivity tasks, the offloading architecture includes all the components of the system model. This hybrid scheme increases the service rate too, resulting in utilizing the least amount of resources of the UE. For task partitioning, an already established partitioning scheme of ^aZ_b is used, where a is the task size and b is the number of components it is divided into [43]. In this scheme, the computational complexity of task partitioning is reduced by limiting the number of components along with defining the resolution of partitioning. Table 2 contains a summary of notations used in this paper, along with their descriptions.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 2. List of notations.

https://doi.org/10.1371/journal.pone.0314198.t002

Latency of PHyPO

The latency of each sub-task for all schemes is calculated for the input parameters. The total latency includes the time taken to divide a task into sub-tasks, transmit it, and receive it from either of the servers and the time taken to process it.

For local execution of ST_m, the time required to divide a task into n sub-tasks is given by (1) where τ is the time required to divide a task into 2 sub-tasks [43]. After the division of the task, the local processing parameters are used to execute the sub-task, the time consumed during which is given by (2) where α_m is the number of CPU cycles used by UE to process the sub-task and f_cm is the local CPU frequency [20]. The value of α_m can be calculated by (3) where η is the number of CPU cycles required to process each MegaByte (MB) of the ST_m and s_m is the size of ST_m [44]. The total execution latency for local processing is calculated by (4)

The total latency of edge offloading is calculated by summing all the delays included in the total processing of ST_m as (5) where L_om and L_rm are times used by the UE to prepare the data for transmission to the edge server and to load the output data when the edge server sends it back, respectively [43]. L_pm the propagation delay for sending data to and from the edge server. It is added twice to incorporate both the delay for uplink and downlink communications. The value of total propagation delay is dependent on the medium of communication, which in this case is air, and is calculated as (6) where d is the distance between UE and edge, and c is the speed of light, as the medium of transportation is air. The time consumed by the transmission and reception is calculated, respectively, as (7) (8) where υ_ulm and υ_dlm are the uplink and downlink data rates for communication between the UE and edge. The value of the uplink data rate is calculated as (9) and the value of the downlink data rate is given by (10)

In (9) and (10), b_e is the bandwidth of the channel between UE and the edge server. The transmission and reception of data are directly proportional to the number of sub-carriers available for communication. ϕ_upm and ϕ_dlm are coefficients that are used for simplification purposes and their values are stated, respectively, as (11) (12) where N_o is the noise power, while P_tm and P_rm are the values of power used to transmit ST_m to the edge server and to receive it back, respectively. The communication channel used is the Rayleigh channel, so the channel fading coefficient for uplink is calculated by (13) where N is generated as a random Gaussian variable between 0 and 1. In this model, the channel fading coefficient for the downlink is considered to be equal to the uplink fading coefficient. The Signal-to-Noise Ratio (SNR) margins that are used to synchronize the actual signal using the bit error rate, i.e., g_up and g_dl for uplink and downlink channels, respectively, are calculated as (14) (15)

The time required to process data at the edge server is calculated using the processing frequency of the edge server, f_em, and the number of CPU cores available, as (16)

The total latency in the case of cloud computing is the cumulative time taken to send the data to the router, which sends it to the cloud server, and then the same data transfer occurs in the downlink. The overall latency of mobile-cloud computing is calculated as (17) where L_am is the latency to send the sub-task to the router in uplink and then receive the processed task back from it. L_am is calculated as (18) where u_inm and u_outm are the input and output sizes of the sub-task, which are considered to be equal to the size of s_m in MBs [59]. and represent the uplink and downlink transmissions’ spectral efficiency, respectively. The delay in sending the task from the router to the cloud and then receiving the processed task at the UE is calculated as (19) where r_ac is the rate of data transmission between the cloud and the UE [59].

Energy consumption of PHyPO

The energy consumption of each scheme is calculated using the different parameters involved in each scenario. For local execution, the total energy is calculated as (20)

In (20), the total energy utilized in the local execution of ST_m is calculated by adding the energy utilized in the processing of ST_m, i.e., E_im and partitioning of the whole task [43], i.e. E_dm, which is calculated as (21) and the value of E_im is calculated as (22) where ζ is a constant of the UE, having a value greater than 2 [43]. In the case of edge computing, the energy required to transmit data to the edge server from the UE is calculated as (23) and the energy used to receive the data from the edge server is calculated as (24) where P_tm and P_rm are the values of power consumption of the UE for transmitting the data to the edge server and then receiving from it, respectively. The total energy consumed in edge offloading is measured by the sum of E_tm and E_rm [43], and is given as (25)

As the energy used by the router to transmit the data to the cloud has no impact on the battery of the UE, so in the case of cloud computing, only the energy consumption of the UE to transmit ST_m to the router is considered [59]. Therefore, (26) where β is the per MB cost of router usage, E_ctm and E_crm are the energy values of the UE used to transmit the data to the router and then receive the processed data.

Cost functions of PHyPO

A cost function is generated using the parameters of latency and energy consumption, which are normalized to make them unitless quantities and then weighted with respect to their effect on the whole function. The following expressions are the cost functions for local execution, edge, and cloud server offloading, respectively. (27) (28) (29) where δ₁, δ₂, …, δ₆ are the weighting coefficients of cost functions for different schemes, i.e. C_lm, C_em, and C_cm. Individual costs of each sub-task are calculated and then for each possible policy of offloading, the total cost of executing the task is calculated, e.g., if a task has 2 partitions, the total possible number of offloading policies can be 9 as there are 3 destinations in this case. For each possible offloading policy, the cumulative cost is compared with the rest, and the minimum one is chosen for the processing. The offloading policy and the number of partitions in case of minimum cost are regarded as the optimal policies against the particular input variables.

Machine learning in PHyPO

The calculation of cost for each possible offloading policy costs a lot of time and battery consumption, so to eradicate the need for an exhaustive search, ML models are generated. The data is trained for supervised learning with AutoML, having a classification label being the optimal number of partitions and offloading policy, as mentioned in the previous section. AutoML is the latest trend in the field of ML, which is used to determine which ML model is optimal for the classification of any given data [60]. There are several parameters that an ML model sets during the training process, but some are set before the beginning of the training process. These parameters are called hyper-parameters, which also play a drastic role in changing the classification value. AutoML not only predicts the optimal ML model but also sets the value of hyper-parameters for the model by tuning them in different iterations until no further improvement in the results can be achieved. This process is not only efficient but also eliminates the chances of human error in the identification and tuning of an ML model [60]. By implementation of the ML models, the complexity of generating output is reduced to O(1), as the model is trained only once. As an ML classifier only provides a single class label, 2 models are generated to optimize the number of partitions and their offloading destination. Fig 2 shows a brief overview of the PHyPO algorithm, which is deployed on the UE.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 2. An overview of PHyPO.

https://doi.org/10.1371/journal.pone.0314198.g002

The datasets are trained using the AutoML generated model and then compared with multiple traditional ML models, which include Tree, K-Nearest Neighbor (KNN), SVM, Neural Network (NN), and ensemble models. These models are trained once and then deployed for run-time testing with minimum time and energy consumption [61, 62]. The first dataset (DS1) is generated by concatenation of the total task size, the communication parameters used to communicate with the edge server, and the parameters used in local processing. The local processing parameters include the CPU frequency of UE and the resolution with which the task is to be partitioned, and both of them vary with respect to the time and position of the UE. The communication parameters include the distance between the UE and the edge server, the number of sub-carriers, and the number of CPU cores available at the edge server. The second dataset (DS2) is generated by concatenation of DS1 and the label generated by the DS1, in case of testing. The task is partitioned with the label generated by Model 1 and then the partitioned sub-tasks are offloaded to their respective targets using the label generated by Model 2. Both the datasets used to generate the test label for sub-task m can be generalized by the following equations (30) (31)

Use of ensemble learning

The ensemble learning models work by stacking the output of multiple weak classifiers and then choosing the most frequent output. Fig 3 shows the basic working of the AdaBoost model, which in this case is classified using a series of Decision Trees (DTs). An ensemble model can either be implemented by using Bagging-based models or Boosting-based models. The PHyPO algorithm utilizes a Boosting-based model for two purposes: (i) AdaBoost Model for Partitioning (AMP) and (ii) AdaBoost Model for Offloading (AMO). An AdaBoost model works by training the data on a weak classifier and then passing on its misclassified data to the next classifier, which then passes on its misclassified labels to the next classifier and so on [63].

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 3. The basic working of AMP and AMO.

https://doi.org/10.1371/journal.pone.0314198.g003

Algorithm 1 depicts the pseudocode of the PHyPO algorithm with the adaptive boosting training models of AMP and AMO, along with the process of generation of the datasets. Both of these algorithms are tuned with different hyper-parameters and are compared with other ensemble models as well, which include Subspace KNN, Bagging Trees, and other variants of Boosting Trees.

After the deployment of the trained models on the UE, Algorithm 1 is used to generate the label and perform the action upon it.

Algorithm 1 PHyPO scheme in mobile computing

Input: S, resolution, MaxComponents

Output: label1, label2, y₁, y₂

1. PD =^a Z_bPartitioning(S, resolution, MaxComponents)

2. For iteration = 1 to 1000

3.  P = GenerateRandomInteger [0, 1]

4.  f_cm = GenerateRandomInteger [10⁸, 10⁹]

5.  d = GenerateRandomInteger [20, 35000]

6.  LC = CalculateLocalCost(PD, f_cm)

7.  [EC, r_i, k_i] = CalculateEdgeCost(PD, d, f_cm)

8.  CC = CalculateCloudCost(PD, f_cm)

9.  [row, col] = Size(PD)

10.  For k = 1 to row

11.   if P = 0

12.    ALL_COST = [LC(k), EC(k), CC(k)]

13.   else

14.    ALL_COST = [LC(k), EC(k)]

15.   End if

16.   CMB_COST = AllCombinations(ALL_COST)

17.   temp = Sum(CMB_COST(Rows))

18.   index = Min(temp)

19.   TEMP2 = V(index)

20.   For j = 1 to col

21.    if TEMP2(k, j) = LC(k, j)

22.     OP = 1

23.    else if TEMP2(k, j) = EC(k, j)

24.     OP = 2

25.    else if TEMP2(k, j) = CC(k, j)

26.     OP = 3

27.    End if

28.   End For

29.  End For

30.  temp3 = Sum(TEMP2(Rows))

31.  [MinCost, index2] = Min(temp3)

32.  label2(iteration) = OP(index2)

33.  label1 = Length(label2)

34.  DS1(iteration) = [S,P,f_cm,d,r_i,k_i,resolution,label1]

35.  DS2(iteration) = [S,P,f_/cm,d,r_i,k_i,resolution,label1, label2]

36. End For

37. AMP = AutoML(DS1_train)

38. AM0 = AutoML(DS2_train)

39. y₁ = Test(AMP(DS1_test))

40. y₂ = Test(AMP(DS2_test)) Here, S is the size of the task, resolution is the size of a minimum possible partition, and MaxComponents is the number of components the task is decomposed into. y₁ is the test label of the ML model AMP and y₂ is the test label of AMO, both of which are determined by training both the datasets, DS1_train and DS2_train, in AutoML.

Dataset description

A multi-user scenario was considered where each UE could move within the range of ±100 meters during the processing of sub-tasks. The CPU frequency of UE ranged from 0.1 to 1 GHz and different task sizes were considered, ranging from 100 MB to 2 GB with different partitioning resolutions. For communication between UE and the edge server, a 4G band was used and the value of the distance between UE and the edge server varied from 20 meters to 35 km. As the edge server resources are limited, the possibility of 0 CPU cores available at the edge server was also considered. To generate a comprehensive dataset that incorporated each possible input scenario, the optimal cost for each task size was generated multiple times.

Evaluation parameters

The performance of the proposed algorithm was evaluated on the basis of the normalized cost of different execution schemes, testing accuracy of ML models, prediction time of the ML models, and the computational complexity of the model. The execution schemes include the proposed algorithm, total local execution, total edge server offloading, and total cloud server offloading. Table 3 shows the values of the parameters that were fixed before the simulations were carried out. The values of these parameters were determined by using 4G as a communication band for the communication between the edge server and UE. For communication between UE and the cloud server, the communication parameters used in WiFi were used.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 3. Configuration of simulation parameters.

https://doi.org/10.1371/journal.pone.0314198.t003

Performance of cost function for time-insensitive tasks

The average cost of PHyPO for each task size is compared with the cost of executing the whole task on UE or offloading the whole task on the edge server or cloud server. Fig 4 shows the comparison between all the execution schemes, where despite the linear increase in the cost with respect to the task size, the average normalized cost of PHyPO is lesser than the other costs. The average cost of PHyPO is lesser than the rest, and the performance of cloud computing is better than the other schemes, as the bandwidth of the cloud communication channel is considered to be 4 times the one used to communicate with the edge. The cost of edge computing is affected by its dependency on the number of available sub-carriers and the available CPU cores, with the cost resulting in infinity in case of no availability of cores, which is the reason behind the increase in the average cost. The service rate is also increased as the load on the edge server is lessened with the inclusion of a cloud server in the system model.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 4. Performance evaluation of different schemes for time-insensitive tasks.

https://doi.org/10.1371/journal.pone.0314198.g004

Performance of cost function for time-sensitive tasks

For time-sensitive tasks, the sub-tasks are offloaded only on the edge server or are executed locally, as cloud servers introduce more latency. Fig 5 shows the difference in average normalized cost of all three schemes, with a significant improvement in the PHyPO scheme results, as the latency and energy consumption both are reduced to a great extent. The great improvement in the performance of PHyPO in Fig 5 is also caused by the pre-calculation of an optimal number of partitions, as the number of components is not fixed in this model and each possible policy of partitioning a task is considered.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 5. Performance evaluation of different schemes for time-insensitive tasks.

https://doi.org/10.1371/journal.pone.0314198.g005

AMP: AdaBoost based model for optimal partitioning

The first generated dataset is trained for multiple traditional ML models, which included Fine Tree, Coarse KNN, TriLayered NN, Fine Gaussian SVM, and an AutoML-tuned AdaBoost classifier. Fig 6 shows the comparison between all the mentioned models for the parameters of testing time and accuracy. The optimization time for an AMP is 0.7 seconds, which is relatively larger than the rest of the algorithms, but the reduction in error rate compensates for that. The performance of different bagging, boosting, and subspace ensemble methods were compared, and the best-performing ones are reported in Table 4. The proposed model, AMP, is also optimized via AutoML and tuned for various hyper-parameters for Bagging, RUSBoost, and AdaBoost Tree. Table 5 depicts the parameters that were tuned in different iterations to reduce the classification error rate.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 6. Performance of traditional ML algorithms for optimal partitioning scheme.

https://doi.org/10.1371/journal.pone.0314198.g006

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 4. Performance of different ensemble algorithms for optimal partitioning policy.

https://doi.org/10.1371/journal.pone.0314198.t004

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 5. Tuning of hyper-parameters in each iteration for AMP.

https://doi.org/10.1371/journal.pone.0314198.t005

The training accuracy of the last 2 iterations in Table 5 has very little difference but due to the 44447 number of splits in the Bagging model, the testing time is much greater than the AMP. Any further tuning showed no improvement in the performance. Also, the reason behind a relative increase in the testing time of AMP than the rest of the ML models, as shown in Fig 6, is the greater number of learners than the other models having simple architectures, with the learners being DTs in this case.

AMO: AdaBoost based model for optimal offloading

The second dataset resulting from the concatenation of the first dataset and the output of AMP was also trained using AutoML, with the best results achieved by the AdaBoost model with differently tuned hyper-parameters, and compared with different conventional ML models. Fig 7 shows the comparison between Fine Tree, Coarse KNN, TriLayered NN, Fine Gaussian SVM, and the proposed AdaBoost-based Model for optimal Offloading (AMO). The performance of the proposed model AMO is seen to be better than the rest of the models with the least amount of classification error, along with the prediction time of 0.02 seconds, which is not much greater than the rest of the models. Due to a 0.6% error reduction in AMP as compared to Fine Tree, the latter is not considered the optimal model for offloading policy. Table 6 shows the comparison between different ensemble learning methods which included Subspace KNN, Bagging, and Boosting trees, while the best-performing ones are also mentioned in the table. The proposed model AMO to solve the second problem of optimal offloading policy performs better than the rest of the algorithms mentioned in Table 6 due to its simpler architecture and comprehensive dataset. This model is also optimized by tuning its hyper-parameters in various iterations along with the comparison with other ensemble models, which include Bagging, RUSBoost, and AdaBoost Tree, as shown in Table 7. The error reduction stopped after only a few iterations, from 6% to 5.8% error in prediction. The testing time of AMO is smaller than that of AMP due to the fewer number of learners and splits of the model.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 7. Performance of traditional ML algorithms for optimal offloading scheme.

https://doi.org/10.1371/journal.pone.0314198.g007

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 6. Performance of different ensemble algorithms for optimal offloading policy.

https://doi.org/10.1371/journal.pone.0314198.t006

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 7. Tuning of hyper-parameters in each iteration for AMO.

https://doi.org/10.1371/journal.pone.0314198.t007

Critical discussion

A novel algorithm to address the problem of data partitioning and offloading in MC is presented in this paper. A comprehensive dataset is simulated, containing different environmental scenarios, which is trained using an ML model to optimize the number of partitions and their offloading destinations, for time-sensitive tasks. From 100 MB to 1.2 GB, the dataset was generated for every task size with a gap of 50MB, but due to resource limitation, the gap between 1.2 GB to 2 GB was maintained as 100 MB, which is a limitation of our dataset. In our future work, we will seek to address this limitation by creating a model that trains itself in the run-time by using the test data of different sizes. Tasks are partitioned and offloaded without scheduling them first, which can be addressed in the future by scheduling them on the basis of priority and then partitioning them.

The parameters on which the proposed model is evaluated are average offloading energy consumption and latency, which are the most commonly used evaluation parameters and are also the indicator of quality of service in the literature. Thus, we have shown to achieve an overall higher quality of service. We aim to evaluate PHyPO on the basis of other evaluation parameters in the future, including task completion rate, and by using more resources for data training and testing. The technique of AutoML is used to determine the optimal model for the given data, along with the hyper-parameters. The training and testing accuracy of both the models, i.e., AMP and AMO, show that the data provided for training the model is comprehensive and contains all the relevant information required for prediction. The use of AdaBoost results in improved performance as it tunes the local parameters, which are used in each dataset, with respect to the weaknesses found in the previous one. The other hyper-parameters involved are tuned via AutoML to generate a model, which works optimally in each scenario. The prediction time of AMP is relatively high as compared to AMO due to more number of splits and number of learners. The data is tested in run-time using a distributed architecture, where with an insignificant increase in prediction time, near-optimal results are achieved, with the prediction accuracy of AMP being 96.1% and that of AMO being 94.3%. The achieved accuracy for both the algorithms is higher than the existing literature reviewed in the Literature review section, along with the proposed model being lightweight. We aim to improve this accuracy further in the future by performing data analysis and exploring other ML algorithms. This research can also be extended with the implementation of such a model, which can not only do optimal offloading but also solve the issue of resource allocation. Other aspects to explore in our future work are to apply task scheduling [64] before offloading, and the identification of tasks that cannot be partitioned in order to offload them accordingly.