Research on Computing Power Resources-Based Clustering Methods for Edge Computing Terminals

Abstract

In the “cloud–edge–end” three-tier architecture of edge computing, the cloud, edge layer, and end-device layer collaborate to enable efficient data processing and task allocation. Certain computation-intensive tasks are decomposed into subtasks at the edge layer and assigned to terminal devices for execution. However, existing research has primarily focused on resource scheduling, paying insufficient attention to the specific requirements of tasks for computing and storage resources, as well as to constructing terminal clusters tailored to the needs of different subtasks.This study proposes a multi-objective optimization-based cluster construction method to address this gap, aiming to form matched clusters for each subtask. First, this study integrates the computing and storage resources of nodes into a unified concept termed the computing power resources of terminal nodes. A computing power metric model is then designed to quantitatively evaluate the heterogeneous resources of terminals, deriving a comprehensive computing power value for each node to assess its capability. Building upon this model, this study introduces an improved NSGA-III (Non-dominated Sorting Genetic Algorithm III) clustering algorithm. This algorithm incorporates simulated annealing and adaptive genetic operations to generate the initial population and employs a differential mutation strategy in place of traditional methods, thereby enhancing optimization efficiency and solution diversity. The experimental results demonstrate that the proposed algorithm consistently outperformed the optimal baseline algorithm across most scenarios, achieving average improvements of $18.07\%$, $7.82\%$, $15.25\%$, and $10\%$ across the four optimization objectives, respectively. A comprehensive comparative analysis against multiple benchmark algorithms further confirms the marked competitiveness of the method in multi-objective optimization. This approach enables more efficient construction of terminal clusters adapted to subtask requirements, thereby validating its efficacy and superior performance.

1. Introduction

With the rapid development of the Internet of things (IOT), 5G/6G communications, edge computing, and other technologies, the deployment scale of IOT devices continues to expand, and the amount of data generated is reaching an unprecedented level [1]. This trend of data growth poses new challenges to traditional cloud computing architectures. Although the central cloud computing model can provide substantial computing power and virtually unlimited storage resources, its limitations in latency-sensitive applications become non-negligible [2]. Additionally, the cost of data transmission and the energy required to operate cloud data centers are significant [3]. To cope with the above challenges, edge computing [4] has emerged as a distributed computing paradigm. By offloading computing tasks to the network edge infrastructure [5], system latency performance can be significantly optimized while relieving bandwidth pressure on the central network [6]. In addition, the distributed architecture improves privacy protection through localized data processing [7], better aligning with modern data regulatory requirements.

In edge computing scenarios, complex tasks are typically decomposed into parallel subtasks to enable efficient processing, as noted in [8]. The standard procedure involves terminal nodes initially offloading computational tasks to an edge server, which then decomposes them into multiple subtasks and redistributes these to terminal nodes for collaborative execution. To facilitate effective resource management and node collaboration, clustering mechanisms are widely employed. These mechanisms group nodes into clusters based on performance similarity [9], enabling nodes within each cluster to cooperate, share computing resources, and collectively complete assigned tasks [10,11]. This approach not only enhances computing resource utilization but also reduces individual node workload and shortens overall processing time.

However, existing studies predominantly assume terminal node homogeneity, whereas in reality these nodes exhibit heterogeneous computational capabilities [12,13]. Although improved meta-heuristic algorithms have been extensively applied to optimize task allocation [14,15], most focus primarily on minimizing completion time, cost, and delay. Despite this, these optimization algorithms have demonstrated effective optimization towards these objectives, significantly reducing task completion time, cost, and delay. they frequently overlook the heterogeneous computing resources required by different tasks. Although some research [16] has considered task-level resource heterogeneity, it often neglects the computational heterogeneity of the executing nodes themselves.

Therefore, to bridge the research gap mentioned above, this paper focuses on heterogeneous terminal nodes and tasks with heterogeneous demands. The main contributions of this paper are as follows:

• Aiming at the heterogeneity of terminal nodes in the edge computing environment, this paper proposes and constructs a computing power resources metric model. Normalized and unified indicators of the node’s computing power resources from the dimensions of computing resources and storage resources are used to comprehensively assess the computing power resources of nodes. Through the systematic quantification of nodes’ multi- dimensional resources characteristics, the capacity differences between different nodes in terms of overall computing power resources are accurately portrayed. This facilitates the clustering of nodes with similar computational resource profiles.
• Secondly, this paper proposes an improved algorithm based on NSGA-III (H-NSGAIII-DE). During the initialization phase, simulated annealing and adaptive genetic operations are integrated to generate an initial population with superior distribution and higher quality. During the evolutionary process, a differential mutation mechanism is introduced to effectively enhance the algorithm’s global exploration capability and convergence speed.
• Finally, the effectiveness and advantages of the proposed algorithm are verified through comparative experiments.The proposed method demonstrates comprehensive performance improvements across all optimization objectives. Specifically, it achieves an 18.07% reduction in task–resource matching deviation (average matching deviation), a 7.82% decrease in computing resources heterogeneity (average computing power resources dispersion) within clusters, a 15.25% reduction in cluster size, and a 10% decrease in server–terminals communication overhead (average distance). These results effectively validate that the proposed method constructs terminal clusters with significantly optimized configurations for task execution.

The remainder of this paper is organized as follows. The Section Related Works describes related works. The Section System Model presents the system model employed in this study. The Section Optimization Objectives and Problem Description defines the optimization objectives required for selecting the optimal clustering strategy and clarifies the problem statement of this study. The Section Improved NSGA-III Algorithm presents the algorithm used in this study. The Section Results and Discussion demonstrates the experiments and results. Finally, the Section Conclusion and Future Work concludes the paper and discusses potential directions for future research.

2. Related Works

Some studies such as task offloading and task allocation will be based on two predefined clustering models. One is assuming that the nodes are already clustered [17,18] and the other is to cluster only according to the physical distance between nodes or network topology [19,20]. In fact, the formation of clusters often involves more complex factors.

Asensio et al. [21] solves the problem of efficient device clustering in hybrid fog–cloud computing scenarios, where the authors propose a multi-objective optimization model based on mixed-integer linear programming (MILP) and derive upper and lower bounds on the number of clusters; and a heuristic algorithm combining k-means and constrained optimization is designed for the scalability problem of large-scale scenarios. However, there are still limitations in the calculation efficiency and the integration of technical and economic models in the super large-scale scenario. Chen et al. [22] uses the Leuven algorithm to cluster end-to-end devices (D2D), and the authors add a resource constraint factor to this method to regulate the size of each cluster. By calculating the modularity gain of D2D devices within a cluster, the cluster with the largest gain is selected as the final clustering scheme. Amer and Sorour [23] investigate the problem of forming clusters of extreme edge nodes to perform different subtasks at minimum cost. The authors used the result of multiplying the price of the amount of data per bit of execution and the amount of data for the subtasks as the cluster cost for forming clusters, and with the optimization objective of minimizing the cluster cost, the problem was transformed into a mixed-integer quadratic constraint programming problem, and parsing was deduced through KKT conditions and Lagrangian analysis in order to find the cluster solution with the lowest cost. The method achieves the purpose of building computing clusters for subtasks, but it does not take into account the heterogeneity of computing resources required by different subtasks. Dankolo et al. [24] proposed a hybrid FPA-TS algorithm that optimizes task scheduling in the edge–cloud continuum. However, their model operates at a coarse granularity, focusing only on edge–cloud task placement without constructing terminal clusters for subtask-specific needs. It also overlooks node-level factors like resource balance and communication overhead, which are critical for sustainable cluster performance. Predić et al. [25] proposed a VMD and attention-RNN model for cloud load forecasting, optimized via improved PSO. While achieving accurate predictions, the method only considers cloud-level metrics, ignoring edge and terminal resources in cross-layer scenarios.

In the field of wireless sensor networks, clustering is more widely applied. Most of its study focus on how to optimize the selection of cluster heads in clusters. Sheeja  et al. [26], Younas and Naeem [27], and Joseph and Asaletha [28] formulated a multi-objective optimization problem targeting energy surplus, network lifetime, and average distance, which was solved using a heuristic algorithm to select an optimal set of cluster heads. Clusters were then formed by assigning nodes to the nearest cluster head. Jagadeesh and Muthulakshmi [29] employ a unified multi-objective fitness function for centralized energy-aware clustering and distributed selection of high-efficiency cluster heads. The Levy flight-enhanced multi-objective PSO algorithm substantially improves network energy efficiency and lifespan. But their clustering generally assumes that the network is isomorphic, ignoring the heterogeneity between different nodes, and the selection of nodes in the cluster according to some demand of the task is not considered in the clustering.

