Enhanced Link Prediction and Traffic Load Balancing in Unmanned Aerial Vehicle-Based Cloud-Edge-Local Networks

Abstract

With the advancement of cloud-edge-local computing, Unmanned Aerial Vehicles (UAVs), as flexible mobile nodes, offer novel solutions for dynamic network deployment. However, existing research on UAV networks faces substantial challenges in accurately predicting link dynamics and efficiently managing traffic loads, particularly in highly distributed and rapidly changing environments. These limitations result in inefficient resource allocation and suboptimal network performance. To address these challenges, this paper proposes a UAV-based cloud-edge-local network resource elastic scheduling architecture, which integrates the Graph-Autoencoder–GAN-LSTM (GA–GLU) algorithm for accurate link prediction and the FlowBender-Enhanced Reinforcement Learning for Load Balancing (FERL-LB) algorithm for dynamic traffic load balancing. GA–GLU accurately predicts dynamic changes in UAV network topologies, enabling adaptive and efficient scheduling of network resources. FERL-LB leverages these predictions to optimize traffic load balancing within the architecture, enhancing both performance and resource utilization. To validate the effectiveness of GA–GLU, comparisons are made with classical methods such as CN and Katz, as well as modern approaches like Node2vec and GAE–LSTM, which are commonly used for link prediction. Experimental results demonstrate that GA–GLU consistently outperforms these competitors in metrics such as AUC, MAP, and error rate. The integration of GA–GLU and FERL-LB within the proposed architecture significantly improves network performance in highly dynamic environments.

1. Introduction

Cloud-edge-local computing [1] is a computing paradigm that combines cloud, edge, and local resources to process data efficiently by distributing workloads across centralized cloud systems, edge devices, and local networks. This paradigm addresses challenges such as data transmission latency, bandwidth constraints, and privacy concerns by processing data closer to its source, thereby reducing the load on centralized cloud resources and enabling faster response times.

UAV networks are communication networks formed by Unmanned Aerial Vehicles (UAVs) that enable data exchange and coordination between drones and ground stations for various applications. UAVs have become essential for dynamic network deployment due to their rapid mobility and ability to extend network coverage in remote or inaccessible areas. These networks also play a vital role in mobile edge computing, offering the potential for task offloading and improving network flexibility.

Despite these advantages, existing research on UAV networks faces significant challenges in predicting the dynamic nature of communication links and managing network traffic in real time, particularly in highly distributed and evolving environments. These challenges often lead to suboptimal resource allocation and inefficient network performance, limiting the full potential of UAV-based architectures. As UAVs become more prevalent in cloud-edge-local computing, addressing these challenges is crucial for maintaining network reliability and performance in scenarios that demand quick responses and seamless connectivity.

To address these limitations, this paper proposes an integrated cloud-edge-local network resource scheduling architecture, specifically designed for UAV networks. The architecture is grounded in the fat-tree topology, a structure commonly used in data center networks due to its scalability and fault tolerance. By leveraging this topology, the proposed architecture provides a robust foundation for elastic resource scheduling, allowing for efficient network management in dynamic UAV environments. This architecture effectively allocates UAV nodes across hierarchical layers, enhancing resource flexibility and ensuring consistent performance, even in fluctuating network conditions.

We introduce the Graph-Autoencoder–GAN-LSTM (GA–GLU) method for UAV link prediction, which combines the advantages of Graph Autoencoders (GAEs) and Generative Adversarial Networks (GANs) with LSTM predictive networks for link prediction and dynamic resource scheduling in UAV networks. The GA–GLU method is essential to this architecture, as it addresses the challenge of predicting link dynamics in highly dynamic UAV topologies. By incorporating a GAE for feature extraction and GANs for optimizing these features, GA–GLU provides accurate link predictions, while the LSTM component enhances its temporal prediction capabilities, making it highly suitable for evolving UAV networks. This method’s ability to foresee link changes enables more adaptive and efficient resource management across the network.

This study significantly enhances the resource utilization of cloud-edge-local networks by introducing a UAV-based elastic scheduling architecture and the GA–GLU graph representation learning method. To complement the link prediction capabilities of GA–GLU, we propose the FlowBender-Enhanced Reinforcement Learning for Load Balancing (FERL-LB) algorithm, which dynamically adjusts network traffic distribution based on real-time link predictions. This approach achieves more efficient traffic management and service quality assurance by improving load balancing in highly dynamic network environments. By integrating FERL-LB within the architecture, traffic loads are dynamically balanced, thereby optimizing resource allocation and preventing congestion, even in volatile UAV network scenarios. Together, GA–GLU and FERL-LB provide a comprehensive solution for real-time network scheduling, improving both performance and resource efficiency across cloud-edge-local networks.

The innovations of this paper are as follows:

• We propose a UAV-based elastic scheduling architecture for cloud-edge-local network resources, effectively utilizing UAV flexibility to enhance network deployment and employing the fat-tree topology structure to improve network scalability and management efficiency.
• We introduce the GA–GLU graph representation learning method to predict UAV links, accurately forecasting UAV network topology changes for dynamic resource scheduling.
• We propose the FERL-LB algorithm, which integrates reinforcement learning to optimize traffic load balancing based on link prediction, significantly improving network performance and resource utilization.

2. Related Works

2.1. UAV-Based Cloud-Edge-Local Resource Scheduling

Mobile edge computing (MEC) enables the deployment of innovative applications and services at the network edge, providing computational capabilities close to a large number of IoT devices  [2]. With MEC deployment, devices can offload computationally intensive tasks to nearby powerful edge servers, thereby reducing latency and saving energy [3]. Recent research efforts have shifted from fixed edge servers to mobile edge servers, which offer greater flexibility, cost-effectiveness, and efficiency in challenging environments. Some recent studies have proposed using UAVs to improve connectivity for ground IoT devices [4]. UAV-assisted wireless communication offers advantages in flexible deployment, fully controllable mobility, and enhanced network performance, garnering increasing research interest. Hovering UAV-based FSO relay systems, as explored in recent studies under the effects of pointing errors and atmospheric turbulence, provide valuable insights into improving performance in UAV networks [5]. Efficient routing protocols have been proposed to enhance UAV communication, as demonstrated in recent work on hybrid routing schemes for 3D UAV networks [6]. Consequently, UAV-assisted edge computing networks are a natural and promising paradigm, where optimizing UAV flight paths to meet the communication and computing demands of numerous devices is a crucial and challenging issue.

