Fed4UL: A Cloud–Edge–End Collaborative Federated Learning Framework for Addressing the Non-IID Data Issue in UAV Logistics

Abstract

Artificial intelligence and the Internet of Things (IoT) have brought great convenience to people’s everyday lives. With the emergence of edge computing, IoT devices such as unmanned aerial vehicles (UAVs) can process data instantly at the point of generation, which significantly decreases the requirement for on-board processing power and minimises the data transfer time to enable real-time applications. Meanwhile, with federated learning (FL), UAVs can enhance their intelligent decision-making capabilities by learning from other UAVs without directly accessing their data. This facilitates rapid model iteration and improvement while safeguarding data privacy. However, in many UAV applications such as UAV logistics, different UAVs may perform different tasks and cover different areas, which can result in heterogeneous data and add to the problem of non-independent and identically distributed (Non-IID) data for model training. To address such a problem, we introduce a novel cloud–edge–end collaborative FL framework, which organises and combines local clients through clustering and aggregation. By employing the cosine similarity, we identified and integrated the most appropriate local model into the global model, which can effectively address the issue of Non-IID data in UAV logistics. The experimental results showed that our approach outperformed traditional FL algorithms on two real-world datasets, CIFAR-10 and MNIST.

1. Introduction

1.1. Background

Artificial intelligence (AI) technology is advancing rapidly, and together with the widespread use of the Internet, sensors, and digital devices, we are being connected in unprecedented ways [1]. We have entered the era of big data, characterised by an overwhelming increase in information. This digital transformation is reshaping society, becoming a fundamental part of our daily lives and driving significant changes. Everyday activities, from sending emails to operating UAVs, now generate vast amounts of data [2]. These data are essential for improving systems, particularly logistics and transportation involving UAVs. As a transformative technology, UAVs have been widely used in various fields. These include logistics distribution, disaster management, surveillance, and agricultural monitoring. UAVs are valued for their flexible operation, high cost effectiveness, and real-time collection of high-resolution data. However, the deployment of drone networks faces several challenges. These challenges include data storage, privacy issues, security concerns, and technical limitations such as the limited battery life. Despite these challenges, drone networks continue to play a key role in modern technology [3].

Cloud computing has become essential for managing data storage, access, and computing resources efficiently. It is especially useful in operating UAVs for logistics operations, where it supports real-time data analysis for optimising routes, managing traffic, and tracking shipments [4]. However, as UAVs and AI technology become more prevalent in logistics, cloud computing’s limitations are becoming clearer. These include network delays, data privacy concerns, regulatory compliance hurdles, and the high costs of managing these systems [5]. These challenges underscore the critical need for new solutions that enhance efficiency, protect privacy, and scale effectively in UAV-based logistics systems.

To overcome these challenges of cloud computing, edge computing offers a significant solution for enhancing the efficiency and security of UAV logistics operations. By processing data close to where they originate, such as directly on the UAVs or at the edge servers located nearby, this technology greatly reduces response times and bolsters data security [6]. This strategic placement of computing resources diminishes the risks of data breaches and cyberattacks and is crucial for the secure operation of UAVs. Additionally, local processing of data ensures that UAVs’ services are uninterrupted, even in scenarios of poor network connectivity, thereby enhancing reliability [7]. However, integrating edge computing into UAV logistics introduces its own set of challenges. These include ensuring the security of devices, protecting the privacy of data, and complying with strict regulatory standards, especially in environments where security may already be a concern [8]. To successfully implement edge computing in UAV logistics operations, it is essential to establish strong privacy measures and secure protocols.

Federated learning (FL), as a privacy-preserving distributed learning framework, offers a promising approach that fits well within UAV logistics operations in edge computing environments [9]. This innovative method enables UAVs and ground stations to collaboratively train artificial intelligence (AI) models without the need to exchange sensitive data [10]. It addresses several challenges, such as breaking down data silos, reducing the risk of data breaches, and simplifying data management across different legal frameworks [11]. Moreover, FL significantly increases the self-sufficiency of UAVs by allowing AI models to adjust to local variations in the data, which in turn enhances operational efficiency. By utilising the computing power and storage capabilities of UAVs and edge devices, FL ensures ongoing improvement and adaptation of AI models to meet the dynamic demands of UAV logistics [12]. This not only secures data and complies with regulations, but also boosts computing efficiency and the accuracy of AI models.

1.2. Motivation and Contributions

In an edge computing environment, the rapid development of artificial intelligence Internet of Things (AIoT) systems has significantly advanced fields such as smart logistics. These industries are increasingly adopting unmanned aerial vehicles (UAVs) for efficient last-mile delivery solutions. As shown in Figure 1 [13], a typical edge-based UAV collaborative delivery system includes three stages. First is generating a collaborative delivery service plan. Second is formulating a service allocation plan. The last one is using UAVs for delivery. However, combining FL with UAV logistics systems presents a major challenge. This challenge is the issue of non-independent and identically distributed (Non-IID) data. The main reasons for this are as follows.

First, UAVs operate in different geographical areas and capture various environmental data. These geographical areas can significantly differ in terms of weather conditions, landscape features, and urban layout. Such diversity leads to Non-IID data, which complicate the training and effectiveness of AI models. These models are designed to optimise UAV routes and operations. For example, a UAV navigating in an urban area might collect data on high building density and complex airspace restrictions. Conversely, a UAV in a rural area might record data on wide-open spaces with minimal aerial obstructions. These variances require AI models to be not only highly adaptable, but also efficiently trained on various datasets. This training ensures consistent performance across diverse environments. Second, the data collected by UAVs show temporal variability. This means that the data captured at different times might vary significantly due to changes in traffic, weather, or operational challenges. Such variability impacts the accuracy of AI models when they are used over different periods. For example, UAVs used in logistics during rush hour or bad weather may experience delays and need to alter their flight paths. These deviations from normal operations are significant. To handle such fluctuations, AI models need to be powerful and capable of adjusting dynamically to maintain accurate forecasts and efficient operations. Third, traditional machine learning algorithms assume that both training data and future data are uniformly distributed. Non-IID data violate this assumption. As a result, models may not generalise well across different datasets or operating environments. Consider UAVs as an example. A model trained on data from a densely populated urban environment might perform poorly in a sparsely populated or rural environment, and vice versa. This challenge is particularly noticeable in edge computing environments. In such environments, computing resources and data storage are dispersed. Data are processed locally at each node. This can lead to differences in how models are trained and how they perform. Fourth, in systems like EXPRESS 2.0 [13], UAVs and unmanned ground vehicles (UGVs) collaborate on delivery missions. Non-IID data in these systems can cause inefficiencies in mission assignment, route optimisation, and coordination between air and ground units. These inefficiencies increase delivery times and energy consumption. Additionally, data mismatches between the air and ground units complicate the synchronisation of logistics operations. Differences in data collection points can affect not only individual performance, but also overall operational efficiency. For example, a UAV might choose the best route based on aerial observations. However, if an autonomous vehicle’s data suggest an alternative route due to ground obstacles like road construction, this discrepancy could lead to inconsistent route choices. As a result, delivery times lengthen and fuel or energy usage increases.

