Joint UAV Deployment and Task Offloading in Large-Scale UAV-Assisted MEC: A Multiobjective Evolutionary Algorithm

Abstract

With the development of digital economy technologies, mobile edge computing (MEC) has emerged as a promising computing paradigm that provides mobile devices with closer edge computing resources. Because of high mobility, unmanned aerial vehicles (UAVs) have been extensively utilized to augment MEC to improve scalability and adaptability. However, with more UAVs or mobile devices, the search space grows exponentially, leading to the curse of dimensionality. This paper focus on the combined challenges of the deployment of UAVs and the task of offloading mobile devices in a large-scale UAV-assisted MEC. Specifically, the joint UAV deployment and task offloading problem is first modeled as a large-scale multiobjective optimization problem with the purpose of minimizing energy consumption while improving user satisfaction. Then, a large-scale UAV deployment and task offloading multiobjective optimization method based on the evolutionary algorithm, called LDOMO, is designed to address the above formulated problem. In LDOMO, a CSO-based evolutionary strategy and a MLP-based evolutionary strategy are proposed to explore solution spaces with different features for accelerating convergence and maintaining the diversity of the population, and two local search optimizers are designed to improve the quality of the solution. Finally, simulation results show that our proposed LDOMO outperforms several representative multiobjective evolutionary algorithms.

1. Introduction

With advances in Internet of Things (IoT) technology, numerous digital economy applications with compute-sensitive and latency-sensitive characteristics, such as augmented reality (AR), virtual reality (VR), and autonomous driving, have emerged, significantly enhancing the user experience [1,2]. Traditional cloud computing, which relies on long-distance communication with centralized data centers, fails to meet the stringent requirements of these applications. Therefore, mobile edge computing (MEC) has emerged as an effective complementary paradigm [3]. By enabling mobile devices to offload tasks to edge base stations, MEC offers reduced latency and energy consumption, thereby improving task completion efficiency [4]. This capability positions MEC as a viable solution for executing compute-intensive and latency-critical tasks, thereby enhancing overall quality of service (QoS) for digital economy applications [5,6,7]. Nevertheless, the location of the edge base station in MEC is usually fixed and cannot be flexibly changed according to the dynamic needs of mobile devices, which limits the adaptability and responsiveness of MEC.

To address these above limitations, unmanned aerial vehicles (UAVs) have emerged as a promising solution to augment MEC, in both military and civilian applications [8,9,10]. The dynamic integration of UAC and MEC is particularly evident in scenarios such as natural disaster relief, field operations, and large-scale competition events, where UAVs act as communication relay stations or efficient edge computing platforms [11]. Unlike fixed base stations, UAV-assisted MEC leverages the high mobility and adaptability of UAVs to establish superior line-of-sight links, thereby reducing transmission distances, enhancing communication reliability, and conserving the battery life of mobile devices [12]. For example, in wildfire rescue operations, UAVs with MEC capabilities can collect and process real-time data, establish communication relays where terrestrial networks fail, and optimize resource allocation to enhance rescue coordination. Consequently, UAV-assisted MEC offers a transformative solution for improving quality of experience (QoE) across various dynamic and challenging environments.

In the realm of UAV-assisted MEC, optimizing the deployment of UAVs and the task offloading of mobile devices is essential for achieving an optimal system performance. However, existing studies primarily focus on small-scale scenarios involving single- or multi-UAV assisted MEC [13,14,15]. In order to obtain efficient optimization strategies, these studies predominantly rely on evolutionary algorithms to solve resource optimization problems in single- or multi-UAV-assisted MEC, such as genetic algorithm (GA) [16,17], particle swarm optimization (PSO) [18,19], and ant colony optimizer (ACO) [20,21]. However, when the number of UAVs or mobile devices increases, the search space exponentially expands as the dimensionality of the decision variables increases, which is known as the curse of dimensionality [22,23]. Therefore, for large-scale UAV-assisted MEC, existing methods encounter considerable difficulties when obtaining convergent optimization strategies.

To address the challenge of efficient UAV deployment and task offloading in a large-scale UAV-assisted MEC, this paper introduces a large-scale UAV deployment and task offloading multiobjective optimization method based on the evolutionary algorithm, namely LDOMO. Specifically, LDOMO first competitively divides the entire solution space into an elite solution space with well-performing individuals and a poor solution space with bad-performing individuals, which provides important labels and guidance for population evolution. Then, the competitive swarm optimizer (CSO)-based evolutionary strategy and the multilayer perceptron (MLP)-based evolutionary strategy are proposed in LDOMO to explore the two solution spaces separately. The former accelerates the convergence of the population by guiding the poor solutions closer to the elite solutions, while the latter guides the elite solutions into more promising areas through the evolutionary directions learned by MLP to maintain the diversity of the population. Finally, to address feasibility issues and elevate solution quality, LDOMO incorporates two local search optimizers: one for UAV deployment to prevent collisions by maintaining safe distances, and another for task offloading to ensure the accomplishment of all tasks.

The main contributions of this paper are clarified as follows.

• This paper focuses on UAV deployment and task offloading optimization in a large-scale UAV-assisted MEC and formulates it as a large-scale multiobjective optimization problem, consisting of two optimization objectives (i.e., energy consumption and user satisfaction) with several constraints.
• This paper proposes an efficient multiobjective optimization evolutionary algorithm, called LDOMO, to address the above-formulated problem. Specifically, LDOMO proposes two evolutionary strategies to explore two solution spaces with different characteristics for accelerating convergence and maintaining the diversity of population, and and designs two local search optimizers to improve the quality of the solution.
• Extensive simulation results show that LDOMO outperforms several representative multiobjective optimization algorithms in terms of energy consumption and user satisfaction.

The rest of the paper is organized as follows. Section 2 reviews the background of large-scale multiobjective optimization and related work. Section 3 introduces several mathematical models and the problem formulation. Section 4 presents the details of the proposed algorithm. Section 5 provides simulation results and discussions. Finally, Section 6 provides conclusions and future work.

2. Background and Related Work

2.1. Large-Scale Multiobjective Optimization

In the realm of large-scale multiobjective optimization (LMOP), the goal is to concurrently minimize or maximize multiple objective functions that often contradict each other. Mathematically, an LMOP can be mathematically modeled as follows:

$$\begin{array}{cc}\hfill \underset{x\in \Omega }{min}& F\left(x\right)={\left(f_1\left(x\right),f_2\left(x\right),\dots ,f_m\left(x\right)\right)}^T,\hfill \\ \hfill \mathrm{s}.\mathrm{t}.& g_i\left(x\right)\le 0,\forall i\in \Theta ,\hfill \end{array}$$