In summary, most of the above methods do not consider node heterogeneity during clustering and overlook the diverse computing power resource requirements of different subtasks when constructing clusters. To address these problems, this study assumes that the edge server decomposes tasks into multiple subtasks based on their computing power resources demands, dispatches these subtasks to the terminal network, and dynamically groups heterogeneous terminals into dedicated clusters, each responsible for executing subtasks with specific resource requirements.

3. System Model

3.1. Network Model

The network model of this paper is shown in Figure 1. This model consists of a central network, edge servers, base stations, and terminal nodes. The central network belongs to the cloud layer, the edge servers and the base stations belong to the edge layer, and the terminal nodes belongs to the end layer. In this model, a one-to-many mapping relationship exists between the core cloud and edge servers, and between edge servers and terminal nodes. Base stations are responsible for the allocation and management of wireless communication resources for terminal nodes. Terminal nodes access edge servers via base stations, while edge servers connect to the core cloud through high-bandwidth, low-latency wired links (such as optical fibers), thereby ensuring reliable and efficient access to central network services for all terminal devices.

Assume there are N heterogeneous terminal nodes in the network, each defined as $e_i=\{H_i,R_i,S_i\}$. $H_i$ represents the set of computational resource types of the node, including three categories: basic computing power, intelligent computing power, and neural computing power. $R_i$ denotes the amount of computing resources of the node across these resource types, and $S_i$ indicates its storage resources.

All these terminal nodes collectively form the terminal network $E=\{e_1,e_2,\dots ,e_N\}$. Given k subdivided subtasks, the terminal nodes are organized into k distinct clusters, with each cluster exclusively responsible for processing its corresponding specific subtask. The set of all node clusters corresponding to the subtasks collectively forms a cluster set: $V=\{v_1,v_2,\dots ,v_k\}$.

3.2. Task Model

In the task model of this study, the edge server first decomposes the original task into a set of k subtasks with computing resource type constraints, based on the task’s heterogeneous computing power resource requirements. Each subtask is uniformly defined as a tuple ${\psi }_i=\{h_i,r_i,s_i\}$, which includes multiple key parameters. $h_i$ denotes the specific type of computing resource required by the sub-task; $r_i$ represents the computing resource demand of the subtask for that resource type. For example, if the subtask demands intelligent computing power, its computing resource requirement may be expressed in terms of the number of floating-point operations (FLOPs) needed. $s_i$ indicates the storage resource requirements of the subtask. $r_i$ and $s_i$ are referred to as the computing power resource requirements of the subtask. After the task deconstruction and subtask definition, the edge server sends the partitioned subtasks to terminal nodes for execution through wireless links.

The task model is illustrated in Figure 2. The computing power resource requirements vary significantly across different subtasks, which forms the basis for adopting a heterogeneous task decomposition strategy.

The relationship between the physical configuration (Figure 1) and the task model (Figure 2) is defined by a core mechanism of task-driven, dynamic cluster provisioning. In this framework, the abstract “subtasks” in Figure 2 are not statically assigned to pre-defined clusters in Figure 1. Instead, they are dynamically scheduled and mapped to dedicated clusters, which are provisioned on-demand based on subtask attributes such as computation type and resource requirements. This dynamic “task-cluster” mapping forms the mathematical foundation of the optimization model in Section 4, where its precise formulation is central to determining the ultimate scheduling strategy.

3.3. Computing Power Resources Metric Model

Before constructing clusters for subtasks, a unified framework is established to measure the computing resources of heterogeneous terminal nodes, ensuring the comparability of multi-dimensional computing resources across different nodes. In traditional studies, computing power is usually attributed to the computing analysis capability of a hardware device processing unit or system software platform for business or data. However, this understanding is often confined to the performance metrics of individual devices or localized systems, which fails to fully capture the multi-dimensional characteristics of computing power in distributed and heterogeneous modern computing environments. Consequently, this study evaluates a node’s computing power capacity along two core dimensions—computing and storage resources.

In the dimension of computing resources, this study mainly considers the computing resources of three typical hardware types—CPU, GPU, and NPU—categorizing them into three computing resource types: basic computing power, intelligent computing power, and neural computing power. The storage resource dimension is comprehensively measured by four indicators: memory capacity, hard disc storage capacity, memory bandwidth, and hard disc read/write speed of the terminal nodes. These indicators are shown in

Table 1. Indicators of computing power resources.

Dimension	Indicator Name	Definition of Indicators	Hardware Type	Unit of Measurement
Computing	Basic computing power	Million instructions per second	CPU	MIPS
	Intelligent computing power	Tera Floating-Point Operations Per Second	GPU	TFLOPS
	Neural computing power	Tera Operations Per Second	NPU	TOPS
Storage	Storage Capacity	Maximum amount of digital data a Hard Drive can hold	Hard Drive	GB, TB
	Memory capacity	Random access memory (RAM) capacity	RAM	GB
	Memory bandwidth	The data transfer speed between the CPU and RAM	Memory	GB/s
	Hard Drive read/write speed	The rate at which data is read or written	Hard Drive	GB/s

.

The comprehensive computing power of a node, which represents its overall computing power capability, can be obtained by performing a weighted summation of its multi-dimensional computing resources as expressed in Equation (1).

$$U_i={\alpha }_1{R}_1+{\alpha }_2{R}_2+{\alpha }_3{R}_3+{\beta }_1{S}_1+{\beta }_2{S}_2+{\beta }_3{S}_3+{\beta }_4{S}_4$$

(1)

where $R_1$, $R_2$, and $R_3$ represent the computing resource components of a node, corresponding to the computing capacities of the CPU, GPU, and NPU—measured in MIPS, TFLOPS, and TOPS, respectively. Similarly, $S_1$, $S_2$, $S_3$, and $S_4$ denote the node’s storage resource components, corresponding to memory capacity, hard disk storage capacity, memory bandwidth, and hard disc read/write speed.

The coefficients ${\alpha }_1$ and ${\beta }_1$ are the weighting factors for the computing and storage resources, respectively. In this paper, the entropy weight method is adopted to determine these weights. This method assigns weights entirely based on the degree of data dispersion, without relying on subjective judgment. The rationality of the resulting weights therefore depends on the scientific soundness of the indicator system. By calculating the weights of nodes in different dimensions using the entropy weight method, the comprehensive computing power of each node can be obtained.

The weighting results of the entropy weight method depend on the degree of dispersion of the indicators, rendering them relatively sensitive to the distribution of the original data. To examine the robustness of the weights derived in this study, a systematic sensitivity analysis was conducted. Specifically, random perturbations of $\pm 5\%$, $\pm 10\%$, and $\pm 15\%$ were introduced into the original data to simulate data uncertainty, and the entropy weight method was recalculated on the generated series of perturbed datasets. Subsequently, the consistency in ranking between the perturbed weights and the original weights was assessed by calculating Spearman’s rank correlation coefficient. This coefficient serves as a key metric for evaluating weight stability, where a value closer to 1 indicates stronger robustness. The correlation coefficients for each indicator under different perturbation levels are presented in

Table 2. Analysis of sensitivity.

Perturbation Level	Basic Computing Power	Intelligent Computing Power	Neural Computing Power	Memory Capacity	Storage Capacity	Memory Bandwidth	Hard Drive Read/Write Speed
−15%	0.988	0.928	0.929	0.916	0.927	0.919	0.985
−10%	0.995	0.938	0.932	0.933	0.947	0.928	0.991
−5%	0.999	0.960	0.966	0.958	0.961	0.952	0.998
0%	1.000	1.000	1.000	1.000	1.000	1.000	1.000
+5%	0.997	0.956	0.989	0.960	0.953	0.955	0.970
+10%	0.992	0.936	0.980	0.938	0.912	0.919	0.965
+15%	0.990	0.914	0.968	0.919	0.904	0.906	0.961

.

The sensitivity analysis results (presented in Table 2) demonstrate that under data perturbations of up to $\pm 15\%$, all indicators maintain Spearman’s correlation coefficients above 0.9, while under $\pm 5\%$ perturbations, all coefficients remain above 0.95. This indicates that the relative importance ranking of the indicators is largely insensitive to data fluctuations, confirming the robustness of the entropy weight method in the context of this study.