To address the above-mentioned issues, we propose a novel FL framework for UAV logistics operations that adopts a cloud–edge–end collaborative model called Fed4UL. This framework significantly boosts the UAV logistics networks’ ability to leverage distributed computing for efficient data processing and storage, enhancing response times. Incorporating FL allows for local model updates on edge servers, reducing the computational burden on central servers and improving system scalability. To address the Non-IID challenge in UAV logistics systems, we employed the K-means method on trusted edge servers to categorise the data distribution from each UAV into distinct clusters. Subsequently, on the cloud server, we adapted the parameters of the local cluster models to the aggregated global model, based on the similarity in the data distribution of each upload. The experimental results demonstrated the effectiveness of our Fed4UL framework in mitigating the Non-IID data issue. The key contributions of this paper are outlined as follows:

• We propose a novel FL framework for UAVs’ logistics operations called Fed4UL. Fed4UL is designed based on a cloud–edge–end collaboration architecture and aims to protect the privacy of UAV logistics operations while reducing the negative impact of Non-IID data on the UAV logistics operations.
• We integrated the K-means method into the client training phase to capture the complex relationships and dependencies within the data. This approach not only enhances FL by mitigating the effects of Non-IID data, but also improves the performance and generalisation ability of local models, while reducing the communication costs.
• We measured the cosine similarity between each local cluster model and adaptively selected a threshold for global model aggregation. This aims to enhance the global model’s consistency, accommodate data diversity, minimise the risk of incorrect aggregation, and improve its generalisation ability.
• To demonstrate the efficacy of Fed4UL, we conducted extensive experimental evaluations using two heterogeneous public datasets. The results highlighted Fed4UL’s superiority over the selected FL baselines, particularly in terms of global convergence performance.

The rest of this paper is organised as follows. In Section 2, we review the related works on the edge computing-empowered UAVs and the Non-IID data problem. Section 3 describes the basic knowledge used in this paper. We propose an FL UAV logistics framework in Section 4. We analyse the effectiveness of our proposed algorithm in Section 5. Finally, we conclude the paper in Section 6.

2. Related Work

2.1. Edge Computing-Empowered UAVs

Yao et al. [14] introduced A2DSEC, a security framework designed to boost the security of edge computing-based unmanned aerial vehicle (UAV) logistics systems. It combines user authentication, anomaly detection, and active defence strategies, significantly enhancing security. However, the framework’s reliance on blockchain technology could lead to challenges, including increased latency and greater resource demands, during its implementation and operation.

Qu et al. [15] introduced a method to deploy services using unmanned aerial vehicles (UAVs) in mobile edge computing, featuring two simplified optimisation strategies. The first, designed for complex situations, uses the branch and bound (BnB) method and continuous convex approximation (SCA) for iterative solutions. The second approach addresses the issue more straightforwardly, applying relaxation and random rounding to approximate solutions for deploying services and scheduling tasks. However, the first method’s complexity may not fit real-time uses, and the second may reduce optimisation effectiveness. Additionally, the model’s limitations, including fixed UAV heights and indivisible tasks among UAVs, restrict its practical utility.

Callegaro and Levorato [7] developed a framework to boost the self-operating abilities of unmanned aerial vehicles (UAVs) supported by infrastructure, using edge computing for optimisation. This approach tackles the challenge of limited resources on UAVs by treating it as an optimal stopping time issue within a semi-Markov process. It combines dynamic programming and deep reinforcement learning, adaptable to different system complexities and the system’s unpredictable behaviours. Although this method enhances UAVs autonomy by utilising advanced learning and programming techniques, it might require more computing power and increase processing time, especially when quick adjustments to environmental shifts are essential. Moreover, while it considers changes in network conditions and server loads, further research is needed to strengthen its performance under tough or changing conditions, such as communication problems during extreme weather.

Zhang and Ansari [16] proposed a simplified UAV-supported mobile edge computing (MEC) system for Internet of Things devices (IoTDs), where UAVs serve a dual role as providers and relay points. This setup allows IoTD tasks to be processed in multiple ways: directly by UAVs, through mobile base stations (MBSs), via UAVs to MBSs, or independently by the IoTDs. The study offers a strategy to cut the operating costs by tackling the joint challenges of computation offloading, spectrum and computing resource allocation, and UAVs’ placement (Joint-CAP). This is achieved by dividing the problem into two simpler sub-problems, solved separately to reduce the IoTD service costs. However, the real-world applicability of this method may be limited by deployment complexities and the efficiency of the algorithm. While it aims to decrease operational costs, the algorithm’s complexity could limit its real-time use in IoT settings. Moreover, the architecture’s effectiveness largely depends on careful UAV deployment and management, posing additional challenges in changing or uncertain environments.

Deng et al. [17] developed a system that pairs unmanned aerial vehicles (UAVs) with mobile edge computing (MEC) to support real-time artificial intelligence (AI) applications. This system uses an air–ground network to enhance deep neural network (DNN) decision-making, efficiently manage resources, and guide UAVs to minimise delays, ensure accuracy, and control energy use. It employs fixed-wing UAVs as servers for Internet of Things (IoT) devices, examining how different DNN models impact service speed, energy, and precision. The system’s reliance on accurate location data and its sensitivity to environmental changes pose challenges, as does the complexity of optimising UAVs’ routes and resource allocation. Iterative optimisation algorithms are proposed to address these issues, but their complexity could limit real-time IoT usage. Additionally, selecting models, allocating resources, and considering network conditions, the mission objectives, and UAVs’ positioning complicate decisions in ever-changing settings.