(1)

where the objective vector $F\left(x\right)$ comprises m conflicting objective functions $f_i\left(x\right)$ and $x=(x_1,x_2,\dots ,x_n)$ symbolizes an n-dimensional decision vector within the search space $\Omega$ ($m\ge 2$ and $n\ge 1000$). In order to balance multiple conflicting optimization objectives, the goal of optimizing an LMOP is to obtain a set of Pareto-optimal solutions (PS) in its search space, and the mapping of PS in the objective space is called the Pareto frontier (PF), which is described as follows.

If two solutions a and b exist in the search space $\Omega$, a dominates b ($a\prec b$) if $f_i\left(a\right)\le f_i\left(b\right)$ for all i and $f_j\left(a\right)<f_j\left(b\right)$ for at least one j. A solution $x^{*}\in \Omega$ is non-dominated when no other solution in $\Omega$ dominates it. The set of non-dominated solutions constitutes the PS, and the corresponding objective values form the PF:

$$\begin{array}{cc}\hfill PS=& \left\{\forall x\in \Omega |\nexists y\in \Omega ,y\prec x\right\},\hfill \\ \hfill PF=& \left\{F\left(x^{*}\right),x^{*}\in PS\right\}.\hfill \end{array}$$

(2)

2.2. Related Work and Our Motivations

This section reviews the prior works most relevant to our work from two aspects: (1) task offloading in MEC and (2) UAV-assisted MEC networks, and clarifies the motivation of our work.

Task offloading in MEC: In recent years, task offloading in MEC has attracted great attention, as it can reduce the delay of computation-intensive tasks and energy consumption to effectively improve the system performance [24,25]. For example, Mei et al. [26] focused on the task offloading problem for MEC systems with multiple energy harvesting devices aiming to increase the throughput and extend the battery life of devices. They applied Liapunov optimization theory to design a computational task offloading algorithm to accommodate system dynamics and ensure system stability. Ren et al. [27] studied the task offloading problem in the scenario of multiple edge service providers, and proposed an ADMM-based internal load balancing algorithm and a dynamic two-stage non-cooperative game to reduce the delays of ESPs internally and externally, respectively. Deng et al. [28] investigated edge collaboration task offloading and splitting strategies in MEC networks, i.e., splitting tasks to be executed in parallel on multiple MEC servers aims to minimize the total cost of latency and energy consumption. They applied the alternating convex search algorithm to obtain optimized solutions withv a low computational complexity for the task offloading and splitting problems. Liu et al. [29] developed a task offloading model consisting of local edge computing resources, edge server resources at both macro and attached base stations, as well as cloud computing server resources. They developed an approach based on block coordinate descent technique combining convex optimization and gray wolf algorithm in order to simultaneously reduce latency and energy consumption. Zeng et al. [30] discussed task offloading in a multi-layer vehicular edge computing framework and proposed a prediction-based vehicular task offloading scheme, in which a deep learning model is designed to predict the task offloading result and service delay, and then the prediction policy with successful task offloading and minimum service delay is selected as the final offloading scheme.

UAV-assisted MEC networks: A number of research efforts have started to use UAVs as different types of wireless communication platforms, i.e., UAVs equipped with edge servers can be flexibly deployed in specific areas to provide reliable uplink and downlink communications to ground users [31,32]. Therefore, UAV deployment has become a key discussion issue in academia. In particular, a good UAV deployment can improve the quality and efficiency of task offloading for users and enhance the performance of the system [33,34]. Xu et al. [35] proposed a sky–air–ground integrated mobile edge computing system to provide high-quality computing services in areas with missing or damaged communication infrastructures and designed an algorithm based on particle swarm optimization and greedy strategies to obtain a near-optimal solution for UAV deployment and mission offloading in the system. Tian et al. [36] investigated the service satisfaction-oriented task offloading and UAV scheduling problem in UAV-assisted MEC networks, where the task priority was considered based on the latency requirement of tasks and the remaining energy status of users. To solve the proposed problem, they proposed a joint optimization algorithm for task offloading and UAV scheduling based on a genetic algorithm to maximize the total user satisfaction. To address the joint optimization of UAV deployment and offloading decisions in a three-layer UAV-assisted MEC network, Xia et al. [37] proposed a two-layer optimization algorithm to reduce the processing latency of the task, where a differential evolution learning algorithm was used in the upper layer to solve the UAV deployment problem, and a distributed deep neural network was used to generate the offloading decisions in the lower layer. Similarly, confronted with the joint optimization of UAV deployment and computational offloading problem in MEC, Chen et al. [38] designed a two-layer joint optimization approach to minimize the average task response time. First, the outer layer utilized a particle swarm optimization algorithm combined with a genetic algorithm operator to optimize UAV deployment. Second, the inner layer used a greedy algorithm to optimize task offloading.

However, none of the existing works seem to have address the specific challenges posed by large-scale UAV assistance in MEC, particularly in terms of UAV deployment and task offloading problems. In reality, many scenarios have large-scale UAV devices and users numbering more than 1000, such as city traffic management, large competition events, and natural disaster rescue. Nevertheless, existing algorithms encounter a significant challenge with the exponential growth of the search space as the number of devices and users increases, leading to the curse of dimensionality and inefficiency in search. Motivated by this gap, our work proposes a large-scale UAV deployment and task offloading multiobjective optimization method based on the evolutionary algorithm, termed LDOMO. Firstly, LDOMO divides the solution space into a poor solution space and an elite solution space to reduce the search space and improve the search efficiency. Thus, it designs a CSO-based evolutionary strategy and a MLP-based evolutionary strategy to optimize these two solution spaces, respectively. Finally, two local search optimizers are designed to prevent infeasible solutions and enhance the quality of solutions.

3. System Model and Problem Formulation

3.1. System Model and Assumption

As shown in Figure 1, there are I mobile devices, J UAVs, and a edge base station in the considered UAV-assisted MEC. Assume that the set of mobile devices is notated as $MD=\{m{d}_1,m{d}_2,\dots ,m{d}_I\}$ and the set of UAVs is denoted as $UAV=\{ua{v}_1,ua{v}_2,\dots ,ua{v}_J\}$. Moreover, the ith mobile device in the set $MD$ is expressed as $m{d}_i=〈D_i,C_i,{\psi }_i〉$, where $D_i$ denotes the task data size, $C_i$ denotes the CPU cycles per bit for task computation, and ${\psi }_i$ is the maximum tolerable delay for task of $m{d}_i$. The jth UAV in the set $UAV$ is denoted as $ua{v}_j=〈F_j,O_j〉$, where $F_j$ and $O_j$ are the computational and storage resources of $ua{v}_j$, respectively.

