Energy-Aware Bid-Based Client Selection for Federated Learning in Resource-Constrained IoT Networks ^†

Abstract

Federated learning (FL) enables distributed IoT devices to train machine learning models collaboratively without sharing raw data. However, energy heterogeneity among devices significantly challenges efficient and equitable participation, particularly in resource-constrained networks. This paper introduces BEAF (Bid-based Energy-Aware Federated Learning), a client selection strategy that incorporates the availability of energy and the training utility of the device into a unified selection criterion. Each client independently computes a bid score based on its remaining energy and the relative improvement in local training loss. Clients with the highest utility-per-joule scores are selected to participate in each round. The approach operates without centralized profiling or historical coordination and is compatible with synchronous FL protocols. The evaluation of standard benchmarks shows that BEAF enhances the precision of the global model, reduces total energy consumption, and improves fairness in client participation compared to baseline methods, such as random sampling and selection based on energy thresholds. The method is suitable for deployment in energy-limited environments, including agricultural monitoring and other distributed sensing applications.

1. Introduction

Wireless sensor networks and distributed monitoring systems often rely on battery-powered devices to collect and process data in physical environments. In applications such as smart agriculture [1], structural health monitoring [2], and environmental sensing [3], the ability to perform machine learning locally has gained relevance [4]. Training on a central server tends to boost bandwidth and latency, elevate energy use, and introduce privacy risks. Federated learning (FL) addresses these concerns by enabling devices to train a shared model collaboratively without sharing raw data [5]. A central server periodically selects a subset of devices to perform local model updates using their private datasets during each global iteration. The aggregated updates are then used to refine a global model. FL reduces communication volume and supports privacy preservation, but its performance is heavily dependent on the selection and availability of participating devices. Many existing implementations, including FedAvg [5], do not incorporate device-level constraints such as energy capacity or computational load and instead rely on uniform or random selection.

In practice, IoT devices vary in their available resources and communication conditions. Some participants (the terms devices, clients, and participants are interchangeable in the paper) have limited energy during training, which can lead to premature depletion of the battery, especially in remote or unattended environments [6]. Furthermore, devices may differ in data quality and learning relevance, meaning that equal participation does not guarantee equal contribution. Training can become inefficient and unbalanced if clients are selected without regard to their energy levels or expected utility [7]. This issue becomes more significant in large-scale systems with heterogeneous nodes and nonuniform data distributions. This paper considers an FL scenario where IoT devices deployed in an agricultural monitoring setting are responsible for training a model that predicts environmental conditions relevant to irrigation planning. Each device collects data independently and may differ in sensing intervals, energy availability, and communication cost. The objective is to maintain model performance while preserving the operational lifespan of devices through selective and energy-aware participation.

A client selection mechanism is proposed in which each device locally evaluates its readiness to participate based on two criteria: remaining energy and a measure of the utility of recent training. Clients compute a bid from estimated contribution and available energy; higher bids are more likely to be selected. The method fits distributed systems that rely on local computation rather than centralized scheduling. In contrast to fixed threshold methods [8,9], this mechanism dynamically adjusts to changes in energy conditions and data value. Figure 1 depicts the end-to-end round workflow in a zoned agricultural deployment. Sensor nodes are grouped by field zones (Zone 1, Zone 2, …, Zone n). Each node measures soil moisture, temperature, and humidity, and maintains two local state variables: $F_i$ (recent local model performance) and $E_i$ (residual energy). The FL server coordinates training as follows. (1) Broadcast: At the start of each round, the server disseminates the current global model to all reachable nodes. (2) Local evaluation and bid computation: Upon reception, each node executes a short local pass to obtain the change in training loss and combines it with its energy state to form a bid score $b_i$ (higher indicates greater utility per unit energy). (3) Bid uplink: Nodes transmit a single scalar bid to the server; no model parameters are sent at this stage. (4) Client selection: The server ranks bids and selects the top-k nodes for the round (green arrows in the figure denote selected links, red arrows denote rejected bids). Nodes below the selection threshold or flagged as low-energy are marked ineligible and defer participation. (5) Aggregation: Only selected nodes perform local training and upload model updates to the server, which aggregates them and prepares the next global model for the subsequent round. The legend indicates B (bid computing block), $F_i$ (local performance), $E_i$ (energy), and the ineligible status used to prevent deep discharge.