2.2. Solution to Solve the Non-IID Data Issue in FL

Li et al. [18] suggested a method called hard feature matching data synthesis (HFMDS) to address the uneven data distribution across devices by creating synthetic data for sharing. However, this method could encounter issues like high computational demands, potential privacy breaches, and ensuring the quality of the synthetic data.

Qiao et al. [19] introduced FedALC, an FL framework designed to address issues with Non-IID data. Key strategies include adversarial training (AT) to make models more resistant to attacks by training them with challenging data on local devices and logic calibration to balance class representation by giving more weight to less-represented categories. However, adversarial training might increase the need for computing resources, and improving robustness could slightly reduce accuracy.

Arafeh et al. [20] suggested a new approach to address the Non-IID data challenge, focusing on two main strategies. Firstly, there is a preliminary selector where clients train local models and send them to the server. The server then uses these models to identify compatible clients for creating an initial global model. Secondly, to manage the complexity of selecting clients, a genetic algorithm is introduced to find near-optimal solutions efficiently, using limited time and resources. While this method aims to reduce the time needed, selecting compatible clients still demands significant computational effort. Moreover, the success of the genetic algorithm partly depends on assumptions about the client data distribution, which might not always hold true in real-world scenarios.

Jeong et al. [21] introduced a method for indoor positioning using FL to address issues with a non-uniform data distribution. The approach includes adding a penalisation layer to improve performance, introducing model reliability and weight change tracking, and using Bayesian data fusion for better clustering in the FL’s indoor positioning. These strategies, however, might increase computational demands and communication needs, particularly with extensive data. Also, customising models for specific data patterns may need extra adjustments.

Wu et al. [22] introduced FedNP, a new FL method, to address the Non-IID data challenges. This Bayesian-based algorithm improves global data understanding by adding local tasks, making two key contributions: it estimates the global data distribution to better train local models, and it is fully differentiable, working well with existing FL systems without needing sampling. However, FedNP has not been tested in unsupervised learning scenarios yet. While it promotes collaborative modelling across data centres, it might increase privacy risks, highlighting the need for better privacy safeguards.

3. Preliminaries

In this section, we will present some preliminaries associated with Fed4UL. These include FL, clustering, and cosine similarity.

3.1. Federated Learning

Federated learning (FL) represents an innovative approach to distributed machine learning, addressing several privacy and data concentration challenges inherent to traditional machine learning methodologies. Instead of aggregating data from various sources into a central server for model training, FL decentralises the process by bringing the model to the data. This approach allows the model to learn from dispersed data sources without necessitating the relocation of the data from their original site. The main running steps of FL are as follows: (1) Initialise the global model ${\omega }_0^g$, and send it to selected clients $S_t$ participating in the training process. (2) Each participating client in $S_t$ trains the model on its local data $D_k$. This training updates the model parameters based on the data available on the device, without the data leaving the device. This process can be expressed as:

$${\omega }_{t+1}^k={\omega }_t^k-\eta \nabla F_k\left({\omega }_t^k\right),$$

(1)

where t represents the number of iterations, $\eta$ denotes the learning rate, and $\nabla F_k\left({\omega }_t^k\right)$ is the gradients of the local training objective with respect to the parameters of client model k. (3) After training on the local data, each device sends its local model ${\omega }_{t+1}^k$ (not the raw data) to a central server. (4) The server aggregates these updates to generate the new global model ${\omega }_{t+1}^g$. The updated global model ${\omega }_{t+1}^g$ is sent back to the selected clients $S_t$ for the next round of local training. This process is repeated until the model converges or a preset number of training epochs is reached. This aggregation might use techniques like the Federated Averaging (FedAvg) algorithm. FedAvg is a commonly used aggregation method in FL, which can be expressed as:

$${\omega }_{t+1}^g=\sum _{k\in S_t}\frac{n_k}{N}{\omega }_{t+1}^k,$$

(2)

where ${\omega }_{t+1}^g$ denotes the updated global model in the $t^{th}$ communication round, $N={\sum }_{k\in S_t}{n}_k$ is the total number of training samples in all selected clients, and $n_k$ represents the number of training samples at client k.

3.2. Clustering

Clustering is an unsupervised learning method. It is primarily used to group data points into several clusters. This grouping allows data points with similar characteristics to be together [23]. The method aims to maximise similarity within clusters and minimise it between different clusters. Clustering is used widely in fields such as data mining, statistical analysis, pattern recognition, image analysis, and social network analysis [24]. Clustering algorithms can be categorised by different criteria and methods. Here are some common clustering methods:

• Partition-based clustering method [25]: This method first specifies the number of clusters. It then assigns data points to these clusters. The goal is to minimise differences within clusters and maximise differences between them. Typical algorithms include K-means and K-medoids.
• Hierarchical-based clustering methods [26]: This approach creates a cluster hierarchy. It achieves this by successively merging or splitting existing clusters. Hierarchical clustering algorithms are of two types. Cohesive hierarchical clustering involves bottom-up merging. Divisive hierarchical clustering involves top-down splitting.
• Density-based clustering method [27]: This method clusters based on the density distribution of data points. It groups density-connected data points into the same cluster. This method can identify clusters of arbitrary shapes. It also handles noisy data to a certain extent. Typical algorithms include DBSCAN and OPTICS.
• Model-based clustering method [28]: These methods assume the data are generated from multiple distributions. Each distribution corresponds to a cluster. Gaussian mixture models (GMMs) and expectation maximisation (EM) algorithms are common. They optimise the model parameters to fit the data.

