The server typically possesses significantly greater computational power and better resource allocation than individual clients. This enables efficient execution of complex mathematical computations, especially when involving multiple clients. Furthermore, performing these calculations on the server side also reduces the communication overhead by eliminating the need to transmit the computed distances. Therefore, starting from Round 1, server will compute the Euclidean distance from each client model to the current global model once the server receives and aggregates the models from all participating clients. The calculation is formulated as follows: (4)di=∑k(wk−wi,k)2

The equation defined above calculates the Euclidean distance di between the global model and the model parameters of the i-th client. Here is a breakdown of the components within the equation:

wk represents the parameter vector of the global model. These parameters are aggregated values derived from the previous round of updates received from all or a subset of clients.

After the calculation is complete, the server will sort the di from largest to smallest. We will explain why later.

In this approach, we select clients based on a descending order of their Euclidean distance from the global model. Intuitively, selecting clients with the greatest divergence from the global model (i.e., the largest Euclidean distance) can introduce more information and data diversity. This is beneficial for the global model as it aids in learning and adapting to a broader data distribution, thereby reducing the risk of over-fitting. By prioritizing clients whose models significantly differ from the global model, each iteration can incorporate more substantial updates, potentially allowing the global model to adapt more quickly to the entire data distribution. We introduce a decay function to dynamically adjust the number of clients selected in each round. The decay function allows the algorithm to adjust the number of participating clients dynamically based on the progress of training or the performance of clients. This method can specifically increase or decrease the number of clients involved in training at different stages to meet the needs of the model during the training process. Given an initial selection fraction α and a decay rate λ, the client selection fraction in round t is: (5)αt=α×exp⁡(−λt)

Adjusting the number of participating clients can more effectively utilize limited computational and communication resources. Initially, more clients may need to be involved to enhance the diversity of the model, while later in training, the number might be reduced to concentrate resources on optimizing a model that is nearing convergence. This method, compared to randomly selecting a fixed number of clients, improves the algorithm’s adaptability to different training stages and network conditions, particularly when facing non-IID data distributions. Let N be the total number of clients. The number of clients selected in round t is: (6)nt=max(⌈N×αt⌉,min_clients)where min_clients is a hyperparameter representing the minimum number of clients participating in each round.

To ensure the robustness and efficacy of the algorithm, especially when the total number of clients N is large and the proportion αt might be set relatively small. This parameter ensures sufficient model update diversity: it prevents inadequate model updates or excessive bias due to too few participating clients. It also ensures that enough clients participate to maintain the continuity and stability of model training, even if some clients may be unavailable due to technical issues.

In the FedAvg algorithm, the aggregation formula for updating the global model is traditionally given by: (7)wt+1=∑k=1Knknwkt

This formula ensures that each client’s contribution to the global model is weighted by the proportion of data they hold relative to the total dataset. However, the sheer volume of data does not always reflect a client’s potential impact on the model. Therefore, in our algorithm, the weight allocation formula is modified as follows: (8)wk=nk⋅exp⁡(βdk)∑i=1Kni⋅exp⁡(βdi)

nk is the size of the local dataset of client k.

Then the global model parameters are updated as follows: (9)wt+1=∑k=1Kwkwk(t)

This weight allocation formula not only considers the volume of data each client contributes but also the divergence of each client’s model from the global model. It introduces a corrective mechanism that allows models with greater Euclidean distances (i.e., more divergent client models) to have a more significant voice in the aggregation process. By employing an exponential function regulated by β, we can flexibly adjust the impact of the Euclidean distance. This provides a method to balance the respect between data-rich clients and those clients whose model parameters significantly differ. The denominator ∑i=1Kni⋅exp⁡(βdi) acts as a normalization factor, ensuring that the sum of all client weights equals 1, thus maintaining stability in the model update steps. By combining data volume and model divergence, the algorithm can balance the influence of different clients on the global model, utilizing the information provided by data-rich clients while preventing the model from deviating from the optimization path due to the excessive influence of outlier clients.