Existing research primarily focuses on optimizing edge computing with fixed ground base stations. Some of the latest studies propose utilizing UAVs and satellite-assisted Space–Air–Ground Integrated Networks (SAGINs) to meet the service needs of remote IoT applications. Some studies [7,8] have employed SAGINs for online offloading decisions of ground IoT tasks and have used linear programming methods to solve stochastic strategies aimed at minimizing the expected long-term average latency. Meanwhile, machine learning techniques, such as deep learning [9], have been introduced into SAGIN-assisted MEC to optimize UAV positioning and resource scheduling, effectively reducing energy consumption. In addition to these machine learning approaches, [10] introduced deep reinforcement learning methods for resource allocation and UAV position optimization, achieving significant results by balancing system efficiency with energy savings. Moreover, applications of reinforcement learning in optimizing resource allocation in dynamic environments can benefit from considering mobility aspects in mobile distributed computing, as explored in [11,12]. However, current research based on reinforcement learning is often limited to single UAV resource allocation or multi-UAV position deployment, lacking exploration of multi-UAV cooperation for comprehensive resource scheduling and system optimization.

Although current research has made progress in the collaborative optimization of cloud-edge-local systems, further exploration is needed regarding the cooperative path design and system optimization among multiple UAVs to meet the requirements of cloud-edge-local network resource scheduling and traffic load balancing.

2.2. UAV Link Topology Prediction

In UAV networks, link topology prediction is a crucial task, and the application of machine learning algorithms in complex networks has made significant progress [13]. However, directly applying machine learning algorithms to network analysis has certain limitations, as the complex structure of networks needs to be transformed into a low-dimensional vector space through graph embedding techniques for more flexible and effective computation [4]. To address these limitations, various graph embedding techniques have been introduced.

To overcome the challenge of obtaining node pair representations in networks, Rahman et al. [14] proposed the DyLink2Vec algorithm, which models the network embedding task as an optimization encoding problem. The objective is to minimize reconstruction errors using gradient descent. Goyal [15] introduced the DGEM algorithm, which maps dynamic graph data into a highly nonlinear latent space using dynamically extended deep autoencoders and captures connectivity trends of graph snapshots at any given time period through a decoder to enhance the precision of link predictions.

To better capture the evolution patterns of links in temporal networks, Li et al. [16] proposed the DDNE framework based on autoencoders. It utilizes historical information from past temporal network snapshots to learn the latent representation of future networks. Additionally, this framework employs Gated Recurrent Units (GRUs) to adaptively capture the dependencies of networks at different scales, improving the framework’s ability to model dynamic link changes. In parallel, with advancements in Graph Neural Networks (GNNs), Pareja et al. [17] proposed the EvolveGCN algorithm based on GNNs. They built an encoder using Graph Convolutional Networks (GCNs) [18] and Recurrent Neural Networks (RNNs) to transform the adjacency matrices and node features of historical network snapshots into corresponding network embeddings. A Multi-Layer Perceptron (MLP) serves as the decoder to obtain the predicted network structure with enhanced accuracy in evolving network conditions.

Further extending these approaches, Min et al. [19] proposed STGSN from temporal and spatial perspectives, modeling the network from both dimensions and using a temporal attention mechanism to capture the network’s temporal features, thus enhancing the algorithm’s interpretability and enabling a more nuanced understanding of network evolution.

The advantages and disadvantages of the proposed GA–GLU algorithm compared to current popular link prediction methods are shown in

Table 1. Comparison of UAV link prediction algorithms.

Algorithm	Advantages	Disadvantages
DyLink2Vec [14]	Efficient at capturing dynamic network changes; reduces reconstruction errors using gradient descent	Does not fully capture nonlinear patterns in temporal networks; struggles with scalability in large networks
DGEM [15]	Maps dynamic graph data to nonlinear latent space; effectively handles dynamic graph evolution	High computational cost; requires fine-tuning for optimal performance
DDNE [16]	Leverages historical data with GRUs to predict future link changes; effectively models temporal dependencies	Struggles to adapt in highly dynamic environments; performance heavily relies on temporal data quality
EvolveGCN [17]	Combines GCNs and RNNs to capture spatial and temporal dependencies; improves accuracy for evolving graphs	High model complexity; difficult to interpret results
STGSN [19]	Models both spatial and temporal features; utilizes attention mechanisms for better interpretability	High computational overhead; sensitive to noise in the data
GA–GLU (Proposed)	Combines a GAE, GANs, and LSTM networks for more accurate link prediction in UAV networks; captures both spatial and temporal dynamics; improves performance in highly dynamic environments	Requires careful tuning of GAN and LSTM components; slightly higher computational cost compared to simpler models

.

2.3. Traffic Load Balancing in Cloud-Edge-Local Networks

In cloud-edge-local networks, traffic is categorized into elephant flows and mice flows, with 90% of data flows being mice flows. A few elephant flows can generate mice flows, which may lead to significant changes in the network environment and ultimately result in link congestion. Additionally, a large number of packets can occupy the switch’s buffer queue, resulting in head-of-line blocking and increased latency for mice flows. Cloud-edge-local networks typically use the Equal-Cost Multi-Path (ECMP) algorithm [20], which distributes each flow in the network evenly across paths using a hash function. However, the ECMP algorithm cannot detect whether there is congestion in the network. When elephant flows are present, ECMP can assign multiple elephant flows to the same link or path, causing or further exacerbating network congestion and significantly reducing network throughput. The rapid changes in network environments make traditional load-balancing schemes insufficiently responsive to real-time conditions, which often leads to network overload.

The Hedera algorithm [21] selects the optimal forwarding path using simulated annealing and global first-fit matching, effectively avoiding elephant flow congestion and improving bandwidth utilization and network performance. However, it only addresses elephant flow conflicts, neglecting the impact of mice flows on the network. Mao et al. [22] used deep learning to train convolutional neural networks (CNNs) for each path combination under different network scenarios, determining whether the generated paths are congested based on input traffic patterns. The dynamic traffic scheduling strategy proposed by Liu Zhenpeng et al. routes elephant flows based on bandwidth allocation to improve network quality. Sun et al. [23] applied control theory and deep reinforcement learning to reduce network transmission delays, with TIDE as the DRL mechanism for routing optimization. However, due to its reliance on modifying link weights, the optimal routing path can only be indirectly obtained through the shortest path algorithm [23]. Other researchers have proposed ANN-based routing optimization methods for SD-DCN topologies, improving network performance [24] and enhancing network quality [25].

Our algorithm also focuses on the impact of mice flows on network congestion. By combining link prediction results, it employs reinforcement learning algorithms to achieve load balancing in cloud-edge-local networks.

3. Methodology

3.1. Design of Cloud-Edge-Local Architecture