This paper primarily discusses the application of the K-means method to non-independent and identically distributed (Non-IID) data. For Non-IID data, where the data points are dependent on each other and do not follow the same distribution, K-means clustering still offers unique advantages. First, K-means clustering can create more uniform datasets by grouping similar data together. This method balances the data distribution across different participating nodes, making the data on each node more similar, thereby reducing the negative impact of Non-IID data. Second, in federated learning, Non-IID data may lead to overfitting or underfitting of the model on certain nodes. By preprocessing the data using K-means clustering, the model’s generalisation ability across nodes can be improved, making the training process more stable. Third, Non-IID data can slow down the convergence speed of federated learning. K-means clustering optimises the data distribution, reducing differences between nodes, thus accelerating the convergence speed of the global model and improving training efficiency. Fourth, in federated learning, each node needs to continuously communicate with the central server. K-means clustering can reduce the amount of data that need to be transmitted since similar data have already been grouped together, thereby reducing communication overhead and improving system efficiency. Finally, one major advantage of federated learning is data privacy protection. K-means clustering can further enhance data privacy protection by performing federated learning after clustering the data, as the transmitted data are more centralised and targeted, reducing the risk of data leakage. In contrast, other clustering algorithms such as hierarchical clustering [29] and DBSCAN [30] are not suitable for processing large-scale high-dimensional data. This is due to their high computational cost, poor scalability, and complex parameter adjustment. These factors may add additional complexity and computational overhead. Furthermore, they do not significantly improve the clustering quality.

K-Means Clustering

K-means clustering is a popular unsupervised machine learning algorithm used for partitioning a dataset into a set of non-overlapping subgroups, or clusters, where each data point belongs to the cluster with the nearest mean [31]. The goal of the algorithm is to find groups in the data, with the number of groups represented by the variable K. Set up a dataset $D=\{x_1,x_2,x_3,\dots ,x_n\}$. The data are divided into m clusters $C=\{C_1,C_2,C_3,\dots ,C_m\}$. The minimum optimisation objective of K-means clustering can be expressed as:

$$J({\mu }_1,{\mu }_2,...,{\mu }_m)=\sum _{j=1}^m\sum _{x_i\in C_j}\left|\right|x_i-{\mu }_j{\left|\right|}^2.$$

(3)

where $\left|\right|·\left|\right|$ represents the Euclidean distance between two data points. ${\mu }_j$ denotes the centroid of the cluster $C_j$, which is the average position of all points in the cluster.

3.3. Similarity Measurement

Cosine similarity is a measurement method commonly used to measure the similarity in direction of two non-zero vectors. It calculates the cosine value of the angle between the two vectors in n-dimensional space [32]. A cosine value of 1 means that the two vectors are in exactly the same direction; a cosine value of 0 means that the two vectors are orthogonal and their directions are completely uncorrelated; a cosine value of $-1$ means that the two vectors are in completely opposite directions. The goal of cosine similarity can be expressed as follows:

$$cos\left(\theta \right)=\frac{\mathbf{A}·\mathbf{B}}{\parallel \mathbf{A}\parallel \parallel \mathbf{B}\parallel }=\frac{{\sum }_{j=1}^n{A}_j{B}_j}{\sqrt{{\sum }_{j=1}^n{A}_j^2}\sqrt{{\sum }_{j=1}^n{B}_j^2}}.$$

(4)

where A and B denote two nonzero vectors. $·$ represents the dot product of the vectors. $A_j$ and $B_j$ are the values of vectors A and B, respectively, in the $i^{th}$ dimension.

The scenario of this paper is mainly about the last-mile logistics of UAV logistics operations. In the last mile of UAV logistics operations, the recipient needs to be located, which requires image recognition and classification. When processing image data, cosine similarity can be used to measure the similarity between image feature vectors for image recognition and classification tasks. This is particularly important in edge computing applications, as images can be processed on the fly where the data are generated, reducing data transfers and increasing response times. Our work uses an adaptive threshold to adjust the cosine similarity criterion. This adjustment enhances the robustness and performance of the global model. It also meets personalised needs and simplifies the aggregation process. This method has significant application value in federated learning systems. It helps build more efficient models.

4. Fed4UL Framework

Fed4UL is a cloud–edge–end collaborative framework for FL in UAV logistics operations, specifically designed to protect each participant’s privacy. However, the diversity in participants’ equipment leads to variability in the data, known as the non-independently and identically distributed (Non-IID) data problem. To counteract this issue, Fed4UL utilises K-means clustering and cosine similarity, techniques aimed at reducing the Non-IID data problem’s effect on the efficiency of last-mile deliveries by UAVs. Structurally, the framework is organised into three main tiers, the cloud tier, edge tier, and end tier.

Cloud tier: In our framework, we utilised the powerful computing capabilities of the cloud computing centre to centrally plan and schedule large-scale logistics tasks. These tasks include UAVs’ route planning, cargo distribution, and time arrangement, all aimed at ensuring the optimal operation of the entire logistics network. On the other hand, we conducted big data analysis in the cloud to predict the demand trends based on historical data. This allowed us to adjust the logistics resource allocation and optimise the UAVs routes and distribution plans.

Edge tier: In the Fed4UL framework, we use edge computing servers (such as UAVs’ control towers and ground sites) to control UAVs in real time. This includes managing takeoff, navigation, obstacle avoidance, landing, and other operations to ensure rapid response and safe flight. On the other hand, we preprocess the data collected from UAVs (such as images and sensor data) at edge nodes through preliminary analysis and compression to reduce the burden on the cloud.

End tier: In real life, the data-processing capabilities of most UAVs are insufficient. Even though some advanced UAVs can perform limited data processing, this consumes significant power. Not only does this substantially reduce the UAVs’ endurance, but it also necessitates high costs for acquiring such UAVs. Therefore, in our framework, we assumed that our UAVs do not undertake extensive data processing or model training. By leveraging edge computing capabilities, the UAVs can autonomously make decisions for tasks like temporary obstacle avoidance and selecting emergency landing sites. This maintains operational security and continuity even in communications-restricted environments. On the other hand, the UAVs sense the surrounding environment in real time through the sensors they carry, registering factors like weather conditions, obstacles, and other aircraft. They then send these data to the nearest edge node for real-time processing to adjust the route or take other countermeasures.

Figure 2 presents the entire process of Fed4UL, and the corresponding pseudo-code is provided in Algorithm 1. Lines 1–3 describe the global model initialisation. Lines 4–8 cover the data collection and local training on edge devices. Lines 15–18 detail the global model aggregation with the cosine similarity. Lines 20–25 discuss the global deployment and prediction.

Algorithm 1 Fed4UL framework.