When β is set to a positive value, it implies that as the Euclidean distance dk between a client’s local model and the global model increases, so does their weight in the model update. In this setting, as dk increases (i.e., the greater the divergence of the client model from the global model), the greater their influence on the global model. This approach prioritizes clients with substantial differences from the global model, theoretically assisting the global model to quickly adapt and learn from the unique data patterns represented by a minority of clients. Applicable scenarios: This is particularly suitable in situations where the global model needs to learn from significant differences in client models, especially in cases of highly non-independent and identically distributed (Non-IID) data, helping to enhance the model’s diversity and generalization capabilities.

When β is set to a negative value, the weights decrease as dk increases. This means that clients with smaller differences from the global model gain greater weight, aiding the global model to learn more robustly towards the central tendency of the data, reducing fluctuations caused by extreme or deviating clients.

This method of weight allocation can enhance the robustness and generalization ability of the global model in federated learning. It ensures that all relevant characteristics, such as data volume and model uniqueness, are appropriately considered in weighting each client’s contribution. This method is particularly effective in heterogeneous environments, as client data distributions and system characteristics often vary greatly in reality. We will demonstrate this in the experiments.

In this algorithm, client selection and weight allocation are two interdependent components that together determine the efficiency and quality of the global model updates. They are less effective when existing alone while these components can be understood independently. And they complement each other when integrated, achieving optimal learning outcomes.

Limitations of Client Selection: Client selection alone, without appropriate weight allocation, may lead to an over-reliance on certain clients’ data. Particularly in scenarios where client data is highly imbalanced, selecting clients with larger data volumes can result in a model bias towards these clients’ characteristics, overlooking other important but smaller data volume clients. Purely basing client selection on criteria such as data volume or update frequency may neglect the differences between client models and the global model, which is detrimental to capturing the diversity of data across the entire network.

Limitations of Weight Allocation: If there is only weight allocation without an effective client selection mechanism, then weights might be allocated to clients that contribute minimally to model updates. For instance, clients with minimal divergence from the global model might receive higher weights, but these minor updates may not be sufficient to significantly enhance the model. Relying solely on weight allocation to handle all clients can lead to inefficient computations, especially when the number of clients is very large, resulting in significant computational and communication overhead that is largely unnecessary.

Client selection can reduce the number of clients that need to be processed each round, thereby reducing computational and communication burdens. On the other hand, weight allocation ensures that the maximum learning benefit is extracted from these selected clients, particularly by weighting updates from those clients who differ significantly from the global model, thereby accelerating model convergence. This combined strategy effectively learns from the data across the entire network, avoiding model over-fitting to specific client data and thus improving the model’s performance on unseen data.

FedCW requires each selected client to send its local model parameters to the server as in standard FL. The server computes the Euclidean distance dk for all participating clients, with complexity O(Nd) for N clients and d-dimensional parameters, followed by sorting in O(Nlog⁡N). These costs are negligible compared to the communication of model parameters. Furthermore, since FedCW dynamically reduces the number of participating clients via αt, the overall communication overhead is significantly reduced compared to FedAvg, as also validated in our experiments.

While FedCW demonstrates clear advantages in convergence and communication efficiency, its deployment in real-world vehicular networks also raises important concerns related to security, privacy, and system-level robustness. In particular, the Euclidean distance ranking strategy, although effective for selecting diverse clients, may inadvertently expose distributional characteristics of local model updates, thereby creating potential side-channel privacy risks. To mitigate this, future implementations of FedCW could be combined with secure aggregation protocols or differential privacy mechanisms that protect individual updates while still allowing the server to compute distance-based rankings. Another issue is the vulnerability of distance-based selection and adaptive weighting to malicious or Byzantine clients, who may inject manipulated updates to distort the aggregation process. Addressing this challenge requires the integration of anomaly detection techniques or Byzantine-resilient aggregation rules that can identify and suppress adversarial contributions without significantly increasing communication overhead. Beyond adversarial risks, large-scale vehicular deployments often encounter system bottlenecks such as channel congestion, synchronization delays, and frequent client churn, which can compromise the effectiveness of synchronous distance-based selection. To address these challenges, FedCW can be extended with asynchronous update strategies or hierarchical aggregation frameworks, where edge servers first coordinate subsets of vehicles before forwarding updates to the global server, thereby reducing latency and improving scalability.

