In the rapidly evolving landscape of the Internet of Things and fifth-generation mobile communication technologies, the application scenarios for Unmanned Aerial Vehicles (UAV drones) are expanding swiftly from military to civilian domains. However, UAV drones are inherently constrained by their size, weight, and power, leading to limited onboard computational capabilities, storage resources, and energy reserves. This limitation creates a sharp contradiction with the increasing complexity of the tasks they are tasked with. How to efficiently handle these computation-intensive and latency-sensitive tasks has become a critical bottleneck restricting the effectiveness of UAV drone applications.
In this context, Mobile Edge Computing technology offers an effective pathway to resolve this contradiction. This technology下沉 cloud computing capabilities to the network edge, enabling UAV drones to offload part or all of their computational tasks to nearby edge servers for execution. This significantly alleviates local computational pressure, reduces task processing energy consumption and latency, and effectively extends the operational endurance of UAV drones. However, the task offloading decision itself is a complex optimization problem that must comprehensively consider multidimensional dynamic factors such as network state, server load, task characteristics, and the remaining energy of the UAV drone. It requires seeking an optimal trade-off among multiple objectives like energy consumption and delay.
To address this, researchers have embarked on optimizing the task offloading efficiency of UAV drones from various technical approaches. Existing research can be broadly categorized into three types: first, focusing on improving core efficiency indicators; second, focusing on system reliability and security; and third, exploring new collaborative computing modes. However, much of the previous research has concentrated on offloading optimization algorithms, with simulation environments often simplifying communication and concurrency models, lacking a system implementation carrier for actual complex operational environments. Therefore, in this paper, I design a distributed task offloading monitoring system based on the KBEngine framework to provide an integrated platform for algorithm integration, verification, and management.
The core advantage of my system is its high scalability, capable of integrating and comparing multiple optimization algorithms. I utilize a three-tier architecture to achieve load balancing and integrate lightweight surrogate models to rapidly evaluate offloading strategies. As an example, I integrate the AC-LSTM and NSGA-II algorithms for experimentation. The results show that the AC-LSTM algorithm significantly outperforms the latter in both convergence and frontier width, validating the effectiveness of the system as an algorithm verification platform. The system also provides a visual monitoring interface, offering an integrated solution for UAV drone edge computing research from algorithm integration and performance verification to real-time monitoring.
The optimization problem addressed by this system is as follows: the system contains M UAV drones, N edge servers, and K communication channels. A UAV drone can offload tasks to a specified edge server via one channel. Each UAV drone partitions its task into several task nodes with dependencies. These nodes can be processed locally or offloaded to edge servers. When offloading to edge servers, the communication delay for transmitting required data from the terminal to the edge server must be considered. There are three special types of task nodes: (a) nodes requiring UAV drone-specific information, such as speed or location, which must be processed locally; (b) nodes requiring information from other UAV drones, which must be offloaded to edge servers; and (c) the first and last task nodes involving task initiation and final decisions, which must be processed locally. To represent task dependencies, a Directed Acyclic Graph is used to describe the computational task.
For the task offloading optimization of UAV drone m, both computational delay and energy consumption need to be minimized, forming a bi-objective optimization problem. The objective functions are:
$$ \min \left( f_z^m(x) \right), \quad z = 1, 2 $$
where \( f_1^m(x) \) represents the computational delay of UAV drone m, i.e., \( f_1^m(x) = T_m \), and \( f_2^m(x) \) represents the energy consumption of UAV drone m, i.e., \( f_2^m(x) = E_m \). Here, \( x_m \) is the decision vector for the scheduling relationships of all task nodes of UAV drone m. Converting \( x_m \) to binary, from the lowest to the highest bits, represents the decision factors \( s_m^i \) for task nodes from the start to the end. For the three special task nodes, the offloading location is fixed, so the decision factors are constant values.
$$ x_m = \sum_{i=1}^{\mu_m} s_m^i \cdot 2^{(i-1)} $$
The system includes M UAV drones. Therefore, the average offloading delay and loss function for the UAV drones in this system can be expressed as:
$$ f_z(\mathbf{x}) = \frac{1}{M} \sum_{m=1}^{M} \sum_{n=1}^{N} \sum_{k=1}^{K} \eta_{mnk} \cdot f_z^m(x_m), \quad z = 1, 2 $$
where \( \eta_{mnk} \in \{0, 1\} \); if UAV drone m offloads task nodes to edge server n via channel k, then \( \eta_{mnk} = 1 \), otherwise \( \eta_{mnk} = 0 \). \( \mathbf{x} = [x_1, x_2, \dots, x_M] \) is the decision vector for the optimization problem.
A surrogate model is an approximate mathematical model constructed using machine learning algorithms to replace computationally expensive complex simulation processes. Its core value lies in learning the mapping relationship between input parameters and output responses from historical data, forming a computationally efficient and reliable prediction model, thereby significantly improving optimization efficiency. In scenarios with high real-time requirements, such as UAV drone task offloading, surrogate models enable optimization algorithms to avoid time-consuming physical simulations by quickly predicting system performance under different decisions, allowing for optimization decisions based directly on model predictions.
The construction of surrogate models can employ various machine learning algorithms, with Gaussian Process Regression and Neural Networks being the most typical. Gaussian Process Regression is a probabilistic model whose advantage lies in providing both predicted values and estimates of prediction uncertainty. This characteristic makes it particularly suitable for scenarios with limited sample sizes and requiring guided active learning. Neural Networks, with their powerful nonlinear fitting capabilities, are suitable for modeling complex systems with high dimensions and large data volumes. Other commonly used methods include Radial Basis Function interpolation, Support Vector Regression, and Polynomial Regression.
After achieving efficient energy consumption and delay prediction based on surrogate models, scholars can utilize this platform to integrate various required optimization algorithms to verify decision effects under different conditions. For example, these include the Actor-Critic algorithm with Long Short-Term Memory networks (AC-LSTM) and the Non-dominated Sorting Genetic Algorithm II (NSGA-II). The AC-LSTM algorithm is an advanced framework in deep reinforcement learning that combines the memory capabilities of LSTM with the interactive learning mechanism of Actor-Critic to handle partially observable or strongly time-dependent complex decision environments. NSGA-II is based on the Pareto optimal solution idea, searching the solution space through operations such as selection, crossover, and mutation, making trade-offs between conflicting objectives like energy consumption and delay, and outputting a set of non-dominated solutions to provide multiple strategy choices for decision-makers. The NSGA-II algorithm is prone to local convergence when handling high-dimensional offloading tasks, while the AC-LSTM algorithm can effectively mitigate this situation. This platform allows for analysis and verification based on collected data.
The KBEngine engine adopts a layered architecture design, achieving effective separation of system load and functional decoupling by distributing entities of different functions to different logical layers on the server side. This architecture mainly includes three core layers: the client layer, the external logic layer, and the spatial internal logic layer. Each layer works collaboratively to support complex business logic and high-performance real-time computing.
The client, as the front-end for direct user interaction, provides operation interfaces for task selection, task management, and data display. It receives user input and sends requests to the server while real-time displaying status updates and task execution data returned from the server. The external logic layer is the core process for handling non-real-time, global logic, responsible for account management, persistent data storage, and low-frequency business processing. The spatial internal logic layer focuses on high-frequency real-time computing and spatial logic processing, carrying high-performance computing demands such as task offloading and resource scheduling.
The entity classes in the system are distributed across different layers according to functional requirements. The specific configuration is shown in the following table.
| Entity | Client | BaseApp | CellApp |
|---|---|---|---|
| Account Management Entity | Exists | Exists | Does Not Exist |
| Current Task Entity | Exists | Exists | Exists |
| Space Entity | Does Not Exist | Exists | Exists |
| Space Management Entity | Does Not Exist | Exists | Does Not Exist |
In this architecture, the account management entity is responsible for account management, including global operations such as login/logout and task selection, distributed across the client and the external logic layer of the server side. When a user selects a task, the account management entity in the external logic layer selects the corresponding entity from the task entity storage area, synchronizes it to the current task entity, and initializes it. The initialization process includes three stages: first, according to task collaboration requirements, applying to the space management entity for the corresponding space entity to provide a unified data interaction space for multiple task entities; second, after obtaining the space, initializing the current task entity in the spatial internal logic layer to ensure real-time computing capability is ready; and third, creating the corresponding current task entity on the client side, establishing a bidirectional communication link with the external logic layer and the spatial internal logic layer to achieve three-layer data interconnection.
During the task offloading decision process, the client entity sends a request to the spatial internal layer, and the task offloading management entity executes the offloading decision algorithm and feeds the results back to entities at each layer. This manager generates offloading strategies based on optimization algorithms, coordinates task allocation between terminal devices and edge servers, and simultaneously collects historical offloading data for verifying algorithm accuracy. If the user selects management tasks through the account management entity, the current task entity will be responsible for monitoring the algorithm execution efficiency in each space, providing data display and interaction functions for the management interface, and achieving comprehensive supervision of the system’s operational status.
The optimization core of my system revolves around the collaborative work of two core components: the task offloading management entity and the current task entity. The overall process is a closed-loop system integrating data-driven, machine learning, and intelligent decision-making. The specific workflow is as follows.
First, in the initialization and data collection phase, after system startup, the decision space is configured in the task offloading management entity, clarifying the dimensions of the optimization problem and the value range of each dimension. Then, the manager uses sampling strategies to automatically generate multiple sets of representative decision vector samples. These samples are transmitted to the current task entity through internal interfaces. The current task entity, as the task execution entity, receives each set of decision vectors, drives the UAV drone to complete a full task offloading simulation, and accurately collects performance result data from this offloading. These result data are returned in real-time to the data collection module of the task offloading management entity, thereby building an initial dataset for model training.
Second, in the surrogate model training and construction phase, when sufficient sample data is accumulated, the process enters the machine learning stage. The surrogate model training module of the task offloading management entity is activated. It can employ algorithms such as Gaussian Process Regression or Neural Networks to learn from the historical dataset. This process optimizes model parameters to minimize prediction errors, thereby constructing a mathematical surrogate model that accurately reflects the complex mapping relationship from “decision vectors” to “performance results.” This model is characterized by extremely low computational cost but can approximate the original time-consuming simulation process with high precision.
Third, in the model application and optimization solving phase, the trained surrogate model is immediately integrated into the algorithm optimization solving module, becoming the engine for rapid optimization. When the system is running, if a new task arrives requiring immediate offloading decisions, the current task entity uploads the current real-time environmental parameters to the task offloading management entity. The manager then calls the embedded optimization algorithm to perform fast optimization solving in the approximate space constructed by the surrogate model, ultimately obtaining a high-quality optimal decision vector.
Fourth, in the decision execution and closed-loop feedback phase, the obtained optimal decision vector is sent back to the current task entity to guide the UAV drone in executing the actual task offloading. Simultaneously, the real results of this offloading are recorded and fed back to the offloading result statistics module of the task offloading management entity. These newly added high-value data are not only used for performance monitoring and analysis but can also be regularly used to update and retrain the surrogate model, enabling it to continuously adapt to environmental changes, forming a self-evolving, continuously optimizing intelligent closed-loop.
Additionally, as a supervisory unit, the current task entity has access permissions and can obtain historical operational data and statistical information of the entire system from the offloading result statistics module of the task offloading management entity. It can transmit this data to the client interface for visual display, providing intuitive system status monitoring and decision support for managers.
To verify the effectiveness of my system, I designed a corresponding experimental environment. The experimental hardware configuration mainly includes clients simulating UAV drone clusters, edge server nodes, and central management nodes. The software environment is based on the KBEngine server framework and Unity front-end. The key parameter configurations for the experiment are shown in the following table.
| Configuration Category | Parameter Item | Parameter Value |
|---|---|---|
| Network Topology | Architecture | Star Topology |
| Number of Base Stations | 2 | |
| Network Parameters | Bandwidth | 20 Mbps |
| Network Delay | 10~50 ms | |
| Number of Edge Servers | 2 | |
| Edge Server Specifications | CPU | Intel Xeon E5-2680 v4 |
| Memory | 32 GB | |
| Number of UAV Drones | 30 (adjustable) | |
| UAV Drone Specifications | CPU | ARM Cortex-A72 |
| Battery Capacity | 10000 mAh | |
| Task Type | Path Planning | |
| Task Specifications | Task Input | Local Environment Grid Map |
| Task Data Volume | 100~500 per task |
My system provides complete strategy configuration and operational monitoring functions for the UAV drone edge computing task offloading control system. The system interface adopts a three-zone layout design, corresponding to environment configuration, cluster efficiency overview, and single-machine detailed data query functions. The system initialization state shows all data indicators at zero values in a standby state; the actual operational state displays real monitoring data that has been generated.
The system operation process is as follows: users first need to complete the working environment setup in the left configuration area. After entering the space number in the ROOM_ID field (default value is 1), click the “Enter” button to activate the workspace. Then, select the surrogate model, optimization algorithm, and set multi-objective decision weight parameters via drop-down menus. After completing all parameter configurations, click the “Deploy” button to submit to the server for strategy environment initialization. When needing to change the surrogate model or optimization algorithm, it is necessary to first click the “Unload” button to clear the existing optimization environment. After the system cleanup is completed, reselect parameters and click the “Deploy” button to build a new environment.
The cluster efficiency monitoring function is located in the central area of the interface. Users can select a specific task via the top drop-down menu and then click the “Query” button to obtain aggregated data. The system will return key indicators such as the number of UAV drones executing the task, the total number of completed task offloads, average energy consumption, and average delay. Actual operational data shows, for example, that 6 UAV drones completed 6 offloading tasks, with an average energy consumption of 18.30 J and an average delay of 1.63 s. These data intuitively reflect the overall performance of the cluster.
The single UAV drone detailed query function is located on the right side of the interface, supporting fine-grained task analysis. Users need to specify the target UAV drone number in the “UAV ID” input box and then click the “Query” button. The system will return the cumulative number of offloads for that UAV drone. Users can choose to view the record of a specific offload count, and the system will display the task name, specific energy consumption, and delay data for that execution. For example, it may show that for UAV drone ID=2, the first offload record: executing offload task 1, energy consumption 17.12 J, delay 1.71 s, with a cumulative total of 3 offload tasks completed.
This system, through layered visual design, meets both macro-situation monitoring needs and supports micro-problem localization analysis, providing a complete visual monitoring solution for UAV drone swarm task offloading strategy optimization. All data is obtained in real-time from the computing engine, ensuring the timeliness and accuracy of monitoring data.
In the monitoring terminal, under the same surrogate model, I configured the AC-LSTM algorithm and the NSGA-II algorithm respectively. Weight parameters were randomly generated with 40 data points following a uniform distribution in the range from 0 to 1. The smaller this parameter, the higher the weight for energy consumption optimization; the larger, the higher the weight for delay optimization. When the weight is set to 0, it is equivalent to the UAV drone processing tasks locally; when set to 1, it is equivalent to offloading all tasks to the server for processing. The two algorithms respectively statistics energy consumption and delay under different weights, ultimately obtaining the Pareto frontiers for both algorithms.
Through AC-LSTM, the obtained Pareto frontier has the leftmost point with energy consumption of 17.18 J and delay of 1.91 s, and the rightmost point with energy consumption of 27.53 J and delay of 0.97 s. Through the NSGA-II algorithm, the obtained frontier has the leftmost point with energy consumption of 21.83 J and delay of 1.63 s, and the rightmost point with energy consumption of 24.32 J and delay of 1.40 s. It can be observed that both in terms of frontier width and convergence, AC-LSTM is superior to the NSGA-II algorithm. This verifies that when handling high-dimensional tasks, the NSGA-II algorithm’s optimization process is prone to entering local convergence.
The main contributions of this research are as follows. First, I constructed an extensible algorithm integration and verification platform, addressing the pain point of theoretical algorithms lacking practical carriers. Second, by comparing the AC-LSTM algorithm and the NSGA-II algorithm on this platform through experiments, I quantitatively verified the superiority of AC-LSTM. The Pareto frontier obtained by AC-LSTM is significantly better than that of the comparison algorithm in both width and convergence, providing a better solution set for intelligent offloading decisions. Finally, the visual monitoring interface provided by the system achieves algorithm integration, performance verification, and real-time operation and maintenance.
In summary, this research not only provides an efficient experimental platform for UAV drone task offloading research but also, through rigorous experiments, verifies the great potential of intelligent algorithms in practical applications, supporting the engineering implementation of related technologies. Future work will focus on introducing more complex dynamic channel models and privacy protection mechanisms to further enhance the practicality and security of the system.