Input: Set of end devices ${\left\{E_k\right\}}_{k=1}^K$ with their datasets ${\left\{D_{k,j}\right\}}_{j=1}^{s_k}$, trusted edge devices ${\left\{E_k\right\}}_{k=1}^K$, global communication rounds T; Output: Updated global model ${\omega }^g$;   /* Model distribution */ 1: Cloud server initialises the global model ${\omega }_0^g$ 2: for each communication round t from $t=1$ to $t=T$ do 3:  Distribute ${\omega }_0^g$ to each trusted edge server $E_k$  /* Data collection and local training on edge devices */ 4:  for each trusted edge device $E_k$ do 5:   Collect data $D_k={\left\{D_{k,j}\right\}}_{j=1}^{s_k}$ from connected $s_k$ end devices 6:   /* data clustering */ 7:   Implement the K-means clustering over $D_k$ by Equation (5) 8:   Obtain $m_k$ clusters represented by $D_k={\left\{C_{k,j}\right\}}_{j=1}^{m_k}$ 9:   /* local model training */ 10:   for each cluster dataset $C_{k,j}$ from $j=1$ to $m_k$ in parallel do 11:    Train the local model ${\omega }_{t,j}^k$ on $C_{k,j}$ by Equation (6) 12:   end for 13:   Upload the updated local models ${\{{\omega }_{t+1,j}^k\}}_{j=1}^{m_k}$ to the cloud server 14:  end for  /* Model aggregation */ 15:  Compute the similarity matrix S among all local models by Equation (7) 16:  Select the appropriate local models by Equations (8) and (9) for the final model aggregation 17:  Aggregate selected local models to update the global model ${\omega }_{t+1}^g$ according to Equation (2) 18:  end for 19:  /* Deployment and prediction */ 20:  Distribute the updated global model ${\omega }^g$ back to trusted edge devices $\{E_1,E_2,...,E_K\}$ 21:  for each trusted edge device $E_k$ from $k=1$ to $k=K$ do 22:  Use ${\omega }^g$ for prediction tasks 23:  Send prediction results back to the end devices 24:  end for 25:  return  ${\omega }^g$

As shown in Figure 2, Fed4UL consists of seven steps: (1) The cloud server trains the initial global model based on public data, then distributes them to each trusted edge server. (2) The UAVs upload the data to the trusted edge server. (3) The trusted edge server starts clustering based on the different data distribution of the data uploaded by each UAV based on the K-means algorithm. (4) After clustering, train the local model, and then, upload it to the cloud server. (5) The cloud server selects an appropriate local model based on the cosine similarity to aggregate the global model, then issues the updated global model to each cluster. (6) Each cluster performs inference based on the global model, then sends the inference results to the UAVs. (7) The UAVs locate the person or location based on the inference results.

4.1. Model Distribution and Data Collection

At the beginning of each communication round between the cloud tier and the edge tier, the cloud server will broadcast the initialised or updated global model ${\omega }_t^g$ to each edge device in the edge tier. After receiving the new global model from the cloud server, the edge device needs to collect the data from the end devices in the end tier. Assume that there are K edge devices ${\left\{E_k\right\}}_{k=1}^K$ and each edge device controls the $s_k$ end devices ${\left\{E_{k,j}\right\}}_{j=1}^{s_k}$. So, for edge device $E_k$, it will collect the data from end devices ${\left\{E_k\right\}}_{k=1}^K$ forming its own private dataset $D_k={\left\{D_{k,j}\right\}}_{j=1}^{s_k}$.

4.2. Edge Clustering

Due to the data heterogeneity across end devices under each edge device, we propose to employ the K-means clustering algorithms to cluster the collected data samples in $D_k$. The purpose of data clustering is to classify the data samples with a similar data distribution into one cluster. According to Equation (3), we performed the data clustering within the edge device $E_k$ as expressed by

$$J({\mu }_{k,1},{\mu }_{k,2},...,{\mu }_{k,m_k})=\sum _{j=1}^{m_k}\sum _{x_i\in C_{k,j}}\left|\right|x_{k,i}-{\mu }_{k,j}{\left|\right|}^2,$$

(5)

where $m_k$ denotes the number of clusters on edge device $E_k$, ${\mu }_{k,j}$ represents the centroid of the jth cluster, and $C_{k,j}$ is the jth cluster set within $D_k$. After implementing the edge clustering on $D_k$, we can classify $D_k$ into the $m_k$ cluster set $C_{k,j}$ with diverse data distributions, denoted as $D_k={\left\{C_{k,j}\right\}}_{j=1}^{m_k}$.

4.2.1. Local Model Training

To mitigate the negative impact on the performance of the global model, we trained a separate local model ${\omega }_{t,j}^k$ over each cluster set $C_{k,j}$. In this case, each local model will be trained on IID data rather than Non-IID data. The specific model parameter update formula for ${\omega }_{k,j}^t$ over $C_{k,j}$ can be expressed as below:

$${\omega }_{t+1,j}^k={\omega }_{t,j}^k-{\eta }_{k,j}\nabla F_{k,j}\left({\omega }_{t,j}^k\right).$$

(6)

After finishing the local model training on the edge device $E_k$, we can obtain m local models ${\left\{{\omega }_{t+1,j}^k\right\}}_{j=1}^{m_k}$, which will be sent back to the cloud server.

4.2.2. Global Model Aggregation

In the tth communication round, the cloud server will collect the local models from the edge devices, denoted as $M={\left\{{\omega }_{k,j}^{t+1}\right\}}_{k\in (1,2,...,K),j\in (1,2,...,m_k)}$. To further ensure the robust aggregation for the new global model, based on Equation (4), we first computed the cosine similarity $S_{k,j}^{t+1}$ among any two local models, as follows:

$$S_{k,j}^{t+1}=\frac{{\omega }_{k_1,j_1}^{t+1}·{\omega }_{k_2,j_2}^{t+1}}{\parallel {\omega }_{k_1,j_1}^{t+1}\parallel \parallel {\omega }_{k_2,j_2}^{t+1}\parallel }.$$

(7)

Then, we can obtain the similarity matrix S with the size of $m\times m$ ($m={\sum }_{k=1}^K{m}_k$) for all local models.

To pick up the appropriate local models to take part in the final model aggregation, we designed a filter method according to the adaptive similarity threshold. Specifically, Since the similarity matrix S is symmetric and the diagonal elements represent self-similarity (which are always maximum for any similarity measure), we extracted the upper triangular elements of S, excluding the diagonal. This can be formally represented as:

$$U=\left\{S_{ij}\right|i<j\}.$$

(8)