The hyperparameters λ and β play central roles in balancing convergence and stability. The parameter λ controls the decay rate of client participation: larger λ leads to fewer clients in later rounds, reducing communication but potentially harming diversity, while smaller λ retains more clients, improving robustness but increasing overhead. The parameter β regulates the impact of Euclidean distance in weight allocation: positive β emphasizes clients with divergent models, accelerating adaptation to non-IID data but risking instability when extreme; negative β favors alignment with the global model, improving stability but slowing adaptation. Hence, λ and β jointly determine the trade-off between convergence speed, stability, and communication cost, and must be tuned according to heterogeneity levels and system constraints.

Notation and update rule.

Let 𝒦t be the set of selected clients at round t. Denote server iterate by wt and client k’s local iterate after its local training by wkt. Let akt≥0 be the server aggregation weights with ∑k∈𝒦takt=1 (in FedCW, akt∝nkexp⁡(βdk)). Define the aggregated direction (10)gt = ∑k∈𝒦takt∇fk(wkt).

The server performs the update (11)wt+1 = wt − ηtgt,where ηt>0 is the stepsize.

Assumption 1 (Smoothness): Each fk is L-smooth, i.e., for all w1,w2, (12)‖∇fk(w1)−∇fk(w2)‖ ≤ L‖w1−w2‖.

Consequently, the global objective F(w)=1N∑k=1Nfk(w) is also L-smooth.

Assumption 2 (Bounded gradients and variance): There exists G>0 such that for all k,w, (13)‖∇fk(w)‖ ≤ G.

Let ζt:=gt−E[gt|wt] be the zero-mean noise conditioned on wt. There exists σ2≥0 such that (14)E[‖ζt‖2|wt] ≤ σ2.

Assumption 3 (Selection/weighting and local-drift bias): Define the conditional-mean decomposition at the server point wt: (15)E[gt|wt] = ∇F(wt) + εt,where εt collects (i) selection/weighting mismatch (𝒦t⊂[N], non-uniform akt) and (ii) local drift because ∇fk(wkt) is evaluated at wkt≠wt. Assume the average bias energy is bounded: (16)1T∑t=0T−1E‖εt‖2 ≤ ε2¯.

Step 1: Descent lemma (exact algebra, no convexity).

By L-smoothness of F and the update (11), (17)F(wt+1)≤F(wt)+⟨∇F(wt),wt+1−wt⟩+L2‖wt+1−wt‖2=F(wt)−ηt⟨∇F(wt),gt⟩+Lηt22‖gt‖2.

Step 2: Decompose gt and expand the inner product.

From (15), write (18)gt = ∇F(wt) + εt + ζt,E[ζt|wt]=0.

Then (19)⟨∇F(wt),gt⟩=⟨∇F(wt),∇F(wt)⟩+⟨∇F(wt),εt⟩+⟨∇F(wt),ζt⟩=‖∇F(wt)‖2+⟨∇F(wt),εt⟩+⟨∇F(wt),ζt⟩.

Taking conditional expectation given wt, the noise term vanishes: (20)E[⟨∇F(wt),ζt⟩|wt]=0.

Using Young’s inequality ⟨a,b⟩≥−12‖a‖2−12‖b‖2 with a=∇F(wt) and b=εt gives (21)−⟨∇F(wt),εt⟩ ≤ 12‖∇F(wt)‖2+12‖εt‖2.

Multiplying (19) by −ηt and taking expectation yields (22)E[−ηt⟨∇F(wt),gt⟩] ≤ −ηt2E‖∇F(wt)‖2 + ηt2E‖εt‖2.

Step 3: Bound the quadratic term ‖gt‖2.

From (18) and (x+y+z)2≤3(x2+y2+z2), (23)‖gt‖2 ≤ 3‖∇F(wt)‖2 + 3‖εt‖2 + 3‖ζt‖2.