2. Related Work

Federated learning (FL) enables collaborative model training without exposing raw data. The canonical algorithm, FedAvg [5], samples clients uniformly each round; this simplifies coordination but ignores heterogeneity in computation, energy, and link quality. Client selection under heterogeneity, e.g., the model presented by Nishio and Yonetani [9], prioritizes devices with low expected computation and communication delays, reducing stragglers but assuming steady availability and ignoring energy limits. The joint scheduling of bandwidth and participants has also been studied; Shi et al. [10] balanced spectrum allocation with selection, and Xu and Wang [11] adapted the number of participants across rounds. These designs improve communication efficiency yet typically omit battery feedback. Energy-aware participation, like threshold rules, restricts training to clients with sufficient residual energy [8,12]. This helps prevent deep discharge, but it can also exclude data-rich devices and weaken the global model. While practical for constrained hardware, fixed thresholds lack flexibility when energy levels and data importance vary over time. Utility- and data-aware selection involves methods that weight clients based on the informativeness of their updates. In their work, Amiri et al. [13] and Wang et al. [14] prioritized high-impact contributions, while Zhang et al. [15] addressed non-IID data by favoring more representative local datasets. These strategies can improve accuracy but risk leading to repeated client selections, which can concentrate energy depletion. Incentives and practical constraints, such as auction-based mechanisms that compare declared utility against cost [16], offer flexibility at a computational overhead that may not suit embedded nodes. Recent systems work targets real-world constraints: intelligent reflecting surfaces reduce uplink energy in IRS-assisted FL [17], LESSON provides latency-aware semi-synchronous aggregation to curb stragglers [18], and MACS predicts availability under mobility [19]. These advances address latency and connectivity, while energy diversity is often modeled only indirectly.

This work introduces BEAF, a bid-based energy-aware framework that blends a client’s current energy state with its recent training contribution into a single local bid. Unlike FedAvg’s random sampling and fixed-threshold policies, BEAF explicitly trades off resource availability and informativeness during selection, aiming for higher accuracy, improved energy efficiency, and fairer participation in energy-constrained IoT and sensor networks.

3. System Model and Problem Formulation

Consider an FL framework consisting of a central server and a set of distributed clients denoted by $\mathcal{N}=\{1,2,\dots ,N\}$. Each client $i\in \mathcal{N}$ possesses a private non-IID dataset ${\mathcal{D}}_i$, computational capacity $C_i$, and a time-varying energy reserve $E_i^{\mathrm{rem}}\left(t\right)$. Training proceeds in synchronized communication rounds. At the beginning of each round t, the central server broadcasts the current global model $w_t$ to all clients. Clients then locally assess their readiness for participation based on energy availability and potential learning contribution.

To evaluate learning utility, the relative change in local loss is computed as

$${\delta }_i\left(t\right)={\displaystyle \frac{F_i\left(w_{t-1}\right)-F_i\left(w_t\right)}{F_i\left(w_{t-1}\right)}},$$

(1)

where $F_i\left(w_t\right)$ denotes the local empirical loss for client i. Based on this metric, a bid score is computed:

$$b_i\left(t\right)={\delta }_i\left(t\right)·{\displaystyle \frac{E_i^{\mathrm{rem}}\left(t\right)}{E_i^{\mathrm{train}}+E_i^{\mathrm{comm}}}},$$

(2)

where $E_i^{\mathrm{train}}$ and $E_i^{\mathrm{comm}}$ represent the estimated energy costs of local training and communication, respectively.

Each client transmits its bid to the server, which selects a subset of the top-k clients:

$${\mathcal{S}}_t=TopK\left({\left\{b_i\left(t\right)\right\}}_{i\in \mathcal{N}}\right).$$

(3)

Each selected client performs local training by minimizing its empirical risk:

$$\underset{w}{min}{\mathcal{L}}_i\left(w\right)={\displaystyle \frac{1}{|{\mathcal{D}}_i|}}\sum _{x_j\in {\mathcal{D}}_i}\ell (w;x_j),$$