The adaptive threshold $\tau$ is then calculated as the median of the upper triangular elements:

$$\tau =\mathrm{median}\left(U\right).$$

(9)

To decide which models are included in the aggregation process based on the adaptive threshold $\tau$, we followed the two steps below:

(1)

For each model i, if there is at least one j such that $s_{ij}\ge \tau$ ($i\ne j$), then model i is selected to participate in the aggregation.

(2)

If the similarity of no model exceeds the threshold $\tau$, all models are included in the aggregation process.

Finally, we selected the filtered selected local models to take part in the final model aggregation according to Equation (2) to update the global model ${\omega }_{t+1}^g$.

5. Evaluation

In this section, we will introduce the experimental settings, data, and experimental results in detail. We designed and implemented a series of experiments aimed at evaluating the effectiveness of our proposed algorithm Fed4UL in alleviating the problem of Non-IID data.

5.1. Implementation

Our proposed Fed4UL framework builds upon our previous work, Express 2.0 [13], which focused on UAV logistics operations. Express 2.0 is an advanced service management framework for Artificial Intelligence Internet of Things (AIoT) systems in edge computing environments. It extends the original Express platform by incorporating three key modules. The first module is smart service collaboration management, which facilitates collaboration between various IoT devices and services. It enhances their interaction by simplifying communication protocols and data exchange processes, thereby improving performance and efficiency in terms of response time and resource utilisation. The second module is artificial intelligence application management, which is responsible for supervising artificial intelligence applications. These applications include tasks such as real-time data analysis, predictive maintenance, and autonomous navigation. This module manages the entire life cycle of the AI model, including training, evaluation, partitioning, packaging, and deployment. It optimises AI operations by balancing the trade-off between inference runtime performance and model accuracy, ensuring AI applications run effectively in dynamic edge environments. The third module, data security management, ensures data security and privacy. It uses privacy protection technologies such as differential privacy and secure multi-party computation to securely manage data resources. This is an important feature of edge computing, where data processing occurs close to its source, making security and privacy critical. Figure 3 [13] shows a sample user interface for the Express 2.0 UAV delivery system demonstrating the integration and functionality of these modules.

All experiments were conducted on a server. This server was equipped with 8 Nvidia GeForce GTX 1080Ti GPUs and an Intel(R) Xeon(R) Gold 5120 CPU at 2.20GHz. Our model was built using Python [33] and PyTorch [34]. In the experiments, we used the CNN [35] and ResNet18 [36] structures. Although these models serve as standard benchmarks, they are not the primary focus of our research. Using these standard models allows for fair comparisons with other studies. Our work primarily examines the performance of federated learning methods across different datasets and models, particularly under Non-IID conditions. The focus is not on the specifics of any particular model. The training of the FL global model spans 50 rounds. The learning rate was set at 0.001.

5.2. Datasets

MNIST [37]: The MNIST dataset stands for the Modified National Institute of Standards and Technology database. It includes grayscale images of handwritten digits. The digits range from 0 to 9. Each image measures 28 × 28 pixels. The dataset is split into two parts. The training set contains 60,000 samples. The test set contains 10,000 samples. The MNIST dataset can be used for various tasks in UAV logistics, such as enabling UAVs to scan package labels at logistics centres and classify and distribute packages based on the numbers on the labels, similar to the handwritten digits in MNIST.

CIFAR-10 [38]: The CIFAR-10 dataset is officially named the Canadian Institute For Advanced Research Dataset. It includes 60,000 colour images, each 32 × 32 in resolution. These images are categorised into 10 groups. Each category has 6000 images. The categories are air planes, cars, birds, cats, deer, dogs, frogs, horses, boats, and trucks. CIFAR-10 is split into two sets. The training set contains 50,000 images. The test set contains 10,000 images. The CIFAR-10 dataset can be used for various tasks in UAV logistics, including target recognition and classification. The different categories in CIFAR-10 can simulate various types of parcels or goods. By employing image recognition and classification techniques, UAVs can identify and classify the types of parcels they are carrying or need to deliver. For instance, they can recognise and distinguish between electronics, food, clothing, and other items.

To demonstrate the effectiveness and authenticity of our proposed method, Fed4UL, we applied a Non-IID data distribution to these two datasets using the label distribution skew method [39]. Label distribution skew is a common problem in distributed learning and FL environments. It occurs when data are spread across multiple devices or locations. A bias happens when the distribution of data labels varies across different clients or nodes. As a result, some categories of samples might be too common or rare on certain nodes. Others might not appear at all. This imbalance can greatly affect model training and performance. This is particularly true in scenarios that require models to generalise well. Each client’s data, therefore, have a unique label distribution. To test our experiments’ effectiveness, we divided the MNIST and CIFAR-10 datasets among local clients into groups of 5, 10, and 20. We then grouped these into three clusters on the edge server. The local models were trained for 5 and 10 rounds, depending on the setup.

5.3. Baseline

We selected three widely used FL algorithms as our baseline: FedAvg, FedNova, and FedProx. The FedAvg algorithm, also known as Federated Averaging [40], operates under the FL framework. It trains models independently on multiple devices or nodes. Then, it sends the model parameters to a central server for averaging. After that, it distributes the updated model back to each node. FedNova, or Federated Normalised Averaging [41], standardises the model updates from each client. It performs a weighted average to address variations in the data distribution and system performance between clients. FedProx [42] addresses inconsistencies among participants. It introduces a regularisation term in the local update process. This term penalises deviations from the global model. As a result, it smooths the local updates and aligns them more closely with the global average.

5.4. Results and Analysis

Table 1. Average accuracy (%) of the global model across different local clients using ResNet18 and different algorithms on CIFAR-10 and MNIST datasets. The local model was trained 5 and 10 times. Results highlighted in bold represent the best performance.

Local Epochs	Algorithms	CIFAR-10			MNIST
		5 Clients	10 Clients	20 Clients	5 Clients	10 Clients	20 Clients
5	Fed4UL (Ours)	82.32	79.55	76.65	99.54	99.50	99.49
	FedAvg [40]	72.32	73.75	54.47	98.12	97.88	97.83
	FedNova [41]	65.01	61.84	54.43	97.27	96.71	96.19
	FedProx [42]	65.86	60.61	54.49	98.02	98.03	97.68