Taking expectation and using (14), (24)E‖gt‖2 ≤ 3E‖∇F(wt)‖2 + 3E‖εt‖2 + 3σ2.

Step 4: One-step expected descent inequality.

Taking expectation of (17) and substituting (22) and (24), (25)EF(wt+1)≤EF(wt)−ηt2E‖∇F(wt)‖2+ηt2E‖εt‖2+Lηt22(3E‖∇F(wt)‖2+3E‖εt‖2+3σ2).

Group coefficients of each term: (26)EF(wt+1) ≤ EF(wt)−(ηt2−3Lηt22)E‖∇F(wt)‖2+(ηt2+3Lηt22)E‖εt‖2+3Lηt22σ2.

Step 5: Stepsize choice and telescoping.

Choose a constant stepsize satisfying (27)ηt≡η ≤ 16L⟹η2−3Lη22 ≥ η4,η2+3Lη22 ≤ 3η4.

Then (26) becomes (28)EF(wt+1) ≤ EF(wt)−η4E‖∇F(wt)‖2+3η4E‖εt‖2+3Lη22σ2.

Summing (28) over t=0,…,T−1 and telescoping gives (29)η4∑t=0T−1E‖∇F(wt)‖2 ≤ EF(w0)−EF(wT)+3η4∑t=0T−1E‖εt‖2+3Lη22Tσ2.

Using F(wT)≥F⋆ and dividing by T yields the ergodic stationarity bound (30)1T∑t=0T−1E‖∇F(wt)‖2 ≤ 4(F(w0)−F⋆)ηT + 31T∑t=0T−1E‖εt‖2 + 6Lησ2.

Theorem 1 (Stationarity with selection/weighting bias): Under (12)–(16) and η≤1/(6L), (31)1T∑t=0T−1E‖∇F(wt)‖2 ≤ 4(F(w0)−F⋆)ηT + 3ε2¯ + 6Lησ2.

Remark 1 (Interpretation and roles of λ,β): In FedCW, the bias εt is controlled by the coverage of selected clients and the skewness of weights akt. A larger decay rate λ (fewer clients in later rounds) or a larger |β| (heavier emphasis on dk) typically increases ‖εt‖, enlarging the 3ε2¯ term and slowing convergence (or enlarging the neighborhood). Conversely, ensuring a minimal selection size and tempering |β| reduce ε2¯.

Corollary 1 (Convex case): If, additionally, F is convex and ηt is diminishing with ∑tηt=∞, ∑tηt2<∞, and 1T∑t=0T−1E‖εt‖2→0, then every limit point of {wt} is stationary; for convex F, stationary points are globally optimal.

Additional nonconvex result: iteration complexity and neighborhood size

Goal.

We turn (30) into an explicit iteration complexity statement under nonconvexity by optimizing the stepsize. Let A:=4(F(w0)−F⋆) and B:=3ε2¯. Then for constant η≤1/(6L), (32)1T∑t=0T−1E‖∇F(wt)‖2 ≤ AηT + B + 6Lησ2.

Optimizing the constant stepsize.

For fixed T, the right-hand side of (32) as a function of η is (33)Φ(η) = AηT + 6Lησ2 + B,η∈(0,16L].

Ignoring the box constraint momentarily, the unconstrained minimizer solves −Aη2T+6Lσ2=0, i.e., (34)η⋆ = A6Lσ2T.

If η⋆≤16L, plugging (34) back into (32) yields (35)1T∑t=0T−1E‖∇F(wt)‖2 ≤ 26LAσ2T + B = CT⏟stochastic term + B⏟bias floor,where C:=26LAσ2. Thus the ergodic stationarity measure decays as O(1/T) until it hits the bias floor B=3ε2¯.

Reaching an ϵ-stationary point (ergodic).

Given a target ϵ>0, to ensure (36)1T∑t=0T−1E‖∇F(wt)‖2 ≤ ϵ2,we need ϵ2>B and (37)CT ≤ ϵ2−B⟺T ≥ C2(ϵ2−B)2 = 24 L(F(w0)−F⋆)σ2(ϵ2−B)2.