To accurately represent the positions of UAVs and mobile devices, a 3-dimensional Cartesian coordinate system was employed to model the stereospace of UAV-assisted MEC scenarios. In this system, the position of $m{d}_i$ was denoted as $(x_i^{md},y_i^{md},0)$ and the position of UAV $ua{v}_j$ was denoted as $(x_j^{uav},y_j^{uav},H)$. Note that all mobile devices were placed on the ground and all UAVs were deployed on a plane with height H. Assume that the locations of all UAVs were determined and deployed by the edge base station in the control center of the system. Please note that obstacles in UAV flight were not considered in this article. After that, mobile devices can select the nearest or suitable UAV to offload and execute the task according to the task requirements. A binary matrix $\mathbb{L}$ of size $I\times J$ is represented as task offloading decisions for all mobile devices, where the element $l_{ij}$ represents whether the task of $m{d}_i$ is offloaded to $ua{v}_j$. If the task is offloaded to $ua{v}_j$, $l_{ij}=1$, otherwise $l_{ij}=0$. For ease of description,

Table 1. Main notations.

Symbol	Definition
$MD$	the set of mobile devices
I	the number of mobile devices
$UAV$	the set of UAVs
J	the number of UAVs
$D_i$	the task data size of $m{d}_i$
$C_i$	the CPU cycles of $m{d}_i$
${\psi }_i$	the maximum admissible delay of $m{d}_i$
$F_j$	the computational resource of $ua{v}_j$
$O_j$	the storage resource of $ua{v}_j$
$(x_i^{md},y_i^{md},0)$	the spatial location of $m{d}_i$
$(x_j^{uav},y_j^{uav},H)$	the spatial location of $ua{v}_j$
$l_{ij}$	whether the task of $m{d}_i$ is offloaded to $ua{v}_j$
$B_{ij}$	the channel bandwidth between $m{d}_i$ and $ua{v}_j$
$P^t$	the transmit power
$P^h$	the hovering power of the UAV
${\theta }_i$	whether the task of $m{d}_i$ can be completed

summarizes the main notations in this article.

3.2. Task Offloading Model

There are two main processes involved in the process of task offloading, i.e., the communication process and the computation process. Specifically, in the communication process, the mobile device first communicates with the selected UAV and transmits tasks to the UAV. Then, in the computation process, the tasks of the mobile device are executed on the UAV. Finally, the result of the execution is returned to the mobile device. In this paper, the result return process is ignored because the result data are too small compared with the task data. The communication process and the computation process are discussed in detail subsequently.

Communication process: Assume that mobile devices communicate with UAVs through wireless links. In this case, the path-loss for the channel between the UAV and mobile device is given by,

$$Loss(m{d}_i,ua{v}_j)={\left(\frac{4\pi f}{c}\right)}^2\times {\left(d\left(m{d}_i,ua{v}_j\right)\right)}^{\alpha },$$

(3)

where f represents the central frequency, c is the speed of light, $\alpha$ represents the path-loss exponent, and $d(m{d}_i,ua{v}_j)$ means the distance between $m{d}_i$ and $ua{v}_j$, which is given as follows,

$$d(m{d}_i,ua{v}_j)=\sqrt{{(x_i^{md}-x_j^{uav})}^2+{(y_i^{md}-y_j^{uav})}^2+H^2}.$$

(4)

The signal-to-interference plus noise ratio (SINR) [39] of the communication link between $m{d}_i$ and $ua{v}_j$ is calculated as,

$$SINR(m{d}_i,ua{v}_j)=\frac{P^t\times g^2}{N_0\times Loss(m{d}_i,ua{v}_j)},$$

(5)

where $P^t$ represents the transmit power from the UAV to the mobile device, g is the channel fading coefficient, and $N_0$ is the noise power. The wireless transmission rate between $m{d}_i$ and $ua{v}_j$ is calculated based on the Shannon’s formula as follows,

$$R(m{d}_i,ua{v}_j)=B_{ij}\times {log}_2\left(1+SINR(m{d}_i,ua{v}_j)\right),$$

(6)

where $B_{ij}$ is the channel bandwidth between $m{d}_i$ and $ua{v}_j$.

When $m{d}_i$ chooses to offload its task to $ua{v}_j$, i.e., $l_{ij}=1$, then the communication time between them depends on the task size and transmission rate, which is calculated as follows,

$$\overrightarrow{T}(m{d}_i,ua{v}_j)=\frac{l_{ij}{D}_i}{R(m{d}_i,ua{v}_j)}.$$

(7)

Moreover, the corresponding energy consumption during communication can be given as,

$$\overrightarrow{E}(m{d}_i,ua{v}_j)=P^t\times \frac{l_{ij}{D}_i}{R(m{d}_i,ua{v}_j)}.$$

(8)

Communication process: After the mobile device has completed the task transmission, the task will be executed on the transferred UAV. In this paper, the computing power allocated to $m{d}_i$ from $ua{v}_j$ depends on the maximum allowable delay of the task aiming to equitably distribute the computational resources of the UAV. Therefore, the computing power is calculated as follows,

$$f(m{d}_i,ua{v}_j)=\frac{{\psi }_i^{-1}}{{\sum }_{m{d}_k\in MD\left(ua{v}_j\right)}{\psi }_k^{-1}}\times F_j,$$

(9)

where $MD\left(ua{v}_j\right)$ denotes the set of all mobile devices that offloaded tasks to $ua{v}_j$. According to (9), the more urgent the task of the mobile device, the more computing power is allocated to it.

Moreover, the computation time of task for $m{d}_i$ on $ua{v}_j$ is given as,

$$\widehat{T}(m{d}_i,ua{v}_j)=\frac{l_{ij}{C}_i{D}_i}{f(m{d}_i,ua{v}_j)}.$$

(10)

Following [40], the corresponding energy consumption during computation is modeled as a function related to the computing power, which is given below,

$$\widehat{E}(m{d}_i,ua{v}_j)=\gamma l_{ij}{C}_i{D}_i{\left(f(m{d}_i,ua{v}_j)\right)}^2,$$

(11)

where $\gamma$ is the computing energy efficiency coefficient.

3.3. UAV Hover Model

When UAVs provide computing services for mobile devices, they need to hover at a fixed location to ensure uninterrupted communication and quality of service. In this process, the hovering time of UAV depends on the maximum time of receiving and executing tasks, which is calculated as follows,

$$\overline{T}\left(ua{v}_j\right)=\underset{m{d}_k\in MD\left(ua{v}_j\right)}{max}\left(\overrightarrow{T}(m{d}_k,ua{v}_j)+\widehat{T}(m{d}_k,ua{v}_j)\right).$$