In this study, we used the standard entropy weighting method to weight each index. For detailed calculation procedures, please refer to Appendix A. The comprehensive computing power corresponding to all nodes is denoted as $U_1,U_2,\dots ,U_N$.

4. Optimization Objectives and Problem Description

The target of this study is to select the most suitable cluster for a task by minimizing four key objectives: average matching deviation, average computing power resources dispersion, cluster size, and average distance. By optimizing these objectives, the study aims to enhance the compatibility between tasks and clusters; reduce resource waste and efficiency losses caused by mismatches between task requirements and node capabilities; simultaneously reduce computing power resource distribution disparities within the cluster to enhance overall resource utilization efficiency; minimize cluster size while meeting task processing requirements to reduce management costs and coordination overhead; and shorten average distance to lower data transmission latency and energy consumption.

4.1. Average Matching Deviation

Different subtasks require different computing resource types and computing resources. To compare the gap between the computing resource requirement of a subtask and the available resources in its corresponding cluster, both the resource requirement of the subtask and the relevant computing resources of the nodes within the cluster are normalized. The Min–Max normalization method is used to normalize the computing resources of the dedicated cluster and, similarly, the computing resource requirement of each subtask is normalized in Equation (2).

$$r_i^{Norm}={\displaystyle \frac{r_i}{\underset{j\in v_k}{max\left(R_j\right)}}}$$

(2)

$R_j$ is the maximum value of this computing resource provided by the node in the cluster, and the matching deviation of each subtask from its corresponding candidate cluster is calculated in Equation (3).

$${\delta }_i=\log \left(1+\left[\sum _{j=1}^n{R}_j-r_i^{Norm}\right]\right)$$

(3)

The total computing resources of the nodes within the cluster must be greater than or equal to the computing resource requirement of the subtask to guarantee that the task can be successfully scheduled to the nodes for execution, Therefore, the constraint is given by ${\sum }_{j=1}^n{R}_j\ge r_i^{\mathrm{Norm}}$. When the total computing resources within the cluster is closer to the task demand, the matching deviation is smaller. Assuming that there are k subtasks corresponding to k candidate clusters, the average matching deviation is calculated using Equation (4). The parameter $\rho$ is set to 2. A smaller deviation indicates a closer alignment between the current clustering scheme and the requirements of the subtasks.

$$\delta ={\left[{\displaystyle \frac{1}{k}}\sum _{i=1}^k{\left({\delta }_i\right)}^{\rho }\right]}^{{\displaystyle \frac{1}{\rho }}}$$

(4)

4.2. Average Computing Power Resources Dispersion

In the previous study, the computing power resources of terminal nodes were unified to eliminate the influence of magnitude, resulting in a comprehensive computing power metric to represent each node’s capability. To construct terminal clusters with balanced distribution of computing power resources, the variance of the comprehensive computing power of nodes within a cluster is used to evaluate the cluster’s computing power resources balance, that is, the degree of dispersion of its computing power resources. A larger variance indicates a more dispersed distribution of computing power resources among nodes after clustering, whereas a smaller variance reflects a more balanced allocation.

Assume that there are n nodes in each cluster. The dispersion of the computing power resources in each cluster is shown in Equation (5).

$${{\sigma }^2}_i={\displaystyle \frac{1}{n}}\sum _{i=1}^n{\left(U_i-\overline{U}\right)}^2$$

(5)

$\overline{U}$ denotes the average comprehensive computing power of each cluster. Similarly when there are multiple clusters, the average computing power resources dispersion $\epsilon$ is given by:

$$\epsilon ={\left[{\displaystyle \frac{1}{k}}{\sum _{i=1}^k\left({{\sigma }^2}_i\right)}^{\rho }\right]}^{{\displaystyle \frac{1}{\rho }}}$$

(6)

4.3. Cluster Size

In clustered collaborative computing architecture, cluster size is defined as the total number of nodes participating in the construction of the clusters. It is denoted by Equation (7).

$$N_{cluster}={\sum }_{i=1}^k\left(n_i\right).$$

(7)

where $n_i=\left|v_i\right|$ represent the number of nodes in the cluster i, and k is the number of clusters. A smaller $N_{clsuter}$ means fewer redundant nodes participating in the computation, which can effectively avoid resource idleness and waste. However, to ensure that all subtasks’ computing requirements are met, each cluster vi must contain at least one terminal node to execute its assigned subtask. This constraint can be expressed as $n_i\ge 1,\forall i\in \{1,2,\dots ,k\}$.

4.4. Average Distance

Under the “cloud–edge–end” collaborative computing framework, subtasks are precisely distributed to pre-selected terminal node clusters via edge servers using a distributed scheduling mechanism. This study introduces the average cluster–server distance as a key indicator to quantify the communication overhead of this distribution process. Specifically, let the coordinates of edge server s be $(x_s,y_s)$. The coordinates of any node within the cluster $v_i$ are $(x_i,y_i)$. The average Euclidean distance between the cluster and the server is defined as follows:

$$\overline{d}\left(v_i,s\right)={\displaystyle \frac{1}{\left|v_i\right|}}{\sum }_{n_i\in v_i}\sqrt{{\left(x_i-x_s\right)}^2+{\left(y_i-y_s\right)}^2}$$

(8)

$|v_i|$ denotes the total number of nodes in the cluster $v_i$. When there are k clusters, the average distance is shown in Equation (9).

$$\overline{d_{global}}={\displaystyle \frac{1}{k}}{\sum }_{i=1}^k\overline{d}\left(v_i,s\right)$$

(9)

4.5. Problem Description

Under the above system model and optimization objectives, the terminal nodes cluster problem is modeled as a multi-objective optimization problem to be solved by minimizing these four objectives. The optimization problem can be expressed in Equation (10).   