10	Fed4UL (Ours)	82.41	80.04	77.35	98.70	99.45	99.49
	FedAvg [40]	72.61	73.39	51.86	97.95	97.81	97.67
	FedNova [41]	65.68	57.27	53.88	98.02	95.78	91.92
	FedProx [42]	65.66	58.01	54.75	97.86	97.79	97.71

displays the average accuracy of the global model, which uses the ResNet18 neural network and four different FL algorithms (Fed4UL, FedAvg, FedNova, FedProx), on the CIFAR-10 and MNIST datasets. The results are shown for various numbers of local clients and different epochs of local training. From Table 1, we can see that the Fed4UL algorithm achieves the best performance in all settings, indicating its robustness against the Non-IID data. On the CIFAR-10 dataset, the accuracy of Fed4UL after five local training epochs was as follows: 82.32% for 5 clients, 79.55% for 10 clients, and 76.65% for 20 clients. After 10 training epochs, the accuracy improved to 82.41% for 5 clients, 80.04% for 10 clients, and 77.35% for 20 clients. It can be seen that, as the number of clients increases, the accuracy decreases, but the decrease is relatively small. On the MNIST dataset, Fed4UL showed higher accuracy; especially when using 20 clients, the accuracy exceeded 97% for both 5 and 10 training times, with the highest accuracy of 99.49% being reached for 10 training times. The performance of FedAvg on both datasets generally fell in the middle range. On the CIFAR-10 dataset, the accuracy significantly decreased as the number of clients increased, particularly with 20 clients, where it dropped to around 50%. Conversely, on the MNIST dataset, FedAvg performed much better, especially with five clients, achieving an accuracy of more than 98%. FedNova had the weakest performance on the CIFAR-10 dataset. When the number of clients increased, the accuracy dropped quickly, especially in the case of 20 clients. On the MNIST dataset, FedNova performed better. Although it was slightly inferior to other algorithms in the case of five clients, it maintained a high accuracy when more clients were used. The performance of FedProx on the CIFAR-10 dataset was similar to that of FedNova, with the accuracy rate dropping rapidly as the number of clients increased. On the MNIST dataset, FedProx performed stably across settings with varying numbers of clients. Notably, when using 20 clients, accuracy after 10 training sessions reached 97.71%, which was slightly higher than that of FedNova.

Table 2. Average accuracy (%) of the global model across different local clients using the CNN and different algorithms on the CIFAR-10 and MNIST datasets. The local model was trained 5 and 10 times. Results highlighted in bold represent the best performance.

Local Epochs	Algorithms	CIFAR-10			MNIST
		5 Clients	10 Clients	20 Clients	5 Clients	10 Clients	20 Clients
5	Fed4UL (Ours)	57.90	56.82	55.04	95.82	96.03	95.43
	FedAvg [40]	43.03	36.55	32.91	96.84	95.87	94.87
	FedNova [41]	43.12	36.97	32.56	96.28	95.73	42.95
	FedProx [42]	42.93	37.02	32.62	96.31	93.86	61.32
10	Fed4UL (Ours)	60.81	59.30	55.47	95.81	94.87	95.69
	FedAvg [40]	44.88	38.20	34.25	97.11	96.16	95.12
	FedNova [41]	44.60	38.29	33.18	96.45	95.96	61.49
	FedProx [42]	44.42	38.91	33.56	96.40	95.86	83.05

displays the average accuracy results for four FL algorithms: Fed4UL, FedAvg, FedNova, and FedProx. These results were obtained across different numbers of clients using CNNs for training. The training was conducted on the CIFAR-10 and MNIST datasets, with 5 and 10 local iterations, respectively. From Table 2, we see that, among all algorithms and settings, the Fed4UL algorithm consistently performed the best. This highlights its effectiveness in mitigating the impact of Non-IID data. On the CIFAR-10 dataset, accuracy gradually dropped as the number of clients increased, regardless of whether it was after 5 or 10 local training epochs. The accuracy dropped from 57.90% to 55.04%. Nonetheless, this downward trend was much gentler than that of the other algorithms. On the MNIST dataset, the performance of Fed4UL dropped slightly. This was especially noticeable in the setting of 20 clients. After five training epochs, the accuracy decreased from 96.03% to 95.43%. After 10 training epochs, it changed from 94.87% to 95.69%. FedAvg’s performance on CIFAR-10 was obviously not as good as Fed4UL’s. This was particularly evident at 20 clients, where the accuracy significantly dropped. It fell to 32.91% after 5 training sessions and to 34.25% after 10 training sessions. On the MNIST dataset, FedAvg demonstrated higher accuracy. However, there was still a visible drop at 20 clients. The performance of FedNova on CIFAR-10 was similar to that of FedAvg. This was especially noticeable in the case of 20 clients, where the accuracy dropped significantly. On the MNIST dataset, the performance remained relatively stable across 5 and 10 epochs of training. Even so, a significant drop occurred at 20 clients, particularly after 10 epochs of training. The accuracy fell from 95.96% to 61.49%. The performance of FedProx on CIFAR-10 was similar to the other two algorithms, FedAvg and FedNova. It showed a significant performance drop as the number of clients increased. On the MNIST dataset, FedProx achieved relatively high accuracy. Still, it experienced a drop in accuracy at 20 clients, especially after five training epochs. The accuracy fell from 96.31% to 61.32%.

In general, the Fed4UL algorithm showed excellent robustness and stability for Non-IID data under various test conditions. It proved adaptable in complex scenarios. While the other three algorithms maintained high accuracy on the simpler MNIST dataset, their accuracy decreased more rapidly on CIFAR-10 as the number of clients increased. This rapid decrease suggests they had limitations in handling complex, non-independent and identically distributed data. These results provide important insights into the application of FL in UAV-based logistics systems. They are particularly valuable when selecting an appropriate FL algorithm. This selection is crucial to ensure overall system performance and efficiency.

5.4.1. Effects of Different Network Architectures