Hence, under nonconvexity and stochasticity, FedCW attains an ϵ-stationarity level in T=O(1/(ϵ2−B)2) rounds, provided the bias floor B=3ε2¯ is below ϵ2. Reducing B (e.g., by ensuring a minimum selection size and tempering |β|) directly improves the attainable accuracy and the iteration complexity.

When η⋆>1/(6L).

If (34) violates the box constraint, set η=1/(6L) in (32) to obtain(38)1T∑t=0T−1E‖∇F(wt)‖2 ≤ 24L(F(w0)−F⋆)T + B + σ2L,which shows O(1/T) decay of the optimization term plus a fixed variance floor σ2/L and the bias floor B.

Diminishing stepsizes.

Alternatively, choosing ηt=η0/t+1 (with η0 small enough) yields the classical nonconvex rate(39)1T∑t=0T−1E‖∇F(wt)‖2 ≤ O(1T) + B,again saturating at the bias floor B.

Remark 2 (Practical knobs): The bias floor B=3ε2¯ shrinks when (i) the per-round selection size does not become too small (controlled by λ), and (ii) the weight skewness is moderated (controlled by |β|). These knobs trade off communication/computation with convergence speed and final accuracy. Moreover, λ directly controls the number of participating clients per round: a larger λ lowers communication overhead but increases the risk of slower convergence due to reduced diversity, while a smaller λ improves convergence at the cost of higher communication. Similarly, |β| determines the emphasis on divergent updates: larger values may accelerate convergence under moderate non-IID but risk instability under extreme heterogeneity, which could increase the total number of communication rounds required. Therefore, the choice of λ and β balances communication cost against convergence efficiency in non-IID environments.

The experiments were conducted on a machine equipped with an AMD Ryzen 5600X processor, 32 GB DDR4 RAM, a 1 TB SSD, and an NVIDIA GeForce RTX 4070ti super GPU. The experimental environment was set up using Python 3.8, with machine learning frameworks TensorFlow 2.5 and PyTorch 1.9 employed for implementing and training neural networks. We also used CUDA 11.8 with cuDNN support, and fixed random seeds (set to 42) for NumPy, PyTorch, and TensorFlow to ensure reproducibility. These tools and hardware configurations provided an efficient environment to conduct the experiments and analyze the results.

We utilized the LEAF framework [33], which is a benchmarking framework for learning in federated settings. LEAF provides tools and datasets for various applications, including federated learning, multi-task learning, meta-learning. This framework allowed us to simulate realistic federated environments and evaluate the performance of FedCW and baseline algorithms under different data distributions and client behaviors.

We evaluated FedCW on four image classification tasks using the MNIST, CIFAR-10, ImageNet-100, and CelebA datasets. To simulate different degrees of Non-IID across clients, we used a Dirichlet distribution to partition the data. Specifically, the training data for each dataset was divided among clients by sampling from a Dirichlet distribution with varying concentration parameters (α). For reproducibility, we set α=0.1,0.5,1.0,10 in experiments to represent strong non-IID, moderate non-IID, near-IID, and IID-like distributions, respectively. Lower values of α correspond to higher degrees of Non-IID, meaning that clients receive data concentrated on fewer classes. Conversely, higher values of α lead to a more IID-like distribution, where each client receives a more balanced share of the data across all classes. This method allows us to systematically control the degree of data heterogeneity among clients and assess the performance of FedCW under different Non-IID settings.

In our experiments, we focused on full client participation for each communication round. We compared FedCW with several popular baselines, including FedAvg, FedProx, SCAFFOLD, FedOpt, FedNova, and FedMA, across all datasets. Each algorithm was implemented using the same neural network architectures to ensure fair and consistent comparisons. The hyperparameters for each method, such as learning rate, batch size, and number of communication rounds, were tuned empirically based on prior experience. For FedCW specifically, we report the exact values used for λ and β in the experiment tables to ensure reproducibility.