(12)

Moreover, the hovering energy consumption of UAV is given as follows,

$$\overline{E}\left(ua{v}_j\right)=P^h\times \overline{T}\left(ua{v}_j\right),$$

(13)

where $P^h$ is the hovering power of the UAV.

3.4. Problem Formulation

Based on the above models, the task completion time for each mobile device is as follows,

$$\begin{array}{cc}\hfill T\left(m{d}_i\right)& =\sum _{j=1}^J\left(\overrightarrow{T}(m{d}_i,ua{v}_j)+\widehat{T}(m{d}_i,ua{v}_j)\right)\hfill \\ & =\sum _{j=1}^J\left(\frac{l_{ij}{D}_i}{R(m{d}_i,ua{v}_j)}+\frac{l_{ij}{C}_i{D}_i}{f(m{d}_i,ua{v}_j)}\right).\hfill \end{array}$$

(14)

Moreover, user satisfaction depends on whether their computational task is completed within the maximum allowable delay. Specifically, the ith user is satisfied if $T\left(m{d}_i\right)\le {\psi }_i$, denoted as ${\theta }_i=1$, and ${\theta }_i=0$ otherwise. In this paper, the task completion rate of all users is represented as the user satisfaction in the whole system, which is calculated as,

$$S=\frac{1}{I}\sum _{i=1}^I\left({\theta }_i\right).$$

(15)

The total energy consumption of the system is denoted as,

$$E=\sum _{i=1}^I\sum _{j=1}^J\left(\overrightarrow{E}(m{d}_i,ua{v}_j)+\widehat{E}(m{d}_i,ua{v}_j)\right)+\sum _{j=1}^J\left(\overline{E}\left(ua{v}_j\right)\right).$$

(16)

In this paper, the joint optimization problem of UAV deployment and task offloading is modeled as a large-scale multiobjective optimization problem with the purposes of reducing energy consumption and user satisfaction. Mathematically, the formulated problem is defined as follows,