$$\left\{\begin{array}{c}min\left(\Delta ,\epsilon ,N_{cluster},d_{\mathrm{global}}\right)\hfill \\ \mathrm{s}.\mathrm{t}.\begin{array}{cc}{C}_1:{\displaystyle \sum _{j=1}^n}{R}_j\ge r_i^{\mathrm{Norm}},\hfill & \forall j\in n,\forall i\in k\hfill \\ C_2:{\displaystyle \sum _{j=1}^n}{S}_j\ge s_i,\hfill & \forall j\in n,\forall i\in k\hfill \\ C_3:\left|v_i\right|>0,\hfill & \forall i\in k\hfill \\ C_4:{\displaystyle \sum _{j=1}^n}\mathrm{II}(h_i\in H_j)\ge 1,\hfill & \forall j\in n,\forall i\in k\hfill \end{array}\hfill \end{array}\right.$$

(10)

In the above equation, n represents the number of nodes of cluster j. Constraint $C_1$ ensures that the nodes of a candidate cluster have sufficient computing resources to execute subtasks; $C_2$ ensures that the storage resources of the nodes in the cluster can meet the storage requirements of the subtasks; $C_3$ ensures non-empty clusters by constraining the minimum number of nodes per cluster; and $C_4$ ensures that at least one node within the cluster meets the computing resource-type requirement of the task.

To quantify the degree of violation of the above constraints, the constraint violation value [30] for each cluster is defined as follows:

$$\begin{array}{cc}\hfill C{V}_i=& max\left(0,r_i^{\mathrm{Norm}}-\sum _{j=1}^n{R}_j\right)\hfill \\ \hfill & +max\left(0,s_i-\sum _{j=1}^n{S}_j\right)\hfill \\ \hfill & +max\left(0,\xi ·(\varphi -|v_i\left|\right)\right)\hfill \\ \hfill & +max\left(0,\xi ·\left[\varphi -\sum _{j=1}^n\mathbf{1}(h_i\in H_j)\right]\right).\hfill \end{array}$$

(11)

In this formulation $\varphi$ is an extremely small value smaller than 1 and $\xi$ is an extremely large value. The total Constraint Violation ($CV$) of the clustering scheme is $CV={\sum }_{i=1}^{k}C{V}_i$, where $C{V}_i$ denotes the constraint violation degree of the cluster i. When $CV$ is 0, the current solution is a feasible solution. The goal of this paper is to find the optimal terminal clustering scheme in the feasible solutions. Currently, multi-objective evolutionary algorithms based on non-dominated solutions have become the mainstream algorithms for solving multi-objective optimization problems. Since this study involves more than three objective functions and the solution space of the problem is more complex, NSGA-III [31]—with its mechanism of uniformly distributed reference points—enables better distribution of non-dominated solutions in high-dimensional objective spaces and more effective exploration of the solution space. Accordingly, NSGA-III is selected as the baseline algorithm and is adaptively improved to address the clustering problem presented in this paper.

5. Improved NSGA-III Algorithm

NSGA-III, as the successor to the NSGA-II(Non-dominated Sorting Genetic Algorithms II) algorithm [32], is an improved algorithm proposed for Many-objective Optimization Problems. NSGA-III introduces the concept of reference points to replace the crowding distance in NSGA-II to guide the direction of solutions, maintain population diversity, and ensure that solutions are evenly distributed across the Pareto front. The specific steps are as follows:

Generate the initial population and reference points: Reference points are generated based on the problem, and $N_p$ individuals are randomly generated as the initial population to participate in subsequent iterations.

Crossover and mutation to generate offspring: The initial population $P_t$ is subjected to crossover and mutation to generate the offspring population $Q_t$, where the size of $Q_t$ equals that of $P_t$. The two populations are combined to obtain the new offspring population $R_t$.

Perform non-dominated sorting. Calculate the objective function values of the merged population $R_t$ and perform non-dominated sorting to establish a hierarchical non-dominated solution structure. During the population selection phase, all individuals in the first non-dominated layer ($F_1$) are prioritized for retention. Subsequently, use the reference point association strategy to select individuals with excellent distribution from the remaining frontier layers for supplementation until the predefined population size $N_p$ is reached. This forms the new parent population $P_{t+1}$.

Perform crossover and mutation operations on the new parent population $P_{t+1}$ to generate the new offspring population $Q_{t+1}$. Merge the two populations to form the new population $R_{t+1}$. Repeat the above steps until the specified number of iterations is reached.

However, the original NSGA-III algorithm tends to converge prematurely when handling terminal node clustering problems and generates a large number of solutions that do not meet the constraints in the early stages of iteration. Therefore, the improved H-NSGAIII-DE algorithm is proposed. The detailed steps of H-NSGAIII-DE are presented in the following subsections.

5.1. Population Encoding

Chromosomes are represented in various ways. For the problem addressed in this study, chromosomes are encoded using integer representation. Each chromosome characterizes a subtask-oriented clustering scheme for terminal nodes. It is defined as follows: the length of each chromosome equals the number of terminal nodes. The gene position in the chromosome, when $g_i=j$, indicates that terminal node i belongs to cluster $v_j$ which performs the subtask. A gene value of 0 indicates that the node does not participate in the current clustering task. j represents the cluster number to which the subtask is mapped, and the number of clusters varies according to the number of subtasks.

5.2. Generation of Initial Populations Based on the HSAGI Strategy

This study proposes a hybrid initialization method (Hybrid SA-GA Initialization, HSAGI) that incorporates simulated annealing and adaptive genetic manipulation, with the aim of generating high-quality and diverse initial populations for the NSGA-III algorithm. The specific process is as follows.

5.2.1. Construction of Candidate Solution Pool

First, an initial pool of candidate solutions is constructed for a given optimization problem by random generation. For each candidate solution, its objective function values and constraint violation degree are calculated for subsequent screening and evaluation. In the iteration, neighborhood solutions as well as cross individuals are generated, and the optimal initial population is selected through continuous iteration.

5.2.2. Iterative Optimization Dominated by Simulated Annealing

Simulated annealing is a global optimization algorithm. Its core depends on two major strategies: new solution generation and acceptance probability. The new solution generation mechanism defines the method of exploring neighborhood solutions from the current solution. To improve the efficiency of the algorithm and ensure the quality of the solution, this study adopts the principle of local search and designs the new solution generation strategy to perform random perturbations within the neighborhood of the current solution.

The disturbance operations swap, insert, shift, and reverse the genes of each candidate solution. Swap refers to randomly selecting two gene positions and exchanging their values; insert refers to randomly selecting a gene and inserting it into another random position; and shift refers to selecting a gene and shifting one position to the right from that gene. Reverse order is the reversal of the order of a segment of consecutive genes. The neighborhood solution generation operation is shown in Figure 3.

Another key strategy in SA is to use the Metropolis criterion to determine whether to accept a newly generated neighborhood solution. Considering that the solutions in this study are constrained, this study adopts the dominance relationship judgment mechanism in [33] to judge the dominance relationship between the neighborhood solution and the current solution. If the neighborhood solution dominates the current solution or both are non-dominant solutions, then accept it directly; otherwise, the Metropolis criterion is used to determine whether to accept the neighborhood solution. The core of the dominance relationship judgment is based on a binary solution comparison method based on CV and the Pareto dominance principle. The specific logic is as follows:

Feasibility Priority Principle: If both solutions are feasible ($CV=0$), the original Pareto dominance criterion is applied: namely, if solution 1 is not inferior to solution 2 in all objective values and is strictly superior in at least one objective, then solution 1 is considered to dominate solution 2.

Dominance mechanism: In the context of mixed-feasibility solution comparison, a feasible solution ($CV=0$) always dominates an infeasible solution ($CV>0$).

Comparison criterion for infeasible solutions: If both solutions are infeasible, the solution with a smaller constraint violation ($CV$) value is preferred. If their $CV$ values are equal, the Pareto dominance criterion is then applied for comparison.

When the neighborhood solution is dominated by the current solution, the Metropolis criterion is utilized to determine whether to accept the neighborhood solution. The neighborhood solution is accepted with a certain probability to avoid iteration getting stuck in a local optimum. The probability of accepting the neighborhood solution is given by the following equation.

$$P=exp\left(-{\displaystyle \frac{\Delta f}{\theta }}\right)$$

(12)

$\Delta f$ is the cost difference between the current candidate solution and its generated neighborhood solution: $\Delta f=f\left(\mathrm{new}\right)-f\left(\mathrm{old}\right)$. $f\left(new\right)$ is the generation value of the newly generated neighborhood solution, and $f\left(old\right)$ is the generation value of the current solution. Calculate the generation value using Equation (16). The probability of accepting the inferior solution is controlled by using the temperature parameter $\theta$, which is the current temperature, and is calculated as follows: $\theta =T_0·{\alpha }^{g-1}$. $T_0$ denotes the initial temperature, which takes the value of 150 °C, g denotes the current iteration number and $\alpha$ denotes the annealing coefficient, $\alpha =0.96$.

In order to generate more population individuals that meet the constraints as well as diversity, a crossover operation is introduced on top of the local search. The crossover operation here selects uniform crossover. Based on the number of feasible solutions of the initial candidate solution set individuals, the number of individuals whose initial candidate solution set accepts crossover is selected. The number of crossover individuals is shown in the following equation.

$$ncrossover=\left(0.5+0.2\left[1-pf\right]\right)·candidate$$

(13)

$pf$ represents the proportion of feasible solutions in the candidate pool. candidate is the number of candidate solutions. The newly generated neighborhood solutions, the offspring produced by crossover operations, and the original candidate solutions textcolorgreenare collectively merged into a new candidate solution pool for subsequent iterative optimization. for subsequent iterative optimization.The iterative cycle of simulated annealing and adaptive crossover operations enables the proposed algorithm to effectively promote global convergence while maintaining solution quality and diversity.

5.2.3. Initial Population Generation

Upon completion of the iterative process, all feasible solutions satisfying the constraints are first selected from the final-generation candidate solution pool. If the number of feasible solutions exceeds the initial population size, a subset of individuals equal to the initial population size is randomly chosen from them to form the initial population. If the number of feasible solutions is insufficient, infeasible solutions with smaller constraint violation ($CV$) values are selected from the candidate pool to supplement the population until the predefined initial population size is reached.

5.3. Uniform Crossover

Crossover operation is a key step in genetic algorithm. As illustrated in Figure 4, uniform crossover is chosen to perform the crossover operation on individuals in this study. Uniform crossover does not rely on a fixed crossover point; it independently determines from which parent individual each locus comes. For the gene i of the offspring $O1$, a random number between 0 and 1 is generated; if the generated random parameter is less than 0.5, the corresponding gene of the parent $P1$ is selected for inheritance, otherwise the gene from $P2$ is selected. Similarly, the crossover operation generates offspring $O2$, creating new individual combinations. This mechanism enhances population diversity and helps the algorithm escape local optima.

5.4. Differential Mutation

NSGA-III often uses two ways to generate mutated offspring in the mutation operation: polynomial mutation and simulated binary mutation. However, these two ways of mutation will produce offspring individuals with high similarity, and also have the problem of slow convergence speed. To address these problems, a differential mutation (DE) strategy is introduced to replace the original mutation operation. DE generates new individuals by calculating the vectorial differences between population individuals and scaling them by a scaling factor. However, since this paper employs integer encoding, the idea of Boolean differential mutation is used to cope with the lack of support for feasibility and integer constraints in the standard DE operator.

Given that the value range of each gene (dimension) is $\{0,1,\dots ,k\}$, then when there is only one subtask and the number of clusters is 1, the value space of each individual gene is only 0 and 1. The gene values do not need to be converted. When the number of clusters is greater than 1, the integer-valued genes are converted to 2-bit binary numbers. Four individuals are randomly selected from the population species noted as $x_i$, $x_{r1}$, $x_{r2}$, and $x_{r3}$. For the target individual $x_i$, its differential individual is generated by the following equation:

$$m{u}_i=F\ast \left[x_{r1}\oplus \left(x_{r2}\oplus x_{r3}\right)\right].$$

(14)

F is the scaling factor, which is regarded here as the probability of executing (14), denoting the heteroscedastic operation. ⊕ represents the XOR operation. The execution rule of ∗ is as follows: for each binary bit of each gene, generate a random number $rand$ between $(0,1)$; if $\mathit{rand}<F$, then execute Equation (14). The opposite is not executed. The mutated binary number is converted back to an integer to obtain the final mutated individual. After generating the mutated individual, for each of its genes decide whether to replace the target individual with the value of the mutated individual $m{u}_i$ based on the crossover probability $CR$.

$$q_{ij}=\left\{\begin{array}{c}m{u_i}_j,rand\left(0,1\right)\le CR\vee j=j_{rand}\hfill \\ x_{ij},otherwise\hfill \end{array}\right.$$

(15)

$q_{ij}$, $x_{ij}$, and $m{u}_{ij}$ represent the values of gene j of the variant individual $q_i$, the target individual $x_i$, and the differential individual $m{u}_i$, respectively. $j_{rand}$ denotes a random selection of genes to ensure that at least one gene is crossed over. The crossover probability $CR$ generally takes a value between $(0,1)$. The larger $CR$ is, the more frequent the gene replacement is. After the above operations, the $q_i$ is obtained.

5.5. Selection and Niche-Preservation in H-NSGAIII-DE

During the population selection phase, the crossover population generated by uniform crossover, the mutation population produced by differential mutation, and the original population are combined to form a new composite population $R_t$. Subsequently, the non-dominated sorting mechanism from reference [33] is applied to $R_t$ to construct a hierarchical structure of non-dominated solutions, thereby identifying multiple Pareto fronts. Subsequently, thereby identifying Pareto fronts with different priorities. Building upon this, the algorithm employs a reference point-based niche-preservation strategy for elite selection: First, the objective function values are normalized and a set of predefined reference points is generated to guide the population towards a desired distribution along the Pareto front. Next, individuals in the combined population $R_t$ are associated with these reference points. During the selection process, all individuals from the first non-dominated front ($F_1$) are prioritized for retention. If their number does not reach the predefined population size $N_p$, individuals with excellent distribution are subsequently selected from the lower non-dominated fronts based on their association with reference points and niche density, until the population size is filled, ultimately forming the new parent population $P_{t+1}$.

5.6. Selection of the Final Solution

The final clustering scheme is selected in the final set of solutions according to the following equation.

$$\mathrm{O}=\arg \min \left(\lambda ·\delta +\alpha ·\epsilon +\beta ·N_{cluster}+\mu ·\overline{d_{global}}\right).$$

(16)

where $\lambda +\alpha +\beta +\mu =1$ is the weight factor of each optimization objective. In summary, H-NSGAIII-DE is presented in Algorithm 1.

Algorithm 1 H-NSGAIII-DE algorithm

Input:  Set of terminal nodes $E=\{e_1,e_2,\dots ,e_N\}$, node comprehensive computing power vector $\{U_1,U_2,\dots ,U_N\}$, number of clusters k, set of subtasks $\Psi =\{{\psi }_1,{\psi }_2,\dots ,{\psi }_k\}$ Output:  Optimal clustering strategy 1: Initialization: 2: $P_0\leftarrow$ HSAGI_Initialization(N)    ▹Using hybrid SA-GA initialization strategy 3: $t\leftarrow 0$ 4: while$t\ne \mathrm{Maxit}$do 5:     Reproduction: 6:     $Q_t\leftarrow \varnothing$ 7:     for each individual in $P_t$ do 8:         Perform uniform crossover with probability $P_c$ 9:         Perform differential mutation (DE strategy) 10:         Evaluate offspring fitness using Equation (16) 11:         Add offspring to $Q_t$ 12:     end for 13:     Selection: 14:     $R_t\leftarrow P_t\cup Q_t$ 15:     Normalize objectives and generate reference points 16:     Associate solutions with reference points 17:     $P_{t+1}\leftarrow$ NSGA-III_Selection($R_t$, N)        ▹Niche-preserving operation 18:     $t\leftarrow t+1$ 19: end while 20: Apply Equation (16) to select Optimal clustering strategy

6. Results and Discussion

To validate the performance of the proposed algorithm, the method presented herein was compared with H-NSGAIII (initialized using the HSAGI strategy), NSGA-III-DE (employing differential mutation), the original NSGA-III, NSGAIII-S-CDAS [34], and NSGAIII-MSDR [35]. This section presents the results of the experimental evaluation and provides a comparative analysis of the outcomes.

6.1. Experimental Setup

The experiments in this paper were conducted using MATLAB 2018b, with the specific experimental parameters in the

Table 3. Experimental parameters.

Parameter	Value
Number of terminals/nodes (N)	300
Population size ($N_p$)	200
Number of iterations ($Maxit$)	250
Crossover probability ($p_c$)	0.9
Mutation probability ($p_m$)	0.1
Scaling factor (F)	0.9
Crossover probability ($CR$)	0.1
Area	500 × 500
Base station coordinates ($x_s$, $y_s$)	(250, 250)
Number of clusters/Number of subtasks k	1–3
Number of independent runs	15

.

6.2. The Relationship Between the Number of Nodes and Each Objective

6.2.1. The Relationship Between the Number of Nodes and Average Computing Power Resources Dispersion

Figure 5 illustrates the variation trend in average computing power resources dispersion under different numbers of nodes (N). Its subgraphs further show the specific relationships under varying numbers of clusters (k). The results indicate that the average computing power resources dispersion is negatively correlated with N, meaning that as the node scale increases, the dispersion degree of computing resources distribution shows a significant downward trend.

This phenomenon can be attributed to the resource pooling effect brought about by node scale expansion: when a large number of heterogeneous nodes are integrated into the terminal network, the proposed algorithm can achieve more optimized node selection within the expanded resource pool. By reconstructing the computing power allocation within clusters, it promotes a more uniform distribution of computing power resources at the cluster level, thereby effectively reducing the overall average computing power resources dispersion of the system. The proposed H-NSGAIII-DE algorithm outperforms most comparative algorithms across most node scales. Although its performance falls short of some comparative algorithms when nodes are fewer than 250, H-NSGAIII-DE achieves lower average computing power resources dispersion when nodes exceed 250. This demonstrates its stronger suitability for large-scale node scenarios and its ability to construct clusters with more balanced computing power resources distribution.

6.2.2. The Relationship Between the Number of Nodes and Cluster Size

Figure 6 reflects the impact of different node numbers on the cluster size, and the subgraphs distinguish the changes under different k. Within the figure, cluster size exhibits a positive correlation with the number of nodes. As the number of nodes increases, more redundant nodes are allocated within the cluster, consequently expanding its overall scale.

When $k=1$ and $N=150$, the cluster size of the proposed algorithm is slightly higher than that of NSGA-III-DE algorithm, indicating that there is some room for improvement. However, when k increases to two and three, the proposed algorithm demonstrates a marked advantage in cluster size control, with values significantly lower than the comparative algorithms. This result indicates that in scenarios with large node scales, the proposed method can more effectively reduce the number of redundant nodes. Consequently, it achieves a more compact cluster structure while maintaining system performance and improving resource utilization efficiency.

6.2.3. The Relationship Between the Number of Nodes and Average Matching Deviation

Figure 7 illustrates the relationship between terminal node scale and the system’s average matching deviation, with subgraphs providing detailed comparisons under different k. As the number of nodes increases, the expansion of cluster size and the enhancement of total computing power resources lead to a corresponding rise in the matching deviation between resources and task requirements, resulting in decreased resource utilization efficiency and computing redundancy.

When $k=3$, the average matching deviation increases most significantly across all algorithms. For $k=2$, with $N=100$ and $N=150$, the average matching deviation of the proposed algorithm is marginally higher than that of NSGA-II and NSGAIII-S-CDAS, indicating potential for further improvement in resource utilization efficiency under these specific scenarios. However, in the majority of other cases, the proposed algorithm demonstrated optimal resource conservation characteristics. Its average matching deviation exhibited the smallest increase with a growing number of nodes and also recorded the lowest absolute value, effectively curbing computing power waste. The results confirm that the proposed method can significantly reduce redundant resource allocation while scaling cluster size, thereby enhancing resource utilization efficiency.

6.2.4. The Relationship Between the Number of Nodes and Average Distance

Figure 8 illustrates the relationship between terminal node scale and the system’s average distance, with subfigures reflecting variation patterns under different k. As the number of nodes increases, the average distance between clusters and base stations decreases. This trend can be attributed to the spatial optimization effect resulting from higher node density: with more available nodes, the probability of selecting closer nodes while satisfying task resource requirements increases, leading to a cluster distribution geographically nearer to the base station and thereby reducing the average distance. Overall, for most node scales and cluster configurations, the average distance achieved by the proposed algorithm is significantly lower than that of the comparative algorithms. This demonstrates that the proposed method more effectively utilizes the geographical distribution of nodes to construct clusters with lower communication overhead and more optimal topologies. This contributes to reduced transmission delays and enhances the overall responsiveness of the system.

6.3. The Relationship Between the Number of Clusters and Each Objective

Figure 9 illustrates the trends in average computing power resources dispersion, cluster size, average matching deviation, and average distance across varying numbers of clusters under the condition of $k=3$, $N=300$. As evident from the graphs, each objective generally increases with the number of clusters. This occurs because different subtasks demand distinct computing power resources; when the number of clusters increases, algorithms cannot simultaneously satisfy optimal cluster configurations for all subtasks. Competition for nodes between clusters may occur, leading to subtasks being assigned to suboptimal clusters and consequently elevating the objective values. Despite the upward trend in all objective values as the number of clusters increases, the proposed algorithm consistently achieves lower values across all objectives compared to the baseline algorithms under the same number of clusters. This result robustly demonstrates that, in complex scenarios with varying k, the proposed algorithm can construct terminal clusters with higher resource-task matching, more compact structure, and lower communication overhead, significantly outperforming the comparative algorithms in overall performance.

6.4. Convergence Analysis

Figure 10 illustrates the relationship between the objective values and the number of iterations for all algorithms under the condition of $k=3$ and $N=300$. The figure reveals that the convergence rates and objective values differ across algorithms.

The objective values decrease as the number of iterations increases. However, H-NSGAIII-DE consistently converges more rapidly to the optimal solution. Concurrently, H-NSGAIII-DE exhibits a significantly lower initial objective value compared to other comparative algorithms. This stems from its HSAGI strategy, which selects a greater number of high-quality individuals meeting the constraints from the candidate solutions to form the initial population. Consequently, it demonstrates superior objective performance from the outset. In contrast, algorithms employing random initial population generation often produce numerous unconstrained individuals during randomization.

These unconstrained individuals lower the overall objective value of the initial population, resulting in comparatively higher initial objective values for these algorithms. Furthermore, H-NSGAIII-DE employs differential mutation to perform mutation operations on individuals. Compared to the bit mutation of the original algorithm, this generates higher-quality new solutions. These solutions can more rapidly guide the proposed algorithm towards the optimal solution region, thereby accelerating convergence speed. Results demonstrate that the improved algorithm proposed in this paper, which incorporates the HSAGI initialization strategy and the differential mutation mechanism, exhibits significant advantages in enhancing both algorithm convergence speed and the quality of initial solutions.

6.5. Performance of the Algorithm

6.5.1. Objective Performance

To further compare the performance improvements of the algorithm, two traditional algorithms, PSO and ABC, were added for comparison. Under the condition of a node scale of 300 and cluster numbers (k) set to 1, 2, and 3, respectively, the optimization results of each algorithm were recorded and analyzed in detail. Specific performance metrics are presented in

Table 4. Objective functions performance (The bolded values indicate the best performance).

Objective	Values	H-NSGAIII-DE	NSGAIII-S-CDAS	H-NSGAIII	NSGA-III-DE	NSGA-III	NSGA-II	NSGAIII-MSDR	PSO	ABC
A (k = 1)	Best	$\mathbf{4}.\mathbf{54}\times {\mathbf{10}}^{-\mathbf{2}}$	$4.71\times {10}^{-2}$	$6.46\times {10}^{-2}$	$9.33\times {10}^{-2}$	$7.05\times {10}^{-2}$	$1.93\times {10}^{-1}$	$2.75\times {10}^{-1}$	$1.31$	$1.50$
	Worst	$\mathbf{6}.\mathbf{00}\times {\mathbf{10}}^{-\mathbf{2}}$	$6.36\times {10}^{-2}$	$7.75\times {10}^{-2}$	$1.24\times {10}^{-1}$	$8.71\times {10}^{-2}$	$2.49\times {10}^{-1}$	$3.17\times {10}^{-1}$	$1.78$	$2.73$
	Mean	$\mathbf{5}.\mathbf{03}\times {\mathbf{10}}^{-\mathbf{2}}$	$5.39\times {10}^{-2}$	$7.03\times {10}^{-2}$	$1.02\times {10}^{-1}$	$7.84\times {10}^{-2}$	$2.21\times {10}^{-1}$	$2.93\times {10}^{-1}$	$1.59$	$2.10$
	Std Dev	$4.52\times {10}^{-3}$	$4.56\times {10}^{-3}$	$\mathbf{3}.\mathbf{99}\times {\mathbf{10}}^{-\mathbf{3}}$	$8.28\times {10}^{-3}$	$4.49\times {10}^{-3}$	$1.57\times {10}^{-2}$	$1.30\times {10}^{-2}$	$1.61\times {10}^{-1}$	$4.47\times {10}^{-1}$
B (k = 1)	Best	$\mathbf{2}.\mathbf{33}\times {\mathbf{10}}^{-\mathbf{3}}$	$3.17\times {10}^{-3}$	$3.72\times {10}^{-3}$	$3.63\times {10}^{-3}$	$3.44\times {10}^{-3}$	$3.34\times {10}^{-3}$	$5.17\times {10}^{-3}$	$8.47\times {10}^{-3}$	$8.00\times {10}^{-3}$
	Worst	$\mathbf{2}.\mathbf{83}\times {\mathbf{10}}^{-\mathbf{3}}$	$3.86\times {10}^{-3}$	$4.55\times {10}^{-3}$	$4.66\times {10}^{-3}$	$4.06\times {10}^{-3}$	$4.39\times {10}^{-3}$	$6.18\times {10}^{-3}$	$1.85\times {10}^{-2}$	$1.74\times {10}^{-2}$
	Mean	$\mathbf{2}.\mathbf{55}\times {\mathbf{10}}^{-\mathbf{3}}$	$3.45\times {10}^{-3}$	$4.09\times {10}^{-3}$	$4.07\times {10}^{-3}$	$3.79\times {10}^{-3}$	$3.78\times {10}^{-3}$	$5.58\times {10}^{-3}$	$1.22\times {10}^{-2}$	$1.31\times {10}^{-2}$
	Std Dev	$\mathbf{1}.\mathbf{55}\times {\mathbf{10}}^{-\mathbf{4}}$	$2.10\times {10}^{-4}$	$2.45\times {10}^{-4}$	$2.88\times {10}^{-4}$	$1.81\times {10}^{-4}$	$2.98\times {10}^{-4}$	$2.67\times {10}^{-4}$	$3.03\times {10}^{-3}$	$2.63\times {10}^{-3}$
C (k = 1)	Best	$\mathbf{10}$	11	10	12	11	16	11	71	68
	Worst	$\mathbf{26}$	26	29	33	30	36	29	118	99
	Mean	17	$\mathbf{16}.\mathbf{47}$	$18.60$	$20.33$	$20.33$	$25.93$	$18.00$	$87.00$	$81.93$
	Std Dev	$\mathbf{5}.\mathbf{24}$	$5.38$	$6.27$	$6.91$	$6.95$	$7.07$	$6.06$	$13.05$	$10.37$
D (k = 1)	Best	$\mathbf{63}.\mathbf{25}$	$77.12$	$67.53$	$70.05$	$73.93$	$76.37$	$74.34$	$107.23$	$131.70$
	Worst	$\mathbf{93}.\mathbf{44}$	$111.52$	$96.17$	$100.62$	$107.53$	$107.21$	99.85	$165.43$	$171.78$
	Mean	$\mathbf{78}.\mathbf{18}$	$90.40$	$80.56$	$87.38$	$91.79$	$93.24$	$85.86$	$138.71$	$150.53$
	Std Dev	$\mathbf{8}.\mathbf{26}$	$9.27$	$9.96$	$8.93$	$12.12$	$10.15$	$8.49$	$18.18$	$14.12$
A (k = 2)	Best	$\mathbf{4}.\mathbf{13}\times {\mathbf{10}}^{-\mathbf{2}}$	$8.32\times {10}^{-2}$	$5.64\times {10}^{-2}$	$1.31\times {10}^{-1}$	$1.26\times {10}^{-1}$	$2.13\times {10}^{-1}$	$1.51\times {10}^{-1}$	$1.21$	$2.17$
	Worst	$\mathbf{6}.\mathbf{59}\times {\mathbf{10}}^{-\mathbf{2}}$	$1.23\times {10}^{-1}$	$8.18\times {10}^{-2}$	$1.78\times {10}^{-1}$	$1.69\times {10}^{-1}$	$2.66\times {10}^{-1}$	$2.08\times {10}^{-1}$	$2.59$	$2.64$
	Mean	$\mathbf{5}.\mathbf{31}\times {\mathbf{10}}^{-\mathbf{2}}$	$1.01\times {10}^{-1}$	$6.92\times {10}^{-2}$	$1.51\times {10}^{-1}$	$1.43\times {10}^{-1}$	$2.35\times {10}^{-1}$	$1.70\times {10}^{-1}$	$1.69$	$2.39$
	Std Dev	$\mathbf{6}.\mathbf{91}\times {\mathbf{10}}^{-\mathbf{3}}$	$1.31\times {10}^{-2}$	$8.30\times {10}^{-3}$	$1.55\times {10}^{-2}$	$1.23\times {10}^{-2}$	$1.69\times {10}^{-2}$	$1.73\times {10}^{-2}$	$4.05\times {10}^{-1}$	$1.58\times {10}^{-1}$
B (k = 2)	Best	$\mathbf{2}.\mathbf{35}\times {\mathbf{10}}^{-\mathbf{3}}$	$3.01\times {10}^{-3}$	$2.72\times {10}^{-3}$	$3.09\times {10}^{-3}$	$3.61\times {10}^{-3}$	$2.69\times {10}^{-3}$	$4.91\times {10}^{-3}$	$1.34\times {10}^{-2}$	$1.22\times {10}^{-2}$
	Worst	$\mathbf{3}.\mathbf{09}\times {\mathbf{10}}^{-\mathbf{3}}$	$3.62\times {10}^{-3}$	$3.39\times {10}^{-3}$	$4.04\times {10}^{-3}$	$4.45\times {10}^{-3}$	$4.52\times {10}^{-3}$	$5.90\times {10}^{-3}$	$2.37\times {10}^{-2}$	$2.01\times {10}^{-2}$
	Mean	$\mathbf{2}.\mathbf{68}\times {\mathbf{10}}^{-\mathbf{3}}$	$3.29\times {10}^{-3}$	$2.95\times {10}^{-3}$	$3.57\times {10}^{-3}$	$3.99\times {10}^{-3}$	$3.49\times {10}^{-3}$	$5.34\times {10}^{-3}$	$1.77\times {10}^{-2}$	$1.51\times {10}^{-2}$
	Std Dev	$\mathbf{1}.\mathbf{98}\times {\mathbf{10}}^{-\mathbf{4}}$	$2.06\times {10}^{-4}$	$2.21\times {10}^{-4}$	$2.89\times {10}^{-4}$	$2.23\times {10}^{-4}$	$6.25\times {10}^{-4}$	$2.66\times {10}^{-4}$	$2.76\times {10}^{-3}$	$2.10\times {10}^{-3}$
C (k = 2)	Best	$\mathbf{25}$	33	28	27	28	32	35	112	128
	Worst	$\mathbf{41}$	52	48	54	55	60	56	146	151
	Mean	$\mathbf{31}.\mathbf{13}$	$43.33$	$38.60$	$40.67$	$42.73$	$47.60$	$44.73$	$133.40$	$141.00$
	Std Dev	$\mathbf{5}.\mathbf{53}$	$7.24$	$6.12$	$9.18$	$7.82$	$8.97$	$7.73$	$9.16$	$6.20$
D (k = 2)	Best	$\mathbf{68}.\mathbf{95}$	$81.86$	$74.95$	$88.09$	$74.19$	$73.93$	$81.75$	$93.72$	$152.23$
	Worst	$\mathbf{96}.\mathbf{12}$	$123.35$	$113.28$	$124.85$	$121.85$	$128.28$	$110.31$	$169.75$	$175.25$
	Mean	$\mathbf{81}.\mathbf{47}$	$106.10$	$91.84$	$102.94$	$98.94$	$103.88$	$98.58$	$141.60$	$164.99$
	Std Dev	$\mathbf{8}.\mathbf{79}$	$12.31$	$12.29$	$8.95$	$14.29$	$16.95$	$9.51$	$27.05$	$8.06$
A (k = 3)	Best	$\mathbf{9}.\mathbf{16}\times {\mathbf{10}}^{-\mathbf{2}}$	$2.70\times {10}^{-1}$	$4.73\times {10}^{-1}$	$4.03\times {10}^{-1}$	$4.93\times {10}^{-1}$	$3.73\times {10}^{-1}$	$3.38\times {10}^{-1}$	$2.18$	$2.17$
	Worst	$\mathbf{2}.\mathbf{19}\times {\mathbf{10}}^{-\mathbf{1}}$	$5.54\times {10}^{-1}$	$7.09\times {10}^{-1}$	$6.52\times {10}^{-1}$	$8.05\times {10}^{-1}$	$6.73\times {10}^{-1}$	$6.65\times {10}^{-1}$	$3.09$	$3.11$
	Mean	$\mathbf{1}.\mathbf{43}\times {\mathbf{10}}^{-\mathbf{1}}$	$3.61\times {10}^{-1}$	$5.74\times {10}^{-1}$	$5.32\times {10}^{-1}$	$6.50\times {10}^{-1}$	$4.91\times {10}^{-1}$	$4.54\times {10}^{-1}$	$2.76$	$2.78$
	Std Dev	$\mathbf{4}.\mathbf{02}\times {\mathbf{10}}^{-\mathbf{2}}$	$8.62\times {10}^{-2}$	$7.21\times {10}^{-2}$	$7.93\times {10}^{-2}$	$1.01\times {10}^{-1}$	$9.32\times {10}^{-2}$	$8.53\times {10}^{-2}$	$3.07\times {10}^{-1}$	$3.66\times {10}^{-1}$
B (k = 3)	Best	$\mathbf{1}.\mathbf{65}\times {\mathbf{10}}^{-\mathbf{3}}$	$4.36\times {10}^{-3}$	$3.87\times {10}^{-3}$	$4.43\times {10}^{-3}$	$4.54\times {10}^{-3}$	$3.95\times {10}^{-3}$	$4.34\times {10}^{-3}$	$1.59\times {10}^{-2}$	$1.46\times {10}^{-2}$
	Worst	$\mathbf{2}.\mathbf{62}\times {\mathbf{10}}^{-\mathbf{3}}$	$6.33\times {10}^{-3}$	$5.26\times {10}^{-3}$	$7.05\times {10}^{-3}$	$7.91\times {10}^{-3}$	$5.59\times {10}^{-3}$	$7.71\times {10}^{-3}$	$1.88\times {10}^{-2}$	$2.19\times {10}^{-2}$
	Mean	$\mathbf{2}.\mathbf{16}\times {\mathbf{10}}^{-\mathbf{3}}$	$5.33\times {10}^{-3}$	$4.49\times {10}^{-3}$	$5.56\times {10}^{-3}$	$5.69\times {10}^{-3}$	$4.78\times {10}^{-3}$	$5.97\times {10}^{-3}$	$1.72\times {10}^{-2}$	$1.84\times {10}^{-2}$
	Std Dev	$\mathbf{3}.\mathbf{10}\times {\mathbf{10}}^{-\mathbf{4}}$	$5.78\times {10}^{-4}$	$3.99\times {10}^{-4}$	$8.28\times {10}^{-4}$	$1.07\times {10}^{-3}$	$5.00\times {10}^{-4}$	$9.82\times {10}^{-4}$	$8.72\times {10}^{-4}$	$2.19\times {10}^{-3}$
C (k = 3)	Best	$\mathbf{44}$	66	56	53	71	67	72	146	162
	Worst	$\mathbf{55}$	85	79	83	92	94	88	163	188
	Mean	$\mathbf{48}.\mathbf{53}$	$74.80$	$65.33$	$67.87$	$81.80$	$77.87$	$78.80$	$154.33$	$174.87$
	Std Dev	$\mathbf{3}.\mathbf{66}$	$5.51$	$7.50$	$7.89$	$6.13$	$7.41$	$4.60$	$5.33$	$7.79$
D (k = 3)	Best	$\mathbf{80}.\mathbf{40}$	$111.68$	$89.93$	$90.61$	$102.23$	$108.11$	$109.57$	$147.72$	$140.14$
	Worst	$\mathbf{108}.\mathbf{90}$	$133.71$	$127.42$	$131.27$	$159.02$	$153.36$	$135.32$	$175.94$	$180.55$
	Mean	$\mathbf{96}.\mathbf{46}$	$121.26$	$109.66$	$111.56$	$124.99$	$127.47$	$125.66$	$162.67$	$163.03$
	Std Dev	$7.93$	$7.34$	$11.70$	$11.25$	$15.13$	$13.61$	$\mathbf{6}.\mathbf{99}$	$8.72$	$12.98$

. In the table, the letters A, B, C, and D correspond to the four core objective functions defined in this paper: A represents the average matching deviation, B represents the average computing power resources dispersion, C denotes the cluster size, and D signifies the average distance. For clear identification of the optimal results, the best values for each metric across different algorithms are highlighted in bold.

Analysis of the data in Table 4 reveals that the proposed H-NSGAIII-DE algorithm demonstrates significant advantages across all four evaluation metrics. Specifically, across multiple statistical dimensions—including the best, worst, and mean values, as well as the standard deviation—the proposed algorithm consistently outperforms all other compared algorithms. When k = 1 and 2, the improvement of H-NSGA-II-DE over the optimal baseline algorithm is not significant, whereas when k = 3, the proposed algorithm demonstrates superior performance across all objectives. Regarding the core metric of average matching deviation (A), H-NSGAIII-DE achieves an average improvement of $38.16\%$ compared to the second-best baseline algorithm. For the average computing resource dispersion (B), which measures resource balance, the average improvement is $32.17\%$. In terms of optimizing cluster size (C), an improvement of $15.02\%$ is observed. Additionally, an $8.76\%$ performance gain is achieved in the average distance (D) metric, which relates to communication efficiency.

To further investigate the statistical significance of the observed performance differences, this study conducted 15 independent repeated experiments for each algorithm under the fixed condition of 300 nodes. Based on the experimental results, box plots (Figure 11, Figure 12, Figure 13 and Figure 14) are generated and supplemented with Welch’s ANOVA for statistical testing. Considering the substantial differences in the numerical ranges of the metrics across algorithms, a dual-Y-axis design was adopted in the box plots for average matching deviation (A) and average computing power resources dispersion (B) to enhance visualization and readability. Data for the PSO and ABC algorithms correspond to the right-hand axis. Letters above the box for each algorithm indicate significant grouping results. According to statistical convention, algorithms marked with the same letter do not exhibit statistically significant differences (p > 0.05), while those marked with different letters indicate statistically significant differences (p < 0.05). If a box is marked with two letters (e.g., “bc”), it indicates that the algorithm’s performance shows no significant difference from the groups marked with “b” or “c.”

The statistical results presented in Figure 11, Figure 12, Figure 13 and Figure 14 lead to the following conclusions: Under the specific scenario of cluster number k = 1, the improved algorithm proposed in this paper shows no statistically significant difference in the average distance (D) and average matching deviation (A) metrics compared to the current best baseline algorithm, NSGAIII-S-CDAS. However, in all other tested scenarios and metrics, the performance of the H-NSGAIII-DE algorithm consistently and stably exhibits statistically significant differences compared to the other algorithms. It is particularly noteworthy that when the cluster number increases to k = 3, the proposed algorithm demonstrates the most pronounced significant differences and the most outstanding performance advantages across all objective functions compared to the other algorithms. This series of statistical test results robustly confirms that the proposed algorithmic improvements not only yield observable performance enhancements but are also grounded in solid statistical significance, thereby validating the effectiveness and superiority of the H-NSGAIII-DE algorithm in solving this category of optimization problems.

6.5.2. Scalability Analysis

The computational complexity of the proposed H-NSGAIII-DE algorithm is characterized as follows: the HSAGI initialization phase, which employs simulated annealing, exhibits O($M^2$) complexity, where M denotes the number of iterations and N represents the node count. Meanwhile, the NSGA-III selection mechanism requires O($M{N}^2$) operations for non-dominated sorting, with M indicating the number of objective functions. In contrast, the genetic operations (crossover and mutation) maintain a lower O(N) complexity.

As the system scales from 300 to several thousand nodes, the primary computational bottleneck emerges from the O($N^2$) complexity components, particularly during non-dominated sorting and simulated annealing initialization. Although experimental validation in this study was conducted at a scale of 300 nodes, complexity analysis indicates that H-NSGAIII-DE possesses inherent scalability potential for large-scale IoT deployments.

To address scalability challenges in future implementations, several strategic directions may be pursued: developing hierarchical processing architectures to mitigate computational complexity, adopting distributed computing paradigms to enhance processing efficiency, and implementing approximate computation methods to balance accuracy with performance requirements. Additionally, edge computing frameworks coupled with dynamic update mechanisms present promising approaches for managing increasing node scales effectively. These identified pathways provide a structured foundation for subsequent research efforts aimed at algorithmic optimization in ultra-large-scale scenarios.

7. Conclusions and Future Work

This study has systematically investigated the dynamic cluster matching problem for subtasks under heterogeneous computing power resource demands within a “cloud–edge–end” collaborative architecture. To address the differentiated computing resource requirements of subtasks in practical edge computing scenarios, we proposed a method for constructing specialized execution clusters based on specific computing power needs, utilizing an improved NSGA-III algorithm to form terminal clusters. Through comprehensive comparative experiments, the effectiveness and advantages of the proposed algorithm have been conclusively verified. The proposed method demonstrates significant performance improvements across all optimization objectives, achieving an 18.07% reduction in task–resource matching deviation, a 7.82% decrease in computing resource heterogeneity within clusters, a 15.25% reduction in cluster size, and a 10% decrease in server–terminal communication overhead. These quantitative results confirm the method’s effectiveness in substantially mitigating resource waste, minimizing node idleness, reducing communication costs, and alleviating uneven distribution of computing power. Consequently, our approach successfully constructs terminal clusters with optimized configurations for efficient task execution.

However, this research acknowledges several important limitations that warrant further investigation. First, the proposed clustering mechanism operates primarily in a pre-deployment phase based on static resource profiles, lacking adaptability to dynamic environmental changes. The absence of real-time considerations for network fluctuations, node mobility, and instantaneous load variations may lead to suboptimal performance in volatile edge environments. Second, while effective in initial cluster formation, the method lacks a fine-grained node selection mechanism for final task deployment, resulting in cluster redundancy and inefficient resource allocation. Most notably, the current model overlooks energy consumption metrics—a critical oversight given the battery-dependent nature of most edge devices, which may lead to premature node failures in practical deployments.

Building upon these findings, future research will focus on developing a comprehensive optimization framework that bridges coarse-grained clustering with fine-grained deployment. We plan to incorporate real-time parameters including dynamic network conditions, node transmission capabilities, load balancing metrics, and crucially, energy consumption profiles. This enhanced approach will establish a two-stage optimization process enabling cross-layer optimization from resource-aware clustering to energy-efficient deployment, ultimately enhancing task completion reliability and overall system sustainability in edge computing environments.