From Figure 4, we observed that, under the ResNet18 architecture, Fed4UL exhibited very stable performance. It achieved the highest accuracy among all algorithms. Its convergence speed appeared to be faster, reaching a stable state after about 10 rounds of communication. This demonstrates that the Fed4UL algorithm can effectively leverage the characteristics of ResNet18 to achieve high accuracy and rapid convergence. Under the CNN architecture, Fed4UL continued to perform optimally. It quickly reached a high-accuracy stable state. Both its convergence speed and final accuracy surpassed those of the other three algorithms. This further highlights Fed4UL’s stability and efficiency. For FedAvg under the ResNet18 architecture, its accuracy fluctuated over time. The final accuracy was lower than that of Fed4UL, yet higher than those of FedNova and FedProx. Regarding convergence, the algorithm showed a trend toward stabilisation, although with significant volatility. This suggests it may require more communication rounds to stabilise in complex network structures. Under the CNN architecture, FedAvg’s accuracy was lower and more volatile. This suggests that simpler network structures may not offer the same stability as more complex ones. In the ResNet18 architecture, FedNova started with low accuracy. The accuracy fluctuated, but trended upward. However, it remained lower than that of both Fed4UL and FedAvg. This indicated potentially weaker convergence in complex model structures. FedNova’s performance under the CNN network mirrored its behaviour under ResNet18. Initially, the accuracy was low with significant fluctuations. Eventually, it reached a relatively stable state. However, this level of accuracy still fell short of what Fed4UL and FedAvg achieved. FedProx exhibited the lowest initial accuracy under ResNet18. Over time, it showed some improvements. However, its overall accuracy and convergence still lagged behind other algorithms. This may indicate limitations in handling complex network structures. Similarly, under the CNN architecture, FedProx recorded the lowest accuracy. It experienced a slow convergence speed and significant accuracy fluctuations. These observations suggest that FedProx might not be well suited for FL on simpler network structures.

Overall, Fed4UL demonstrated superior performance on both network structures. Its design proved more adaptable to different environments, providing stable and fast convergence. In comparison, FedAvg, FedNova, and FedProx experienced larger fluctuations. They also showed slower convergence speeds, especially on simpler CNN architectures.

5.4.2. Effects of Varying Local Epochs

From Figure 5, the left panel shows a gradual upward trend for Fed4UL. This signifies model improvement with increasing communication rounds. Despite accuracy fluctuations, the overall upward trajectory indicates enhanced convergence. On the right, Fed4UL’s accuracy appears relatively stable. It exhibits slight improvements in later rounds. This indicates that the algorithm maintained stability and achieved incremental improvement with an increased number of local training epochs. Across both figures, FedAvg’s performance shows significant variability. This is particularly noticeable with five local training iterations. It suggests potential convergence issues under unstable data distributions. FedAvg experienced fewer performance fluctuations with 10 local training iterations compared to Fed4UL. However, its overall performance still marginally lagged behind. FedNova maintained relative stability in both scenarios. Despite occasional drops in accuracy, it consistently showed a steady upward trend. With 10 local training iterations, FedNova demonstrated reduced accuracy fluctuations. This is indicative of robust stability and convergence. Conversely, FedProx displays relatively low accuracy in both graphs. It shows pronounced fluctuations, especially in scenarios with fie local training iterations. This may indicate poor convergence in such settings. When extended to 10 epochs of local training, FedProx achieved some improvement. However, this improvement was modest compared to the other algorithms.

Generally, with fewer local training epochs, all algorithms exhibited some degree of fluctuation. However, Fed4UL and FedNova demonstrated relatively greater stability. In contrast, FedAvg and FedProx experienced more significant performance variations. When the number of local training epochs increased to 10, the performance fluctuations for each algorithm diminished. Fed4UL, in particular, exhibited notable stability and a slight improvement in accuracy.

5.4.3. Effects of Varying Numbers of Clients

As seen in Figure 6a, the test accuracy of Fed4UL rapidly increased. It reached nearly 60% after the initial 10 communication rounds. The accuracy maintained this level, demonstrating excellent convergence and stability. In contrast, the FedAvg algorithm started with low accuracy. It increased slowly and exhibited significant fluctuations. These patterns suggest suboptimal convergence. The test accuracy of the FedNova algorithm started high. However, it showed minimal improvement as the communication rounds increased. The algorithm also experienced significant fluctuations, indicating average convergence. FedProx started with high accuracy, but had slow growth. As the communication rounds increased, the accuracy diminished. Additionally, the fluctuations became more pronounced, indicating poor convergence. Figure 6b shows that with fewer clients, the test accuracy of Fed4UL increased slowly at first. After 20 rounds, the increase became significant. By round 50, it approached the values seen in Figure 6a, indicating robust convergence. FedAvg exhibited high initial accuracy. However, its growth was slow and it experienced considerable fluctuations. This signals poor convergence with fewer clients. FedNova’s performance with 5 clients resembled its performance with 20 clients. It showed no significant improvement in test accuracy and continued to exhibit large fluctuations. With five clients, FedProx operated relatively smoothly. However, its test accuracy improvement did not match that of Fed4UL. Additionally, its convergence was comparatively weaker.

Overall, Fed4UL significantly outperformed the other three algorithms in terms of convergence. It showed rapid and stable accuracy improvements. When considering performance with 5 clients, all algorithms demonstrated less notable test accuracy improvements compared to their performance with 20 clients. Despite this, Fed4UL maintained good convergence after 50 communication rounds. In contrast, the other three algorithms, especially FedAvg and FedProx, showed slower improvements. They also experienced greater fluctuations across different numbers of clients. The decline in convergence was more pronounced when fewer clients were involved. This issue may be due to the increased impact of individual client data in smaller groups. Fed4UL potentially combats data imbalance more effectively. It utilises advanced aggregation and model selection strategies.

6. Conclusions

In this paper, we aimed to address the challenges of non-independently and identically distributed (Non-IID) data in UAV logistics. We introduced Fed4UL, an innovative FL framework. It employs clustering and similarity measurement to minimise the negative effects of Non-IID data. Our framework groups local clients on trusted edge servers. This not only mitigates the detrimental impact of Non-IID data, but also enhances local model performance and reduces communication overhead. We also incorporated an adaptive similarity measurement technique. This technique further reduces the influence of Non-IID data by curtailing ineffective updates and expediting model convergence. Our extensive experiments demonstrated that Fed4UL consistently outperformed established baseline algorithms in accuracy and the rate of convergence. However, the increased communication overheads of the Fed4UL framework require further optimisation. These improvements are essential to ensure robust performance in diverse and large-scale environments. In the future, we will focus on addressing these issues and explore the possibility of applying the Fed4UL framework to other fields.