This section explores the design scheme for an elastic resource scheduling architecture based on UAVs in cloud-edge-local networks. The core design concept integrates UAVs into the cloud, edge, and local layers, creating a comprehensive and layered computing and communication framework. This design aims to leverage the unique advantages of UAVs, including dynamic mobility and high flexibility, to achieve efficient and flexible network resource scheduling, thereby ensuring low latency and high reliability of services. Additionally, we use the fat-tree topology for the architecture. The fat-tree topology is highly scalable and excels in handling large-scale network traffic and meeting high-density computing needs.

In the cloud layer, UAVs are assigned significant data processing and storage responsibilities, partially replacing traditional data center functions. UAVs in this layer focus on performing large-scale data analysis tasks, leveraging their rapid deployment capabilities to provide instant computing resources for specific areas or tasks. This also allows UAVs to integrate with existing cloud infrastructure, providing a seamless extension of cloud services.

In the edge layer, UAVs are closer to ground users or sensor networks, primarily undertaking data preprocessing and real-time analysis tasks. At this level, UAVs are flexibly scheduled to adjust their positions and assigned tasks based on actual network conditions and data processing needs, ensuring low latency and high efficiency in data processing. Multi-UAV cooperation at this layer is particularly important for achieving coordinated and efficient data processing, as multiple UAVs work together to balance computational loads and improve service reliability.

In the local layer, UAV deployment is further decentralized and specialized. These UAVs interact directly with ground devices or users and are responsible for collecting data and performing simple edge computing tasks. The deployment of end-layer UAVs significantly enhances network coverage and the real-time collection of data. This decentralized deployment ensures greater system robustness and scalability, allowing the architecture to be integrated with existing sensor networks and communication systems.

To ensure the efficient operation of the aforementioned layered architecture, this paper proposes a comprehensive management and scheduling mechanism that covers key aspects such as link prediction and traffic load balancing. Compared to traditional ground-based stations, this mechanism transforms into a network node that coordinates tasks among UAVs at all layers and dynamically adjusts their flight paths, ensuring the efficient utilization of network resources and the smooth completion of UAV tasks. The coordination between multiple UAVs at different layers facilitates better resource allocation and management, particularly in scenarios that require rapid responses and real-time data processing. The architecture is shown in Figure 1.

3.2. GA–GLU Link Prediction

3.2.1. Architecture

In this study, we designed the GA–GLU algorithm for link prediction in UAV-based cloud-edge-local networks. This model integrates a Graph Autoencoder (GAE), Long Short-Term Memory (LSTM) networks, and Generative Adversarial Networks (GANs) to capture the topological features and temporal evolution patterns of UAV dynamic networks, generating high-quality predictive graph snapshots.

The GA–GLU model consists of three key components, as illustrated in Figure 2.

First, we utilize a Graph Autoencoder (GAE) to learn the topological features of each individual graph snapshot in the dynamic network. The GAE maps the graph snapshot to a low-dimensional representation through an encoder. Then, we introduce Long Short-Term Memory (LSTM) networks to capture the temporal evolution patterns of the dynamic network. LSTM networks effectively remember and learn long-term dependencies in time-series data, helping us better understand the evolution of dynamic networks.

In the model combining GAE and LSTM for graph prediction, the decoder layer of the GAE is primarily used during the training phase to verify whether the generated node embeddings retain the graph’s structural information. The reconstruction ability of the GAE decoder is mainly used to validate the quality of the embeddings by optimizing both the reconstruction loss and the time series prediction loss during training.

We apply Generative Adversarial Networks (GANs) to generate high-quality predictive graph snapshots. In the GANs, we combine a GAE and LSTM networks as the generator to produce predictive graph snapshots. Additionally, we introduce a fully connected discriminator network to distinguish between generated graph snapshots and real records. Through the adversarial process, the generator is trained to produce high-quality predictive results, while the discriminator is trained to effectively differentiate between generated graph snapshots and real records.

In UAV networks, snapshots are represented as discrete time slices $G_{t_k}=\{V_{t_k},E_{t_k}\}$, where $V_{t_k}$ and $E_{t_k}$ denote the set of nodes and edges at time $t_k$, respectively. The weight $w_{ij}$ of a link between nodes $v_i$ and $v_j$ is calculated using the following equation:

$$w_{ij}=\left\{\begin{array}{cc}{\displaystyle \frac{D_i·{log}_2(1+{\gamma }_{ij})}{d_{ij}}},\hfill & d_{ij}\le D_i\hfill \\ 0,\hfill & d_{ij}>D_i\hfill \end{array}\right.$$

(1)

where $d_{ij}$ is the distance between nodes, $D_i$ is the maximum communication radius, and ${\gamma }_{ij}$ is the signal-to-noise ratio.

By integrating a GAE, LSTM networks, and GANs, the GA–GLU model comprehensively captures the topological features and temporal evolution patterns of UAV dynamic networks, generating high-quality predictive graph snapshots and thereby achieving effective temporal link predictions. The algorithm is shown in Algorithm 1.

Algorithm 1 GA–GLU Prediction Algorithm
Input: Graph snapshots $\{G_1,G_2,\cdots ,G_T\}$
Output: Predicted future graph snapshot $G_{T+1}$
1: // Initialize GAE and LSTM networks
2: Initialize GAE encoder $Enc$ and decoder $Dec$
3: Initialize LSTM network $LSTM$
4: Initialize GAN generator G and discriminator D
5: // Process each graph snapshot
6: for$t=1$ to T do
7:    $z_t\leftarrow Enc\left(G_t\right)$	▹ Encode the current graph snapshot
8:    $G_t^{\prime }\leftarrow Dec\left(z_t\right)$	▹ Decode to reconstruct the graph
9:    Feed $z_t$ into $LSTM$	▹ Input to LSTM to update hidden state
10: end for
11: // Use LSTM’s output to predict the next state
12: $z_{T+1}\leftarrow LSTM\left(\mathrm{last}\mathrm{hidden}\mathrm{state}\right)$
13: $G_{T+1}^{\prime }\leftarrow Dec\left(z_{T+1}\right)$	▹ Decode to predict the next graph snapshot
14: // Train GAN
15: repeat
16:    Sample mini-batch of real snapshots $\left\{G_i\right\}$
17:    Generate fake snapshots $\left\{G_i^{\prime }\right\}$ from G
18:    Train discriminator D to distinguish real from fake
19:    Train generator G to fool D
20: until convergence
21: return $G_{T+1}^{\prime }$	▹ Return the predicted future graph snapshot

The GA–GLU prediction algorithm leverages a combination of a Graph Autoencoder (GAE), Long Short-Term Memory (LSTM) networks, and Generative Adversarial Networks (GANs) to predict future UAV network topologies. The algorithm starts by encoding each graph snapshot $G_t$ into a low-dimensional latent representation $z_t$ using the GAE encoder $Enc$, followed by reconstructing the graph snapshot ${\widehat{G}}_t$ through the decoder $Dec$. The latent representations $z_t$ are sequentially fed into the LSTM network, which captures the temporal dependencies across snapshots and uses its final hidden state to predict the latent representation $z_{T+1}$ for the future graph. This predicted latent representation is then decoded into the future graph ${\widehat{G}}_{T+1}$ using $Dec$. To further refine the predicted graph, a GAN consisting of a generator G and discriminator D is employed. The generator produces fake graph snapshots, while the discriminator is trained to distinguish between real and fake graphs. Through iterative training, the generator learns to produce more realistic graphs, ensuring the final prediction closely resembles the actual network structure.

3.2.2. GAE Layer

We utilize a Graph Autoencoder (GAE) to model the local topological structure of each individual graph snapshot in dynamic networks. The GAE consists of a Graph Convolutional Network (GCN) encoder layer and an inner-product decoder layer. The GCN is an efficient variant of convolutional neural networks that operates directly on graphs. Formally, assume a static graph with N nodes, where each node has M-dimensional features (or attributes). The topological structure and node attributes can be represented by an adjacency matrix $\mathrm{A}\in {\mathbb{R}}^{\mathrm{N}\times \mathrm{M}}$ and a feature matrix $\mathrm{Z}\in {\mathbb{R}}^{\mathrm{N}\times \mathrm{M}}$ (where the i-th row of $\mathrm{Z}\in {\mathbb{R}}^{\mathrm{N}\times \mathrm{M}}$ corresponds to the feature vector of node i), respectively. A typical GCN unit takes the feature matrix $\mathrm{Z}\in {\mathbb{R}}^{\mathrm{N}\times \mathrm{M}}$ as input and performs spectral graph convolution (a local first-order approximation according to $\mathrm{A}\in {\mathbb{R}}^{\mathrm{N}\times \mathrm{M}}$). The final output is generated in the same way as a standard fully connected layer. The overall operation of a specific GCN unit can be succinctly defined as follows:

$$\mathrm{X}=GCN(\mathrm{Z},\mathrm{A})=\mathrm{f}\left({\widehat{\mathrm{D}}}^{-1/2}\widehat{\mathrm{A}}{\widehat{\mathrm{D}}}^{-1/2}\mathrm{ZW}\right)$$

(2)

In the above equation, ${\widehat{\mathrm{D}}}^{-1/2}\widehat{\mathrm{A}}{\widehat{\mathrm{D}}}^{-1/2}$ is the approximate graph convolution filter, where $\widehat{\mathrm{A}}=\mathrm{A}+{\mathrm{I}}_{\mathrm{N}}$ (which is an N-dimensional identity matrix) and ${\widehat{\mathrm{D}}}_{\mathrm{ii}}={\sum }_{\mathrm{j}=1}^{\mathrm{N}}{\widehat{A}}_{ij}$; W represents the weight matrix; f(·) is the activation function; and X is the representation output given by the GCN unit.

For the task of temporal link prediction considering multiple static graphs, the GA–GLU model inputs each graph snapshot. ${\mathrm{A}}_t(t\in \{\tau -l,\cdots ,\tau \})$ maintains a GCN unit $GCN(Z,A_t)=X_t$. In our model, the feature matrix Z is set as the noise input to the generative network, where the values of Z are generated according to a certain probability distribution (e.g., uniform distribution). Based on the input Z and ${\mathrm{A}}_{\tau -l}^{\tau }=\{{\mathrm{A}}_{\tau -l},\cdots ,{\mathrm{A}}_{\tau }\}$, the GCN layer of the generative network outputs a series of representations, denoted as ${\mathrm{X}}_{\tau -l}^{\tau }=\{{\mathrm{X}}_{\tau -l},\cdots ,{\mathrm{X}}_{\tau }\}$. The output of the encoder is then fed into the LSTM layer.

3.2.3. LSTM Layer

In the GA–GLU model, the learned comprehensive network representations are fed into an LSTM layer. The LSTM layer has a strong capability to learn long-term dependencies in sequential data to capture the evolution patterns of weighted dynamic networks. The standard LSTM architecture can be described as an encapsulated unit with multiple multiplicative gate units. For a specific time step t, the LSTM unit receives the current input vector $x_t$ and the state vector $h_{t-1}$ from the previous time step as inputs and then outputs the state vector $h_t$ for the current time step. The LSTM–decoder structure is shown in Figure 3.

$${\mathrm{i}}_t=\sigma \left({\mathrm{W}}_x^i{x}_t+{\mathrm{W}}_h^i{h}_{t-1}+b^i\right)$$

(3)

$${\mathrm{f}}_{\mathrm{t}}=\sigma \left({\mathrm{W}}_x^f{x}_t+{\mathrm{W}}_h^f{h}_{t-1}+b^f\right)$$

(4)

$${\mathrm{o}}_t=\sigma \left({\mathrm{W}}_x^o{x}_t+{\mathrm{W}}_h^o{h}_{t-1}+b^o\right)$$

(5)

$${\mathrm{s}}_t={\mathrm{f}}_t\odot s_{st-1}+i_t\odot {\widehat{s}}_t$$

(6)

$${\widehat{s}}_t=\sigma \left({\mathrm{W}}_x^s{x}_t+{\mathrm{W}}_h^s{h}_{t-1}+b^s\right)$$

(7)

$$h_t=o_t\odot tanh\left(s_t\right)$$

(8)

In the above equations, $i_t$, ${\mathrm{f}}_{\mathrm{t}}$, ${\mathrm{o}}_t$, and ${\mathrm{s}}_t$ represent the input gate, forget gate, output gate, and memory cell, respectively. The parameters ${\mathrm{W}}_{\mathrm{x}}$, ${\mathrm{W}}_h$, and b correspond to the weights and biases of the units, which control how the information flows through the network. The activation function $f_t$ is a sigmoid function that ensures the gates operate within the range [0, 1]. The operator ⊙ denotes element-wise multiplication, enabling selective updates to the cell state. Finally, we consider the last hidden state as the distributed representation of the historical snapshots and feed it into a fully connected layer to generate the prediction results ${\tilde{\mathrm{A}}}_{\tau +1}$.

Since the LSTM framework has the ability to learn temporal information from sequential data, it can be directly used to handle temporal link prediction tasks with a multiple-input, single-output setup. However, there are still some limitations in predicting weighted dynamic networks. Specifically, to learn the temporal information of dynamic networks, the LSTM is usually trained using the mean squared error (MSE) loss function.

3.2.4. GAN Layer

To address the sparsity and wide range of edge weights in dynamic networks, we enhanced the generation capability of LSTM using a GAN framework. Generally, a GAN consists of a generator G and a discriminator Q, which compete in a minimax game. Initially, D attempts to distinguish between real data from the training set and data generated by G. Conversely, G aims to deceive D by generating high-quality samples (data). Formally, this process can be described as follows (with two alternating optimization steps):

$$\underset{G}{min}\underset{D}{max}\left(\begin{array}{c}{E}_{x\sim P_{\mathrm{data}}\left(x\right)}[log\left(D\left(x\right)\right)]+\\ E_{z\sim P\left(z\right)}[log(1-D\left(G\left(z\right)\right))]\end{array}\right)$$

(9)

The input data x are derived from the training set, and z represents the noise generated from a certain probability distribution $p\left(z\right)$ (e.g., uniform distribution). Similar to the standard GAN framework, our model optimizes two neural networks through a minimax two-player game, namely the generator G and the discriminator D. In this model, D attempts to distinguish between real image snapshots from the training data and snapshots generated by G, while G maximizes the probability of D making an error. This adversarial process is expected to eventually refine G to produce realistic and high-quality weighted links. The two neural networks are described as follows:

(a) Discriminator Network D: We implement the discriminator model D using a fully connected feedforward neural network with one hidden layer and one output layer. During training, D alternately uses the output of G, ${\tilde{\mathrm{A}}}_{\tau +1}$, or the ground truth, ${\mathrm{A}}_{\tau +1}$, as input. Since each input data point in a fully connected neural network is typically represented as a vector (rather than a matrix), we reshape the matrix inputs (i.e., ${\tilde{\mathrm{A}}}_{\tau +1}$ or ${\mathrm{A}}_{\tau +1}$) into corresponding row-major vectors before feeding them into D. We train the model within the Wasserstein GAN (WGAN) [26] framework, setting the output layer as a linear layer to directly generate outputs without a nonlinear activation function. In summary, the details of the discriminator network D are as follows:

$$D\left(A^{\prime }\right)=(\sigma (a^{\prime }{W}_h^D+b_h^D)W_o^D+b_o^D)$$

(10)

where A′ represents the reshaped row vectors of ${\tilde{\mathrm{A}}}_{\tau +1}$ or ${\mathrm{A}}_{\tau +1}$; $\{{\mathrm{W}}_h^D,{\mathrm{b}}_h^D\}$ and $\{{\mathrm{W}}_o^D,{\mathrm{b}}_o^D\}$ are the parameters of the hidden and output layers, respectively; and $\sigma (\cdot )$ denotes the sigmoid activation function of the hidden layer.

Given that the edge weights of a network snapshot can vary widely (e.g., [0, 2000]), we normalize the values of ${\mathrm{A}}_{\tau +1}$ to the [0, 1] range when selecting ${\mathrm{A}}_{\tau +1}$ as the input for D. The raw prediction results from G, defined within the [0, 1] range, can thus be directly used as inputs for D.

(b) Generator Network: The generator model G comprises a GCN layer, an LSTM layer, and a fully connected output layer. The GCN layer takes the sequence of graph snapshots ${\mathrm{A}}_{\tau -l}^{\tau }$ and noise Z as inputs and outputs a representation sequence ${\mathrm{X}}_{\tau -l}^{\tau }$, which is subsequently fed into the LSTM layer.

Note that each adjacency matrix input ${\mathrm{A}}_{\mathrm{t}}(t\in \{\tau -l,\cdots ,\tau \})$ should be normalized to the [0, 1] range before being fed into the GCN layer. We use sigmoid as the activation function for all GCN units, and the noise input Z follows a uniform distribution within the [0, 1] range (denoted as $\mathrm{Z}\sim \mathrm{U}(0,1)$).

The LSTM layer takes the representation sequence ${\mathrm{X}}_{\tau -l}^{\tau }$ from the GCN layer as input and outputs a hidden state ${\mathrm{h}}_{\tau -l}^{\tau }=\{h_{\tau -l},\cdots ,h_{\tau }\}$. It is important to note that each matrix input ${\mathrm{X}}_t(\mathrm{t}\in \{\tau -\mathrm{l},\cdots ,\tau \})$ should be reshaped into row-major vectors ${\mathrm{X}}_{\mathrm{t}}$ when fed into the LSTM since each LSTM unit treats the input data as vectors. Finally, the last hidden state ${\mathrm{h}}_{\tau }$ is fed into the output layer to generate the graph snapshot ${\tilde{\mathrm{A}}}_{\tau +1}$ for the next time step (in the form of corresponding row vectors). Specifically, an element of a generated result lies within the [0, 1] range. By performing an inverse normalization process, we can obtain the final predicted snapshot ${\tilde{\mathrm{A}}}_{\tau +1}$ with the correct value range for the dynamic network.

3.3. FERL-LB Algorithm

3.3.1. Architecture

With the rapid advancement of UAV technology, UAV networks are playing an increasingly important role in cloud-edge-local architectures. Due to the highly dynamic nature and environmental uncertainties of UAV networks, traditional network resource scheduling and traffic load-balancing strategies often fail to meet their demands. This section aims to propose a reinforcement learning-based FERL-LB algorithm that combines the fat-tree network topology of UAVs and the GA–GLU link prediction method to optimize elastic resource scheduling and traffic load balancing in cloud-edge-local networks. The core of the FERL-LB algorithm is a reinforcement learning-based decision engine that learns and adapts in real time to changes in network conditions to optimize traffic routing decisions.

To enhance the performance of traffic load balancing in UAV cloud-edge-local networks under dynamic and uncertain environments, this study introduces a traffic management strategy that incorporates reinforcement learning, namely the FERL-LB algorithm, using a Double Deep Q-Network (DDQN). This algorithm intelligently predicts and adjusts traffic routing to adapt to rapid changes in network conditions, thereby optimizing network resource utilization and improving data transmission efficiency.

The framework of the FERL-LB algorithm is shown in Figure 4.

The FERL-LB algorithm is based on a Double Deep Q-Network (DDQN) to optimize routing decisions in network environments. Initially, a primary network Q and a target network $\widehat{Q}$ are randomly initialized with weights $\theta$ and ${\theta }^{-}$, respectively. The replay memory D is also initialized to store transitions for experience replay. The algorithm operates in an iterative loop until convergence.

At each iteration, the current network state is observed, and future link states are predicted using a link prediction model. Based on the $ϵ$-greedy policy, an action a is selected from the Q-network, which dictates the rerouting of network traffic. The algorithm then observes the new state $s^{\prime }$ and computes the reward r, storing the transition $(s,a,r,s^{\prime })$ in memory D.

A mini-batch of transitions is sampled from D for training the DDQN. The target value $y_j$ is computed using the target network $\widehat{Q}$, while the Q network is updated through gradient descent. The target network $\widehat{Q}$ is periodically reset to the weights of the primary network Q. Additionally, in the event of predicted congestion, traffic flows are reallocated using the FlowBender mechanism to minimize congestion. The algorithm is shown in Algorithm 2.

Algorithm 2 FERL-LB Algorithm Using DDQN

Input:  Network state, Link prediction model Output:  Optimized routing decisions 1: // Initialize the network and DDQN model 2: Initialize primary network Q with random weights $\theta$ 3: Initialize target network $\widehat{Q}$ with weights ${\theta }^{-}=\theta$ 4: Initialize replay memory D 5: // Main loop 6: while not converged do 7:       $s\leftarrow$ observe current network state 8:       $predictedLinks\leftarrow$ predict links using Link prediction model 9:       $a\leftarrow$ select action using $ϵ$-greedy policy from Q 10:     Execute action a, reroute traffic accordingly 11:     $s^{\prime }\leftarrow$ observe new network state 12:     $r\leftarrow$ compute reward from $s,a,s^{\prime }$ 13:     Store transition $(s,a,r,s^{\prime })$ in D 14:     // Sample a mini-batch from replay memory for learning 15:     Sample mini-batch of transitions $(s_j,a_j,r_j,s_j^{\prime })$ from D 16:     // DDQN update 17:     Set $y_j\leftarrow r_j+\gamma \widehat{Q}(s_j^{\prime },arg{max}_{a^{\prime }}Q(s_j^{\prime },a^{\prime };\theta );{\theta }^{-})$ 18:     Perform a gradient descent step on ${(y_j-Q(s_j,a_j;\theta ))}^2$ with respect to $\theta$ 19:     Every C steps reset $\widehat{Q}=Q$ 20:     $s\leftarrow s^{\prime }$ 21:     // Adjust traffic based on link prediction and network status 22:     if congestion detected in $predictedLinks$ then 23:         Reallocate flows to minimize congestion based on FlowBender 24:     end if 25: end while

3.3.2. Deep Q-Networks and Double Q-Learning

The Deep Q-Network (DQN) algorithm combines deep learning and reinforcement learning techniques, using a single Q-network to approximate the action-value function. This Q-network, denoted as $Q(s,a;\theta )$, where s represents the state, a represents the action, and $\theta$ represents the network parameters, is trained via gradient descent to minimize the difference between predicted and target Q-values. The DQN algorithm leverages experience replay to enhance learning efficiency and stability. However, it suffers from overestimation bias, which can degrade performance during training.

To address this limitation, the Double Deep Q-Network (DDQN) algorithm extends the DQN by incorporating two separate Q-networks: one for action selection and the other for action evaluation. This separation reduces overestimation by decoupling the selection of the best action from the evaluation of its value. Specifically, the first network selects the action, while the second network evaluates the Q-value of this selected action. This dual-network approach significantly improves stability and reduces bias.

The loss function in the DDQN is given by

$$L\left(\theta \right)={\left(R+\gamma Q\left(s^{\prime },arg\underset{a^{\prime }}{max}Q(s^{\prime },a^{\prime };\theta );{\theta }^{-}\right)-Q(s,a;\theta )\right)}^2$$

(11)

where $L\left(\theta \right)$ is the loss function, R is the reward, $\gamma$ is the discount factor, $s^{\prime }$ is the next state, $a^{\prime }$ is the next action, ${\theta }^{-}$ represents the parameters of the target Q-network, and $Q(s^{\prime },a^{\prime };\theta )$ is the estimated Q-value. The target network parameters ${\theta }^{-}$ are periodically updated to improve the stability of training.

3.3.3. Traffic Forwarding Design

In this subsection, we delve into the intricacies of traffic forwarding design within a network environment. Our focus is on comprehensively understanding the network state, devising effective actions for data flow routing, formulating appropriate reward functions for optimizing different types of traffic, and employing advanced link adjustment techniques to mitigate congestion. By leveraging these components, we aim to enhance the overall efficiency and reliability of network traffic management. The critical components of traffic forwarding design are as follows:

(1) State

In the current network environment, the port load of switches and the bandwidth of links are defined as the network state. The network state space can be represented as $S=[P_{S_i,t},U_{S_i,t}],t\in [1,n]$, where S represents the network state space, $P_{S_i,t}$ is the port load of the i-th switch at time t, $U_{S_i,t}$ is the link bandwidth utilization of the i-th switch at time t, with values ranging from 0 to 1, and n is the number of switches.

(2) Action

An action a in the data flow implies selecting a subset of nodes $a{p}_n$ from the network, constructing a list of nodes and their corresponding links to form single or multiple paths, thus transmitting traffic from the source to the destination. Each action corresponds to a specific end-to-end path, and the action space A is expressed as

$$A=[a{p}_1,a{p}_2,\cdots ,a{p}_n]$$

(12)

Here, $a{p}_n$ refers to a specific subset of nodes that are involved in constructing one of the possible paths in the network. The action space A encompasses all potential paths that can be selected, where each path consists of a sequence of nodes facilitating the transmission of traffic.

(3) Reward

Different reward functions are designed for large flows and small flows using CNNs. For large flows, which require high throughput and low packet loss, the reward function is given by

$${\mathrm{R}}_L={\alpha }_L{H}_{L,A}+{\beta }_L\left(1-L_{L,A}\right)$$

(13)

where $R_L$ is the reward function for large flows; $H_{L,A}$ is the average throughput of large flows; $L_{L,A}$ is the average packet loss rate of large flows; and ${\alpha }_L$ and ${\beta }_L$ are weight coefficients, where ${\alpha }_L+{\beta }_L=1$.

For small flows, which require low latency and low packet loss, the reward function is expressed as

$$R_{\mathrm{N}}={\alpha }_N(1-t_{N,A})+{\beta }_N(1-L_{N,A})$$

(14)

where $R_{\mathrm{N}}$ is the reward function for small flows; $t_{N,A}$ is the average round-trip time of small flows; $L_{N,A}$ is the average packet loss rate of small flows; and ${\alpha }_N$ and ${\beta }_N$ are weight coefficients, where ${\alpha }_N+{\beta }_N=1$.

(4) Link Adjustment

When the link prediction model detects congestion on a predicted link, the FERL-LB algorithm employs a FlowBender-based traffic redistribution mechanism to alleviate the congestion. It predicts future link states using a link prediction model and, in conjunction with the current network status, identifies links that may experience congestion. When the predicted traffic for a link exceeds its capacity threshold, it is considered to be on the verge of congestion. Upon detecting a congested link, the algorithm makes traffic redistribution decisions based on the FlowBender mechanism [27]. The core idea of FlowBender is to optimize traffic path selection to minimize congestion within the network. To perform traffic redistribution, the algorithm first determines alternative paths. The selection of these alternative paths is based on their available bandwidth and ability to handle the redistributed traffic, thereby avoiding further congestion on the new paths. Once the alternative paths are identified, the algorithm shifts a portion of the traffic from the congested link to these alternative paths. This process can be implemented by adjusting the routing table to ensure that data packets are forwarded along the new paths.

4. Experiment

4.1. Link Prediction

This study uses the AirSim simulation platform to simulate complex network topologies and UAV flight environments. The model is validated using classic link prediction evaluation metrics: AUC, MAP (mean average precision), and error rate [20].

As shown in

Table 2. AirSim configuration for UAV swarm simulation.

Configuration Parameter	Value
Number of UAVs	36
Simulation Duration (s)	1000
Max Speed (m/s)	15
Communication Range (m)	500
Starting Altitude (m)	100
Control Algorithm	Distributed Control
Scanning Phase Duration (s)	0–500
Hovering Phase Duration (s)	500–1000
Data Collection Frequency (Hz)	10
Network Type	Mesh

, a total of 36 UAVs are deployed in a custom airspace, each with a maximum speed of 15 m/s. The UAVs start at an altitude of 100 m and have a communication range of 500 m. The simulation is divided into two phases: from 0 to 500 s, the UAV swarm is in the scanning phase, spreading outwards from the starting point. After 500 s, the UAVs enter the hovering phase, maintaining coverage of the target airspace. A distributed control algorithm is used to manage the UAVs.

To validate the effectiveness of the proposed GA–GLU link prediction algorithm, we conduct a comparison with several representative methods. These include the classical CN and Katz algorithms; the Node2vec method, which relies on node embeddings [28]; and the GAE–LSTM method, which is based on graph embeddings. Unlike GA–GLU, GAE–LSTM does not utilize a GAN component. The comparison is designed to highlight the specific improvements introduced by the GA–GLU algorithm.

In similarity-based link prediction methods, the probability of a connection between nodes is based on the similarity between those nodes. The AUC is calculated as follows:

$$\mathrm{AUC}={\displaystyle \frac{M^{\prime }+0.5M^{″}}{M}}$$

(15)

where M is the total number of comparisons, M′ is the number of times the score of an edge in the positive set is greater than that in the negative set, and M″ is the number of times the scores are equal. The larger M′ and M” are, the higher the probability that the positive set scores are higher than the negative set scores, indicating higher prediction accuracy.

The MAP is the area under the precision–recall (P–R) curve:

$$\mathrm{MAP}={\displaystyle \frac{{\sum }_{t=1}^N\mathrm{AP}\left(t\right)}{N}}$$

(16)

$$\mathrm{AP}={\displaystyle \frac{1}{n}}\sum _{i=1}^n\sum _{j=1}^n{\displaystyle \frac{\left|\left\{a_{i,j}=1\right\}\cap \left\{{\widehat{a}}_{i,j}=1\right\}\right|}{\left|\left\{a_{i,j}=1\right\}\right|}}$$

(17)

where MAP measures the accuracy of the prediction results. Specifically, MAP is computed as the mean of the average precision (AP) scores across all queries or tasks. The AP score itself quantifies the precision of the predicted results relative to the number of relevant items, averaged over all possible ranks.

The error rate is the ratio of incorrect links $\mathrm{L}{\mathrm{N}}_{\mathrm{false}}$ to all actual links $\mathrm{L}{\mathrm{N}}_{\mathrm{true}}$. The error rate is calculated as

$$\mathrm{Error}\mathrm{Rate}={\displaystyle \frac{\mathrm{L}{\mathrm{N}}_{\mathrm{false}}}{\mathrm{L}{\mathrm{N}}_{\mathrm{true}}}}$$

(18)

The error rate measures the proportion of links that are incorrectly identified relative to the total number of actual links. Specifically, $\mathrm{L}{\mathrm{N}}_{\mathrm{false}}$ represents the number of false links (incorrectly identified links), while $\mathrm{L}{\mathrm{N}}_{\mathrm{true}}$ represents the number of true links (actual links). A higher error rate indicates a greater proportion of misidentified links.

To ensure the validity of the experiments, all comparative experiments were conducted using data samples with the optimal model parameters proposed in this study. Each set of experiments was sampled 20 times to calculate the corresponding AUC, MAP, and error rate. The static network link prediction methods CN, Katz, and Node2vec were used to analyze the network status in the current snapshot to predict the network links at the next time point.

Figure 5 illustrates the prediction performance of different link prediction models under the same environment, as reflected by the AUC metric. It can be observed that deep learning-based link prediction methods, such as Node2vec-LSTM, GAE–LSTM, and our proposed GA–GLU, are relatively more stable compared to other methods. Overall, GA–GLU consistently achieves higher AUC values across 20 test samples than other methods, with CN and Katz exhibiting the poorest performance.

Figure 6 presents the MAP values obtained by different link prediction methods. It is evident that, except for the three deep learning-based link prediction methods, the MAP values of other methods remain below 0.5. Even though Node2vec-LSTM reaches 0.5 in the first case, its generalization performance is lower. The error rate metric similarly reflects that, aside from the three deep learning-based prediction methods, other methods fail to achieve satisfactory prediction results. Node2vec-LSTM exhibits more stable performance compared to Node2vec-LRCV, demonstrating that deep learning models possess better generalization than traditional machine learning models.

The experimental results presented in Figure 7 indicate that the GA-GLU algorithm consistently outperforms other methods in terms of error rates, achieving the lowest values. In

Table 3. Comparison of link prediction results.

Method	AUC	MAP	Error Rate
CN	0.883659	0.107073	4.038485
Katz	0.897741	0.118954	3.811238
Node2vec-LRCV	0.915489	0.157554	3.157558
Node2vec-LSTM	0.901738	0.409950	3.462399
GAE–LSTM	0.984325	0.777592	1.324715
GA–GLU	0.946060	0.756796	1.015201

, the GA–GLU method proposed in this paper demonstrates clear advantages in UAV network link prediction. The results shown are the average values from 20 sampling iterations, ensuring the robustness and reliability of the comparison. GA–GLU outperforms traditional methods such as CN and Katz across all key metrics, particularly in AUC and MAP, achieving values of 0.946060 and 0.756796, respectively. This indicates that GA–GLU has superior predictive accuracy and is more effective at identifying correct links in the network. Additionally, the error rate of GA–GLU is the lowest among all methods at 1.015201, further highlighting its robustness in minimizing prediction errors. These results validate the potential of GA–GLU to enhance link prediction performance in complex and dynamic UAV networks.

4.2. Load Balancing

This study utilizes a flow-level traffic scheduling simulator based on the fat-tree topology, with a link bandwidth of 1 Gbps. Traffic is generated using the DCTCP model, and the throughput and latency of various load-balancing algorithms are compared to assess their performance.

Three sets of traffic were generated, each with similar sizes and rates to ensure reproducibility of the simulation results. To apply a significant load on the network links and accurately reflect the algorithms’ effectiveness, approximately 25,000 back flows and 200,000 query flows were included. The total size of the back flows was around 30 billion bytes, while the query flows totaled 7 billion bytes, for a combined total of 220,000 flows. The average link bandwidth exceeded 0.8 Gbps, demonstrating the load-balancing algorithms’ scheduling capabilities.

The performance of the load-balancing algorithms was evaluated using five main metrics: average throughput, small-flow completion time (FCT), packet loss rate (PLR), the number of flows not completed within the expected time, and end-to-end latency.

The average throughput was measured across multiple simulation runs. Assuming there are n servers and m simulation runs, the average throughput is calculated as shown below. The unit is typically bits per second (bps) or bytes per second (Bps); in this experiment, Mbps (megabits per second) is used. The higher the average throughput, the better the network bandwidth utilization and the performance of the load-balancing algorithm.

$$TPS={\displaystyle \frac{{\sum }_{j=1}^{m}TP{S}_j}{\mathrm{m}}}$$

(19)

$TP{S}_j$ represents the throughput for each simulation run. The calculation of the throughput uses the expected completion time, with the formula for $TP{S}_j$ as follows:

$$TP{S}_j={\displaystyle \frac{{\sum }_{j=1}^n{T}_j}{\mathrm{n}}}$$

(20)

where $T_j$ is the throughput of the j-th server.

This metric mainly reflects the transmission conditions of small flows in the experiment. Since the generated file specifically includes a type of query flow data with a fixed size of 20,480 bytes (20 KB), it helps evaluate network congestion caused by large flows leading to small-flow congestion. The transmission time of small flows can effectively indicate network congestion. Assuming the simulation is conducted m times, the FCT is calculated as follows:

$$FCT={\displaystyle \frac{{\sum }_{j=1}^{m}FC{T}_j}{\mathrm{m}}}$$

(21)

where $FC{T}_j$ represents the transmission time of the k-th small flow.

Assuming that in a single simulation run, the average transmission delay of small flows received by each server is t and there are n servers in total, the formula for $FC{T}_j$ is

$$FC{T}_j={\displaystyle \frac{t}{n}}$$

(22)

The smaller the value of the small-flow FCT, the better the performance of the load-balancing algorithm.

Since the minimum expected completion time for the generated traffic is 10 s, the number of flows that remain unscheduled after 10 s can partially reflect the performance of various load-balancing algorithms. The faster the number of unscheduled flows converges over time, the better the performance of the load-balancing algorithm.

Since the simulator is task-driven, a smaller end-to-end delay of task traffic indicates better transmission performance. Here, the average delay of all traffic is considered. The smaller the end-to-end delay of the total task traffic, the better the performance of the load-balancing algorithm.

The packet loss rate (PLR) refers to the percentage of packets that are lost in the network during transmission. A lower packet loss rate indicates better performance of the load-balancing algorithm, as it reflects more reliable transmission of data. The PLR is calculated as follows:

$$PLR={\displaystyle \frac{P_{\mathrm{lost}}}{P_{\mathrm{sent}}}}\times 100\%$$

(23)

where $P_{\mathrm{lost}}$ is the number of packets lost during transmission and $P_{\mathrm{sent}}$ is the total number of packets sent. The smaller the PLR, the better the network’s performance in terms of reliability and efficiency.

Using the traffic generation and experimental performance metrics described in the previous sections, three sets of experiments were conducted. The subjects of the experiments were four load-balancing algorithms—ECMP, WCMP, FlowBender, and FERL-LB—along with a control group that used random path selection without load balancing. Some experimental results are shown in the figures below.

After data processing, comparative experiments were conducted on the small-flow task transmission delay (FCT), packet loss rate (PLR), average throughput, and end-to-end task transmission delay. The experimental results are shown below.

From the experimental results (Figure 8, Figure 9, Figure 10 and Figure 11), the following key conclusion can be drawn: load-balancing algorithms significantly outperform non-load-balancing path selection algorithms under heavy traffic loads. Among these algorithms, ECMP performs the worst, while WCMP and FlowBender exhibit similar performance. The newly designed FERL-LB algorithm excels in throughput, matching the performance of the best algorithm, FlowBender, and exhibits better performance in small-flow transmission latency, improving on the original FlowBender.

The packet loss rates for the random, ECMP, WCMP, FlowBender, and FERL-LB algorithms are shown in Figure 12. At lower network loads (0.1 and 0.2), congestion is minimal, resulting in low packet loss for all algorithms. As the load increases, congestion causes the packet loss to rise sharply. Among the algorithms, FERL-LB performs the best by efficiently allocating forwarding paths for both large and small flows, leading to the slowest increase in the packet loss rate.

Analyzing the metrics, WCMP and FlowBender both achieve average throughputs close to 800 Mbps. However, in terms of the number of remaining flows that have not been successfully transmitted within the scheduled time for a transmission task, the random path selection algorithm and ECMP have many unallocated flows, while FlowBender converges faster. Regarding transmission delay, FlowBender and WCMP perform similarly, but in terms of small-flow average transmission delay, FlowBender underperforms. The FERL-LB algorithm improves on this, indicating a positive impact on small-flow transmission.

5. Summary

This study proposes a novel UAV-based elastic scheduling architecture for cloud-edge-local network resources, innovatively combining the fat-tree topology with the flexibility of UAVs to enhance the flexibility and efficiency of network resource management. By deploying UAV nodes at different levels, we achieved dynamic allocation and optimization of network resources, considerably improving the scalability and management efficiency of the network.

In terms of UAV network link prediction, we introduced the GA–GLU graph representation learning method. By integrating a Graph Autoencoder (GAE) and Generative Adversarial Networks (GANs), we successfully predicted changes in UAV network links, enabling dynamic resource scheduling. This approach effectively captures network dynamics and structural changes, providing real-time adjustments for optimized resource distribution. This method effectively captures the patterns of network dynamic changes through deep learning techniques, thereby improving the accuracy and efficiency of resource scheduling.

For UAV network load balancing, we introduced the FERL-LB algorithm, which integrates reinforcement learning to optimize traffic load balancing based on link predictions. This significantly improves network performance and resource utilization. By efficiently redistributing traffic based on predicted link changes, the algorithm adapts to evolving network conditions, performing excellently in handling highly dynamic network environments and providing a more efficient solution for traffic management and quality-of-service assurance.

Future research directions include further optimization of scheduling algorithms to adapt to more complex network environments and a wider range of application scenarios. Furthermore, it is essential to explore strategies for enhancing the security and stability of UAV networks to effectively address potential security threats and attacks.