(4)

The updated local models are then returned to the server and aggregated via FedAvg:

$$w_{t+1}=\sum _{j\in {\mathcal{S}}_t}{\displaystyle \frac{|{\mathcal{D}}_j|}{{\sum }_{k\in {\mathcal{S}}_t}\left|{\mathcal{D}}_k\right|}}{w}_j.$$

(5)

The client selection problem is posed as the following constrained optimization:

$$\begin{array}{cc}\hfill \mathbf{P}\mathbf{0}:& \underset{\mathbf{a}\left(t\right)}{max}\sum _{i=1}^N{a}_i\left(t\right){\delta }_i\left(t\right)\hfill \end{array}$$

(6)

$$\begin{array}{cc}\hfill \mathrm{s}.\mathrm{t}.& \sum _{i=1}^N{a}_i\left(t\right)\left(E_i^{\mathrm{train}}+E_i^{\mathrm{comm}}\right)\le E_{\mathrm{budget}}\left(t\right),\hfill \end{array}$$

(7)

$$\begin{array}{cc}\hfill & \mathcal{A}\left(w_T\right)\ge {\mathcal{A}}_{min},\hfill \end{array}$$

(8)

$$\begin{array}{cc}\hfill & a_i\left(t\right)\in \{0,1\},\forall i\in \mathcal{N}.\hfill \end{array}$$

(9)

The objective is to maximize the global model accuracy $\mathcal{A}\left(w_T\right)$ at the final communication round T. The first constraint ensures that the total energy consumption of all selected clients in each round does not exceed the predefined energy budget, denoted as $E_{\mathrm{budget}}\left(t\right)$. This condition maintains energy feasibility across rounds. The second constraint enforces a performance guarantee by requiring the final global model accuracy to meet or exceed a minimum threshold ${\mathcal{A}}_{\min }$. The third constraint defines $a_i\left(t\right)$ as a binary decision variable indicating whether client i is selected at round t.

4. The Proposed BEAF Framework

This work introduces the Bid-based Energy-Aware Federated Learning (BEAF) framework to address the client selection problem under energy constraints. The main idea is to allow each client to independently decide whether to participate in a given round based on both its energy availability and the potential value of its contribution to the global model. At the beginning of each communication round, the server broadcasts the current global model to all clients. Each client then evaluates their status by computing a bid score that reflects the relative improvement in the accuracy of their local model and the ratio of their remaining energy to the energy required for local training and communication. Clients send their bid scores to the server, which ranks them and selects the top-k clients for the round. Only the selected clients perform local training and return model updates. Others remain inactive to conserve energy. After receiving the model updates, the server aggregates them using weighted averaging and updates the global model. Training continues for a predefined number of rounds. For computational cost and intended use, the client-side bid computation uses two local loss values and a few arithmetic operations: this is $\mathcal{O}\left(d\right)$ in model size d and small relative to the local update, and each client sends one scalar bid per round. On the server, selecting the top-k bids is $\mathcal{O}(NlogN)$ with sorting (or $\mathcal{O}\left(N\right)$ with a selection algorithm), and the aggregation follows standard FedAvg. The method targets synchronous, round-based FL with energy budgets and intermittently available IoT devices. Algorithm 1 summarizes the proposed BEAF algorithm.

Algorithm 1 BEAF: Bid-Based Energy-Aware Federated Learning
Require: $w_t$, N, k
1:	for each client $i\in \{1,\dots ,N\}$ in parallel do
2:	Compute $F_i\left(w_t\right),F_i\left(w_{t-1}\right)$; ${\delta }_i\left(t\right)={\displaystyle \frac{F_i\left(w_{t-1}\right)-F_i\left(w_t\right)}{F_i\left(w_{t-1}\right)}}$
3:	Estimate $E_i^{\mathrm{train}},E_i^{\mathrm{comm}},E_i^{\mathrm{rem}}\left(t\right)$
4:	$b_i\left(t\right)={\delta }_i\left(t\right)·{\displaystyle \frac{E_i^{\mathrm{rem}}\left(t\right)}{E_i^{\mathrm{train}}+E_i^{\mathrm{comm}}}}$; send $b_i\left(t\right)$
5:	end for
6:	Select ${\mathcal{S}}_t=\mathrm{TopK}\left(\left\{b_i\left(t\right)\right\}\right)$; broadcast $w_t$
7:	for each $j\in {\mathcal{S}}_t$ do
8:	$w_j\leftarrow \mathrm{LocalUpdate}\left(w_t\right)$; send $\Delta w_j$
9:	end for
10:	Aggregate (FedAvg) to obtain $w_{t+1}$; return $w_{t+1}$