$$\left\{\begin{array}{c}\underset{{\mathbf{x}}^{uav},{\mathbf{y}}^{uav},\mathbb{L}}{max}S\hfill \\ \underset{{\mathbf{x}}^{uav},{\mathbf{y}}^{uav},\mathbb{L}}{min}E\hfill \end{array}\right.$$

(17)

$$s.t.\sum _j^J{l}_{ij}=1,\forall i\in I,$$

(18)

$$\sum _i^I\left(l_{ij}{f}_{ij}\right)\le F_j,\forall j\in J,$$

(19)

$$\sum _i^I\left(l_{ij}{d}_{ij}\right)\le O_j,\forall j\in J,$$

(20)

$$f_{ij}>0,\forall i\in I,\forall i\in J,$$

(21)

$$l_{ij},{\theta }_i\in \{0,1\},\forall i\in I,\forall i\in J.$$

(22)

In the formulated model, the primary goal is to maximize the user satisfaction of mobile devices while minimizing the energy consumption of system in (17) with three decision variables and several constraints. Specifically, the real decision variables ${\mathbf{x}}^{uav}$ and ${\mathbf{y}}^{uav}$ denote the horizontal position of the UAV. The binary decision variable $\mathbb{L}$ represents the task offloading scheme of the user. Constraint (18) guarantees that the task of each mobile device can be offloaded to only one UAV. Moreover, constraints (19) and (20) ensure that the computational and storage resources of each UAV cannot be exceeded, respectively. Constraints (21) and (22) define the range of values for some parameters.

4. Optimization Method

In this section, we propose a multiobjective optimization evolutionary algorithm to solve the above formulated large-scale multiobjective optimization problem in (17), called LDOMO. First, the framework of LDOMO is presented, and then the details of LDOMO are introduced subsequently.

4.1. The Overall Framework

This section presents the general framework of LDOMO proposed in this paper. The flowchart and pseudocode of LDOMO are shown in Figure 2 and Algorithm 1, respectively. As shown in Algorithm 1, LDOMO starts with two input data: a list of UAVs and a list of mobile devices. Then, the initialization process is executed in lines 1 and 2, where a population $Pop$ and a $\mathbf{MLP}$ are initialized, as detailed in Section 4.2. Subsequently, LDOMO enters the main loop in lines 3 to 7, which consists of three core processes (i.e., competition phase, evolution phase, and optimization phase). In the competition phase (line 4), the entire population is split into two equal-sized sets, including an elite solution set ${\mathbf{X}}_e$ with a better performance and a poor solution set ${\mathbf{X}}_p$ with a worse performance. This competitive operation provides important labels and guidelines for the subsequent evolution phase, which is described in Section 4.3. In the evolution phase (line 5), two different evolutionary strategies are employed in LDOMO to evolve ${\mathbf{X}}_p$ and ${\mathbf{X}}_e$, respectively, i.e., CSO-based evolutionary strategy and MLP-based evolutionary strategy. Specifically, in the CSO-based evolutionary strategy, the poor solutions in ${\mathbf{X}}_p$ learn directly from the elite solutions in ${\mathbf{X}}_e$ to accelerate population convergence. Moreover, in the MLP-based evolutionary strategy, MLP is trained to learn the gradient direction of the evolutionary process by adopting the poor and elite solutions. After that, the elite solutions in ${\mathbf{X}}_e$ are evolved through the trained MLP to maintain the population diversity and enhance the population quality. Note that details of the two evolutionary strategies are presented in Section 4.4. To further improve the quality of the solution in $Pop$, the UAV deployment and task offloading for each solution are optimized in line 6 via two local search optimizers, i.e., a deployment optimizer and an offloading optimizer. In the deployment optimizer, redundant UAVs in each solution are eliminated based on the distance between UAVs to reduce energy consumption. Moreover, in the offloading optimizer, the failed tasks in each solution are assigned feasible UAVs as much as possible to improve user satisfaction. Note that the details of local search optimizers are presented in Section 4.5. Finally, the entire evolutionary loop is terminated when the maximum number of generations $t_{max}$ is reached, and the final population obtained by LDOMO is output.

Algorithm 1 LDOMO

Input:  $UAV$ list, $MD$ list. Output:  The final population $Pop$.  1: initialize a population $Pop$;  2: initialize a MLP;  3: for $t:$ 1 to $t_{max}$ do  4:     ${\mathbf{X}}_e,{\mathbf{X}}_p\leftarrow$ Competition Phase($Pop$);\\Algorithm 2  5:     $Pop\leftarrow$ Evolution Phase(MLP, ${\mathbf{X}}_e,{\mathbf{X}}_p$);\\Algorithm 3  6:     Optimization Phase($Pop$);\\Algorithm 4  7: end for

4.2. Population Initialization

Regarding the population representation and initialization, an equal-length integer encoding is employed to represent each solution in the population. Specifically, the locations of all UAVs and the decisions of all mobile devices are encoded in one solution. For example, in an MEC environment of $10\times 10$ m² with two UAVs and three mobile devices, a solution is encoded as 2415221. The first four bits of the solution (i.e., 2415) indicate that the locations of the first and the second UAVs are (2 m, 4 m) and (1 m, 5 m), respectively. Moreover, the last three bits (i.e., 221) indicate the first two mobile devices offload the task to the second UAV, and the last one offloads to the first UAV. As for the population initialization, N solutions are randomly generated to form an initial population $Pop$ that is evolved and optimized in subsequent sections.

4.3. Competition Phase

In order to clearly distinguish the quality of solutions, a competitive strategy in LDOMO is used to divide the population into two sets by employing fast non-dominated sort [41] and crowding distance [42], including a poor solution set with a worse performance and an elite solution set with a better performance. As for the fast non-dominated sort, if solution $x^{*}$ is not worse than any solution after competition, it is called a non-dominated solution and its ranking level is $0(Rank\left(x^{*}\right)=0)$. After removing the solutions with a ranking level of 0, if solution $x^{\prime }$ is not worse than the remaining solutions, the ranking level of $x^{\prime }$ is $1(Rank\left(x^{\prime }\right)=1)$. Through analogy, the ranking level of all solutions can be calculated. Please note that the lower the ranking levels of the solution, the better the quality of the solution. However, when the solutions are in the same ranking level, the quality of them cannot be determined due to the fact that the solution has multiple optimization objectives. In this case, the crowding distance is used to further sort these solutions, which is calculated as follows,

$$\left\{\begin{array}{cc}CD\left(x_i\right)=\infty ,& i=1orn,\\ CD\left(x_i\right)={\sum }_m^M{\sum }_i^I\frac{f_m\left(x_{i+1}\right)-f_m\left(x_{i-1}\right)}{f_m^{max}-f_m^{min}},& i=2,\dots ,n-1,\end{array}\right.$$

(23)

where n represents the number of solutions and $f_m^{max}$ and $f_m^{min}$ are the maximum and minimum values of the mth objective function. In summary, all of the solutions in the population can be ranked from good to bad according to the following conditions,

$$\begin{array}{c}\left\{\begin{array}{c}Rank\left(x_i\right)<Rank\left(x_j\right),\hfill \\ Rank\left(x_i\right)=Rank\left(x_j\right)andCD\left(x_i\right)>CD\left(x_j\right).\hfill \end{array}\right.\end{array}$$

(24)

After the solution is sorted, the first $N/2$ solutions are labeled as elite and added to the set ${\mathbf{X}}_e$, while the remaining solutions are added to the set ${\mathbf{X}}_p$. Through this competitive strategy, LDOMO can efficiently rank solutions with multiple optimization objectives and provide critical labels and guidance for subsequent population evolution.

Algorithm 2 presents the pseudocode of the competition phase with the current population $Pop$ as the input. In particular, two empty sets, ${\mathbf{X}}_e$ and ${\mathbf{X}}_p$, are initialized in lines 1 and 2 to store the elite and poor solutions, respectively. Subsequently, the fitness of all solutions in $Pop$ is calculated based on Equations (15) and (16) in line 3, which serves as a metric for solution competition and is stored in the set $Fit$. Then, the solutions in $Pop$ compete with each other and are sorted in lines 4–6. Specifically, in line 4, a fast non-dominated sort is performed according to $Fit$ and the ranking levels of all solutions are stored in set $Rank$. In line 5, the crowding distances of solutions with the same ranking level are calculated and added to set $CD$. In line 6, the solutions in $Pop$ are sorted from good to bad according to Equation (24), with $Rank$ and $Fit$ as inputs. After that, the sorted solutions are labeled in lines 7–13. The first $N/2$ solutions are labeled as elite solutions and added to set ${\mathbf{X}}_e$ in line 9. The remaining solutions are labeled as poor solutions and added to ${\mathbf{X}}_p$ in line 11. Finally, the set of elite solutions ${\mathbf{X}}_e$ and the set of poor solutions ${\mathbf{X}}_p$ are returned in line 14.

Algorithm 2 Competition Phase

Input:  $Pop$. Output:  ${\mathbf{X}}_e$, ${\mathbf{X}}_p$.  1: initialize an empty set ${\mathbf{X}}_e$ to store the elite solutions;  2: initialize an empty set ${\mathbf{X}}_p$ to store the poor solutions;  3: $Fit\leftarrow$ calculate the fitness of solutions in $Pop$ based on (15) and (16);  4: $Rank\leftarrow$ non-dominated sorting of solutions in $Pop$ according to $Fit$;  5: $CD\leftarrow$ calculate the crowding distance of solutions based on $Rank$ and $Fit$;  6: $Po{p}_{sort}\leftarrow$ sort the solutions in $Pop$ according to (24);  7: for $x\in Po{p}_{sort}$ do  8:     if x ranks in the first $N/2$. then  9:          ${\mathbf{X}}_e\leftarrow$ add x as an elite solution; 10:     else 11:         ${\mathbf{X}}_p\leftarrow$ add x as a poor solution; 12:     end if 13: end for 14: return ${\mathbf{X}}_e$, ${\mathbf{X}}_p$.

4.4. Evolution Phase

In the process of the population evolution phase, LDOMO needs to optimize the UAV deployment and task offloading decisions in each solution. In fact, the real-life UAV deployment and task offloading problem is a large-scale optimization problem due to the dimension of its search space being larger than 1000. However, traditional evolutionary algorithms face large-scale optimization problems with rapidly decreasing efficiency due to dimensionality catastrophe. Inspired by [43,44], two different evolutionary strategies are employed in LDOMO to explore different solution spaces (${\mathbf{X}}_p$ and ${\mathbf{X}}_e$), i.e., the CSO-based evolutionary strategy and the MLP-based evolutionary strategy. Specifically, the former strategy makes the poor solutions in ${\mathbf{X}}_p$ quickly approach the elite solutions in ${\mathbf{X}}_e$ as a way to accelerate population convergence. Meanwhile, the latter strategy exploits the gradient direction of population evolution learned by the MLP to guide elite individuals in ${\mathbf{X}}_e$ to more promising regions, which maintains the diversity of population and further enhances the quality of population. Employing different search strategies for different features of the solution space, LDOMO can overcome the challenges posed by dimensional catastrophe in large-scale optimization. Note that the operational procedures and specific details of population evolution phase are given subsequently.

In the CSO-based evolutionary strategy, the poor solutions in ${\mathbf{X}}_p$ observe and learn the behavior of the elite solutions in ${\mathbf{X}}_e$. This learning process facilitates knowledge transfer from the elite to the poor solutions, which promotes the convergence of the population. Assuming that the velocity and position of the poor solution are $v_p$ and $x_p$, respectively, their update equations are as follows,

$$v_p(t+1)=r_1\times v_p\left(t\right)+r_2\times \left(x_e\left(t\right)-x_p\left(t\right)\right)+\phi \times r_3\times (\overline{x}\left(t\right)-x_p\left(t\right)),$$

(25)

$$x_p(t+1)=x_p\left(t\right)+v_p(t+1),$$

(26)

where $r_1$, $r_2$, and $r_3$ are three random numbers ranging from 0 to 1, t represents the t-th iteration, $x_e\left(t\right)$ is the position of an elite solution, $\overline{x}\left(t\right)$ is the mean position of all solutions in the t-th iteration, and $\phi$ is a control parameter of $\overline{x}\left(t\right)$. On the other hand, it is difficult for elite solutions to learn implicit knowledge from themselves for further evolution, because they are in the vicinity of a locally optimal solution. Therefore, a multilayer perceptron(MLP) in LDOMO is used to explore more promising regions to guide the evolution of elite solutions. In the MLP-based evolutionary strategy, a three-layer MLP is trained by taking ${\mathbf{X}}_p$ as the input, while labeling ${\mathbf{X}}_e$ as the target output. In this supervised learning way, the MLP can learn the possible fast convergence direction for the input solutions. Subsequently, using the trained MLP, the velocities and positions of the elite solutions in ${\mathbf{X}}_e$ are updated in the following way.

$$v_e(t+1)=v_e\left(t\right)+r_1(x_{MLP}\left(t\right)-x_e\left(t\right))+r_2(x_{best}\left(t\right)-x_e\left(t\right))+r_3(x_{rd1}\left(t\right)-x_{rd2}\left(t\right)),$$

(27)

$$x_e(t+1)=x_e\left(t\right)+v_e(t+1),$$

(28)

where $x_{MLP}$ is the output solution by inputting $x_e$ to the trained MLP, $x_{best}$ is the historically best solution for the entire population, $x_{rd1}$ and $x_{rd2}$ are two randomly selected solutions from the current population, respectively. Obviously, the evolution of the solution x defined in (27) consists of three search components: one is a self-acceleration component provided by the knowledge of MLP (i.e., $x_{MLP}\left(t\right)-x_e\left(t\right)$), the second one is the global acceleration component guided by the global best solution (i.e., $x_{best}\left(t\right)-x_e\left(t\right)$), and the last one is the differential-regulation component guided by other solutions (i.e., $x_{rd1}\left(t\right)-x_{rd2}\left(t\right)$). In this way, the convergence of population evolution can be accelerated by following the fast convergence direction provided by MLP, while the correctness of the convergence direction can be guaranteed by the guidance of the global best solution. In addition, differential regulation prevents the evolutionary process from falling into a local optimum to some degree.

Algorithm 3 presents the pseudocode of population evolution. In particular, an empty set $Qsp$ is firstly initialized in line 1 to store the offspring. Subsequently, two critical evolutionary strategies of LDOMO are implemented in lines 2–17. Specifically, the main loop of the CSO-based evolutionary strategy is accessed in line 2. Then, in line 3, an elite solution is randomly selected from ${\mathbf{X}}_e$ for guiding the current poor solution evolution. The mean position of all solutions in $Pop$ is calculated and noted as $\overline{x}$ in line 4. In lines 5 and 6, the velocity and position of $x_p$ are sequentially updated according to (25) and (26). The updated $x_p$ is added to $Qsp$ in line 7. After all of the solutions in ${\mathbf{X}}_p$ have been updated, the MLP-based evolutionary strategy is executed to update the elite solutions in ${\mathbf{X}}_e$ in lines 9–17. The MLP is firstly trained by inputting ${\mathbf{X}}_e$ and ${\mathbf{X}}_p$ in line 9. Then, solutions $x_{MLP}$, $x_{best}$, $x_{rd1}$, and $x_{rd2}$ are generated sequentially for assisted evolution in lines 11–13. After that, the velocity and position of $x_e$ are sequentially updated according to (27) and (28) in lines 14 and 15. In line 16, the updated $x_e$ is added to $Qsp$. Finally, $Qsp$ is returned as the next generation population in line 18.

4.5. Optimization Phase

In the process of population evolution, UAV deployments in each solution may appear aggregation and uneven distribution due to the stochastic nature of evolutionary algorithms. However, overcrowded UAVs lead to wasted computational resources or even economic losses due to crashes. Therefore, a local search optimizer is designed to optimize the deployment of UAVs by eliminating redundant UAVs that are too close together. In this way, the safety of UAVs is ensured and energy consumption can be reduced by reducing the number of UAVs. In order to further improve the quality of solutions at the same time, another local search optimizer was designed in LDOMO to optimize task offloading for each solution to enhance user satisfaction. Specifically, for each failed task that cannot be completed before the maximum allowable delay $T_{max}$, the first feasible UAV is selected as the new offloading scheme for the failed task from the UAV list based on the first-come-first-served principle. Note that this process ensures that the original successful tasks are completed normally and will be stopped when a suitable UAV is found. In this way, LDOMO is able to maximize the user satisfaction, thus improving the reliability of the system and enhancing the user experience.

Algorithm 3 Evolution Phase

Input:  MLP, ${\mathbf{X}}_e$, ${\mathbf{X}}_p$. Output:  $Qsp$.  1: initialize the offspring $Qsp$; ${/}^{*}$ Access to CSO-based evolutionary strategy.  2: for each $x_p\in {\mathbf{X}}_p$ do  3:      $x_e\leftarrow$ get a elite solution from ${\mathbf{X}}_e$;  4:      $\overline{x}\leftarrow$ get the mean position of all solutions;  5:      update the velocity of $x_p$ according to (25);  6:      update the position of $x_p$ according to (26);  7:      $Qsp\leftarrow$ add the updated $x_p$;  8: end for ${/}^{*}$ Access to MLP-based evolutionary strategy.  9: MLP ← train the MLP by inputting ${\mathbf{X}}_e$ and ${\mathbf{X}}_p$; 10: for each $x_e\in {\mathbf{X}}_e$ do 11:      $x_{MLP}\leftarrow$ get a new solution by inputting $x_e$ to MLP; 12:      $x_{best}\leftarrow$ get the global best solution from $Pop$; 13:      $x_{rd1},x_{rd2}\leftarrow$ select two different random solutions; 14:      update the velocity of $x_e$ according to (27); 15:      update the position of $x_e$ according to (28); 16:      $Qsp\leftarrow$ add the updated $x_e$; 17: end for 18: return $Qsp$ as the next generation population.

Algorithm 4 provides the pseudocode of the population optimization phase, which consists of two main loops for the key optimizers—the deployment optimizer and the unloading optimizer. First, the deployment optimizer is executed in lines 1–11 to optimize the UAV deployment scheme for each solution. In particular, the UAV deployment scheme for each solution x in $Pop$ is decoded and presented in set $UAV$ in line 2. Then in lines 3 to 9, each UAV $\mathbf{uav}$ in $UAV$ is checked and determined if it needs to be eliminated. Concretely, the Euclidean distance of the uav from other UAVs is calculated in line 4. In line 5, the minimum distance between uav and other UAVs will be evaluated if it is less than the minimum allowable distance $d_{min}=40$ m. If it does, then uav is eliminated from $UAV$ in line 6 and the tasks on uav are migrated to the nearest UAV in line 7. After checking all of the UAVs, the UAV deployments in x are updated in line 10. Subsequently, the offloading optimizer is executed in lines 12–25 to optimize the task offloading scheme for each solution. Specifically, the task offloading schemes of all of the mobile devices for each solution x are firstly decoded and presented in set $Task$ in line 13. Then, the completion time of each task in $Task$ is calculated in line 15. Moreover, if the completion time of task is greater than its maximum allowed delay $T_{max}$, LDOMO tries to find a feasible UAV for this failed task in line 17. If a feasible UAV is successfully found, the offloading decision of task is updated in x, otherwise task is marked as a failed task. Finally, all task offloading decisions for each solution in the population $Pop$ are optimized and the optimized $Pop$ is returned.

Algorithm 4 Optimization phase

Input:  $Pop$. Output:  The optimized $Pop$.    ${/}^{*}$ Access to deployment optimizer.  1: for each $\mathbf{x}\in Pop$ do  2:      $UAV\leftarrow$ decode the location of UAVs from $\mathbf{x}$;  3:      for each $\mathbf{uav}\in UAV$ do  4:          calculate distance $d_{\mathbf{uav}}$ between $\mathbf{uav}$ and others;  5:          if $min\left(d_{\mathbf{uav}}\right)<d_{min}$ then  6:             eliminate $\mathbf{uav}$ from $UAV$;  7:             migrate tasks from $\mathbf{uav}$ to nearest UAV;  8:          end if  9:      end for 10:      update UAVs and tasks in $\mathbf{x}$; 11: end for ${/}^{*}$ Access to offloading optimizer. 12: for each $\mathbf{x}\in Pop$ do 13:      $Task\leftarrow$ decode the decisions of tasks from $\mathbf{x}$; 14:      for each $\mathbf{task}\in Task$ do 15:          calculate the completion time $t_{\mathbf{task}}$ of $\mathbf{task}$; 16:          if $t_{\mathbf{task}}>T_{max}$ then 17:             try to find a viable decision for $\mathbf{task}$; 18:             if success then 19:                 update $\mathbf{task}$ in $\mathbf{x}$; 20:             else 21:                 mark $\mathbf{task}$ as a failed task; 22:             end if 23:          end if 24:      end for 25: end for

5. Simulation Results

5.1. Environmental Setup

In this section, simulation experiments are performed to evaluate the performance of LDOMO, which are implemented in Python 3.11, and run on a PC with Intel (R) Core (TM) i7-12700 CPU and 32.0 GB RAM.

Table 2. Environment settings.

Parameter	Value
Distribution area of UAVs and mobile devices	1000 × 1000 m2
Number of mobile devices (I)	100, 200, …, 1000
Number of UAVs (J)	50, 100, …, 500
Transmission data of one task	[0.5, 2] Mbits
CPU cycles to compute one bit	[100, 1000] CPU cycles
Maximum delay of one task	[100, 200] ms
Transmission bandwidth	100 Mbps
Computation capabilities of UAVs	$[5,10]$ GHz
Transmit power	1 W
Hovering power of UAVs	1 kW
Noise power	−117 dB
Central frequency	2 GHz
Minimum allowable distance of UAVs	4 m

summarizes the environmental settings for the simulation experiments.

5.2. Experimental Setup

In order to comprehensively evaluate the performance of LDOMO, several representative methods are adopted for comparisons, including NSGA-II [45], MOEA/D [46], LMOCSO [47], and MOPSO [48]. In addition, a variant of the proposed method is used for comparison, i.e., LDOMO-I, which does not use two local search optimizers to verify their effectiveness. Moreover, the parameters of all of the algorithms are summarized in

Table 3. Algorithm settings.

	Parameters	Common Parameters
LDOMO, LDOMO-I	$LR$ = 0.1, e = 20, K = 40	Population Size = 100, Iteration = 200, Runtimes = 20
NSGA-II	$R_c$ = 0.9, $R_m$ = 0.08
MOEA/D	T = 20, $\delta$ = 0.9, $R_c$ = 0.8, $R_m$ = 0.01
LMCSO	$\theta$ = 0.1
MOPSO	w = 0.4, $c1$ = 2.0, $c2$ = 2.0

. In particular, the number of neurons in the hidden layer of the MLP is set to 40 in our LDOMO. For training the MLP in each generation, the learning rate $LR$ is set to 0.1, the number of epochs is set as $e=20$. For the sake of fairness, all algorithms are independently run 20 times and the average results are recorded to evaluate the overall performance of the algorithms.

5.3. Simulation Results

In this section, the experimental results are discussed by comparing the performance of our method with several representative multiobjective evolutionary algorithms on different experimental scales. First, comprehensive performance comparisons of all algorithms are discussed across four different scales, each featuring varying numbers of mobile devices (UAVs): 200 (100), 400 (200), 600 (300), and 1000 (500). Subsequently, the impact of different numbers of mobile devices is analyzed based on algorithm performance, maintaining a constant number of UAVs set at 500. Finally, the effect of different numbers of UAVs is explored on the algorithm performance while keeping the number of mobile devices constant at 1000.

Performance comparison: Figure 3 shows the non-dominated solution sets obtained by all algorithms in terms of both energy consumption and user satisfaction. In a small-scale setting (i.e., 200 (100)), LDOMO-I does not dominate MOEA/D, but shows a slight performance improvement over NSGA-II, LMCSO, and MOPSO. However, LDOMO emerges as the superior performer, dominating all other algorithms due to its lowest energy consumption and highest user satisfaction. This dominance can be attributed to the effectiveness of the two local search optimizers employed by LDOMO, which contribute to reducing energy consumption and enhancing user satisfaction, thereby enhancing solution quality. In the last three large-scale experiments (i.e., 400 (200), 600 (300), and 1000 (500)), LDOMO and LDOMO-I both outperform the other algorithms and have better scalability. This illustrates that the CSO-based evolutionary strategy and MLP-based evolutionary strategy used in both LDOMO and LDOMO-I are able to learn faster convergence directions and improve convergence efficiency.

Impacts of different numbers of mobile devices: 

Table 4. Comparison results for different numbers of mobile devices.

I (J = 500)	Energy Consumption					User Satisfaction
	LDOMO	NSGA-II	MOEA/D	LMCSO	MOPSO	LDOMO	NSGA-II	MOEA/D	LMCSO	MOPSO
100	56,970.1	57,431.5	57,002.0	57,853.4	58,077.6	0.888	0.830	0.720	0.770	0.760
200	63,414.9	65,684.9	64,640.7	65,974.2	66,650.8	0.884	0.790	0.700	0.740	0.730
300	71,332.8	74,111.9	72,910.3	74,336.2	75,317.4	0.860	0.743	0.697	0.690	0.687
400	77,574.7	81,653.4	80,162.3	81,585.6	82,668.7	0.880	0.772	0.700	0.702	0.702
500	84,481.2	90,214.1	89,105.9	90,339.2	91,916.8	0.876	0.730	0.688	0.690	0.686
600	92,729.7	98,438.2	97,719.3	98,768.7	100,130.7	0.867	0.722	0.673	0.683	0.685
700	102,604.7	107,783.9	105,357.2	106,677.9	109,443.0	0.867	0.713	0.667	0.690	0.680
800	103,946.7	115,604.6	113,217.9	115,313.4	117,403.9	0.867	0.712	0.670	0.680	0.677
900	112,344.3	124,771.6	122,638.6	124,138.6	126,358.2	0.863	0.710	0.660	0.677	0.677
1000	123,255.4	133,216.1	130,804.1	132,296.6	135,684.6	0.862	0.711	0.669	0.675	0.673

presents the experimental results with varying numbers of mobile devices, focusing on energy consumption and user satisfaction. As shown in Table 4, the energy consumption of the system rises with the increasing number of mobile devices, attributed to the heightened computing requirements. Consequently, user satisfaction gradually diminishes as the system contends with higher computational loads. Across all scales of mobile devices, LDOMO consistently demonstrates a superior performance, maintaining the lowest energy consumption and ensuring user satisfaction of over 86%. In contrast, other algorithms exhibit lower user satisfaction levels, hovering around 70%, particularly in large-scale environments. In summary, LDOMO outperforms existing representative evolutionary algorithms across different scales of mobile devices. Its ability to effectively balance energy consumption and user satisfaction underscores its suitability for addressing the complexities of UAV-assisted MEC systems, regardless of the scale of mobile device deployment.

Impacts of different numbers of UAVs: 

Table 5. Comparison Results for Different Numbers of UAVs.

I (J = 1000)	Energy Consumption					User Satisfaction
	LDOMO	NSGA-II	MOEA/D	LMCSO	MOPSO	LDOMO	NSGA-II	MOEA/D	LMCSO	MOPSO
50	74,540.7	87,534.9	83,418.2	86,323.6	89,026.3	0.844	0.787	0.657	0.682	0.666
100	77,093.4	92,497.9	89,635.2	90,925.3	95,479.4	0.857	0.716	0.675	0.674	0.680
150	85,530.7	97,687.4	94,877.5	99,300.1	100,112.3	0.857	0.705	0.664	0.698	0.667
200	86,474.1	102,975.9	99,698.2	104,327.6	104,663.8	0.859	0.722	0.677	0.703	0.668
250	92,963.8	108,354.3	105,686.8	106,151.1	110,291.5	0.861	0.715	0.665	0.664	0.679
300	99,043.7	112,999.2	110,784.6	112,751.4	115,239.3	0.862	0.721	0.657	0.676	0.670
350	106,903.4	117,161.8	114,714.7	118,218.3	119,621.3	0.861	0.701	0.665	0.678	0.668
400	112,741.3	122,807.7	120,043.5	122,736.8	124,896.7	0.860	0.719	0.669	0.680	0.664
450	113,291.5	128,049.4	125,420.1	127,362.4	129,851.3	0.862	0.711	0.666	0.671	0.661
500	123,255.4	133,216.1	130,804.1	132,296.6	135,684.6	0.862	0.711	0.669	0.675	0.673

shows the experimental results with different scales of UAVs in terms of energy consumption and user satisfaction. As observed, the energy consumption of the system exhibits a positive trend with the increasing number of UAVs, primarily due to the hovering energy consumption of UAVs. However, the user satisfaction of mobile devices shows improvement with the escalation of UAVs, attributed to the augmented edge computing resources facilitated by the increased UAV deployment. Notably, LDOMO consistently demonstrates a superior performance across varying numbers of UAVs, maintaining the lowest energy consumption and the highest levels of user satisfaction. By effectively balancing energy consumption and user satisfaction, LDOMO emerges as a promising solution for addressing the challenges posed by different scales of UAV deployment in UAV-assisted MEC environments.

6. Conclusions and Future Work

In this paper, we focused on the challenges of joint UAV deployment and task offloading in a large-scale UAV-assisted MEC. First, we formulated joint UAV deployment and task offloading problem as a large-scale multiobjective optimization problem with the goal of minimizing the energy consumption while improving user satisfaction. Then, we designed a large-scale UAV deployment and task offloading multiobjective optimization method based on the evolutionary algorithm (called LDOMO) to effectively address the above formulated problem. In the proposed LDOMO, the entire population was first decomposed into the set of poor solutions and the set of elite solutions. Then, CSO-based and MLP-based evolutionary strategies were proposed to explore the two solution spaces with the aim of accelerating the convergence while improving the quality of the population. Subsequently, two local search optimizers were designed to avoid infeasible solutions and to further improve the quality of solutions. Finally, we simulated different experimental scales to compare the performance of our method with existing representative evolutionary algorithms and discussed the impact of different numbers of UAVs and mobile devices. Extensive simulation results have shown that our approach outperforms several representative evolutionary algorithms in terms of energy consumption and user satisfaction in experiments of different scales.

In future work, we will further consider the problem of UAV trajectory planning with obstacle avoidance in large-scale UAV-assisted MEC. In addition, we are interested in exploring other scenarios to extend the research work of this paper, such as partial task offloading, wireless energy harvesting, and collaboration between UAV and base stations.