5. Results

Assume $N=20$ clients collaborate with a central server to train a global model. Each client is assigned a local dataset sampled from one of three benchmark datasets: MNIST, FashionMNIST, and CIFAR-10. The data are distributed in a non-IID and unbalanced manner to reflect real-world heterogeneity. The training process proceeds for $T=50$ communication rounds, with $k=5$ clients selected in each round.

Each client begins with a maximum energy capacity of $E_{max}=100$ energy units. Per-round energy comprises local training $E_i^{\mathrm{train}}\in [2,3]$ and communication $E_i^{\mathrm{comm}}\in [1,2]$; these values are drawn once per client and fixed. A client is skipped in any round where its residual energy cannot cover both costs. The task is a binary classifier that predicts irrigation need from simulated environmental measurements.

• FedAvg [5]: Random client selection without resource consideration.
• Threshold-based [8,9,20]: Clients are eligible only if their energy exceeds a fixed threshold.
• BEAF: The proposed bid-based energy-aware selection.

Figure 2a–c present the classification accuracy trends over 50–rounds for MNIST, FashionMNIST, and CIFAR-10, respectively. Across all datasets, BEAF consistently outperforms the other methods, showing faster convergence and higher final accuracy. On MNIST, BEAF delivers the most stable learning and top performance. BEAF outperforms all baselines on Fashion-MNIST and keeps a clear lead on the harder CIFAR-10, showing strength across datasets. Figure 3a plots model accuracy across rounds; Figure 3b shows energy use versus accuracy (trade-off), where BEAF requires the least energy for each accuracy gain; and Figure 3c illustrates client participation fairness measured via Jain’s index [21]. BEAF achieves more balanced participation by dynamically rotating client involvement based on energy and utility, while FedAvg and Threshold methods exhibit skewed and limited participation, respectively. Finally, Figure 4 shows how often each client was selected during training compared to their average bid score. The x-axis shows the average bid score of each client, and the y-axis shows how many rounds that client joined. In the case of FedAvg (red), clients were picked randomly, so there is no clear link between bid score and participation. As a result, the method repeatedly selected some clients while barely involving others. The Threshold method (green) only allowed clients with sufficient energy to join, excluding some who had useful data but lacked sufficient power, which resulted in gaps in participation. BEAF (blue) shows a clear trend: higher bids lead to more frequent selection. It prioritizes informative updates while conserving energy, supporting its effectiveness in energy-constrained FL.

Table 1. Final test accuracy (%) across datasets.

Dataset	FedAvg	Threshold	BEAF
MNIST	89.3	90.1	92.8
FashionMNIST	78.0	81.0	86.0
CIFAR-10	65.0	67.0	71.0

presents the final test accuracy achieved by different federated learning methods across the evaluated datasets, highlighting the superior performance of the proposed approach.

6. Conclusions

This work presented BEAF, a bid-based energy-aware client selection framework for federated learning in resource-constrained IoT environments. The proposed method enables decentralized decision-making by allowing clients to compute participation bids based on their energy availability and local training utility. The client selection problem was formulated as a constrained optimization task, and BEAF provided an efficient approximation through its dynamic and scalable bidding mechanism. Simulation results demonstrated that BEAF improves global model accuracy, reduces energy consumption, and enhances participation fairness compared to standard baselines such as FedAvg and energy-threshold methods. These results highlight the effectiveness of BEAF in supporting sustainable and equitable federated learning, particularly in energy-limited scenarios such as agricultural sensor networks and similar distributed systems.