FLEET: A Federated Learning Emulation and Evaluation Testbed for Holistic Research

TL;DR

FLEET is a comprehensive testbed that emulates realistic network conditions to evaluate federated learning algorithms, bridging the gap between theoretical design and practical deployment.

Contribution

The paper introduces FLEET, a scalable, configurable platform integrating a versatile learning component with a high-fidelity network emulator for holistic FL research.

Findings

Supports diverse ML frameworks and real-world network topologies

Enables systematic study of network effects on FL convergence

Provides holistic metrics linking network conditions to algorithm performance

Abstract

Federated Learning (FL) presents a robust paradigm for privacy-preserving, decentralized machine learning. However, a significant gap persists between the theoretical design of FL algorithms and their practical performance, largely because existing evaluation tools often fail to model realistic operational conditions. Many testbeds oversimplify the critical dynamics among algorithmic efficiency, client-level heterogeneity, and continuously evolving network infrastructure. To address this challenge, we introduce the Federated Learning Emulation and Evaluation Testbed (FLEET). This comprehensive platform provides a scalable and configurable environment by integrating a versatile, framework-agnostic learning component with a high-fidelity network emulator. FLEET supports diverse machine learning frameworks, customizable real-world network topologies, and dynamic background traffic generation. The testbed collects holistic metrics that correlate algorithmic outcomes with detailed network statistics. By unifying the entire experiment configuration, FLEET enables researchers to systematically investigate how network constraints, such as limited bandwidth, high latency, and packet loss, affect the convergence and efficiency of FL algorithms. This work provides the research community with a robust tool to bridge the gap between algorithmic theory and real-world network conditions, promoting the holistic and reproducible evaluation of federated learning systems.

Tables

Table 1. TABLE I : Comprehensive Comparison of Federated Learning Testbeds Highlighting Their Core Paradigms, System Architectures, Network Emulation Capabilities, Configurability, and Performance Metrics

Feature	LEAF	CoLexT	MininetFed	FLEET
Core Paradigm	Statistical heterogeneity benchmark	Real-world hardware testbed	System emulation	System emulation
FL Framework	Custom reference implementations	Flower (Framework-Agnostic)	Custom implementation (MQTT-based)	Flower (Framework-Agnostic)
Topology Support	Not applicable	Fixed (Physical network)	Custom scripts	Extensive: (Topohub, Internet Topology Zoo, custom scripts)
Background Traffic	No	No	No	Iperf3 or TCPReplay with multiple traffic patterns
Key Metrics	FL (accuracy), System (FLOPS, bytes)	FL (accuracy), System (CPU, energy, memory)	FL (accuracy, loss), Network (traffic)	FL (accuracy, loss), Network (TX/RX), System (CPU, memory)
Primary Contribution	Standardized datasets and metrics for statistical heterogeneity.	High-fidelity system metrics (especially energy) from physical hardware.	Flexible emulation of client resources and network links with security.	Unified, realistic emulation of FL algorithms, systems, and networks.

Table 2. TABLE II : Background Traffic Patterns Supported by FLEET

Traffic Pattern	Description
Poisson	Simulates random, memoryless event arrivals.
Bursty	Alternates between high-traffic bursts and idle periods.
Uniform	Maintains a constant traffic rate over time.
Normal	Varies traffic rate according to a Gaussian distribution.
SineWave	Generates traffic with smooth, sinusoidal variation.

Full text

I Introduction

Federated Learning (FL) has emerged as a transformative approach to distributed machine learning, enabling collaborative model training on decentralized devices while ensuring user data remains localized [1]. This paradigm is crucial for domains such as healthcare, the Internet of Things (IoT), and autonomous systems, where centralizing data is often infeasible due to privacy regulations, data sovereignty concerns, or prohibitive communication costs. By orchestrating model training directly at the network edge, FL leverages vast distributed datasets to build powerful models without compromising user privacy, signaling a fundamental departure from traditional, centralized artificial intelligence.

Despite its promise, the practical deployment of robust and efficient FL systems faces significant hurdles, particularly in the domain of evaluation. The performance of an FL algorithm is not solely a product of its mathematical design; it is deeply coupled with the environment in which it operates. This environment is defined by a triad of challenges: statistical heterogeneity, where data is non-independently and non-identically (non-IID) distributed across clients; systems heterogeneity, where devices possess varied computational, memory, and power resources; and network dynamics, where communication links suffer from fluctuating bandwidth, latency, and reliability [2]. While benchmarks like LEAF [3] have made important advances in providing realistic federated datasets to address statistical heterogeneity [3], a truly comprehensive evaluation must also integrate the complexities of the underlying system and networking infrastructure.

To properly assess FL algorithms, researchers require tools that can comprehensively model these multifaceted challenges. Current evaluation methodologies, however, reveal a distinct trade-off between realism and scale. Pure software simulations offer scalability but typically rely on abstract models of network and system behavior, which may fail to capture the complex, non-linear interactions that arise in real-world deployments. This abstraction can create a significant ”simulation-to-reality” gap, where algorithms that appear effective in theory underperform in practice. Conversely, physical hardware testbeds provide high-fidelity performance data but are expensive to build, difficult to maintain, and lack the flexibility to systematically study diverse network topologies or dynamic conditions at scale. There is a pressing need for a platform that merges the configurability of simulation with the realism of hardware environments.

In response to these challenges, we have developed the Federated Learning Emulation and Evaluation Testbed (FLEET). Our work directly addresses the need for high-fidelity evaluation by innovating a platform around the synergy between the Flower AI framework [4] and the Containernet network emulator [5]. This integration yields a powerful and flexible testing environment. Flower’s framework-agnostic nature grants researchers the freedom to experiment with familiar tools like PyTorch, TensorFlow, and JAX. Simultaneously, Containernet leverages Docker containers to create realistic client emulations with fine-grained control over system resources and network link characteristics. This architecture allows for the recreation of complex, real-world network topologies and the simulation of dynamic conditions through background traffic injection. By collecting and synchronizing comprehensive metrics that span both algorithmic performance and network statistics, FLEET provides a holistic view of an FL system in operation, thereby enabling a more rigorous and insightful investigation into the multifaceted challenges of federated learning. FLEET is available at [6].

II Related Work

The evaluation of FL systems has inspired various research tools and testbeds, each addressing different challenges of decentralized training. Our work builds upon the foundations laid by key testbeds that have progressively introduced more practical consideration into FL experimentation. We position our contribution concerning three significant works, LEAF, CoLexT [7], and MininetFed [8], to highlight the specific gaps our integrated platform, FLEET, aims to fill.

Caldas et al. introduced LEAF, a foundational benchmark designed to address statistical heterogeneity in federated settings. Its primary contribution is a suite of open-source datasets with natural user-based partitions that model non-IID and unbalanced data distributions. LEAF provides a common ground for comparing algorithms based on how they handle data challenges, focusing primarily on the data layer of FL evaluation.

To incorporate systems-level realism, Božič et al. developed CoLexT, a testbed for FL experimentation on physical devices. CoLexT excels at capturing authentic hardware performance metrics, such as CPU utilization and real-world energy usage, by deploying algorithms directly onto a heterogeneous collection of single-board computers and smartphones. This approach provides high-fidelity system measurements that are unattainable in pure simulation.

Sarmento et al. proposed MininetFed, a container-based emulation tool for modeling FL environments. It allows researchers to configure heterogeneous client hardware and network link properties, such as bandwidth and latency, within a containerized architecture. This provides a flexible platform for exploring the interplay between FL algorithms and the system and network parameters of the clients.

Our testbed, FLEET, synthesizes the strengths of these prior works while addressing their individual limitations. It extends beyond the purely statistical focus of LEAF by providing a rich environment to emulate critical network and systems-level challenges. Unlike CoLexT, which relies on physical hardware, the emulation-based approach of FLEET offers superior scalability, cost-effectiveness, and the flexibility to model thousands of complex network topologies. Finally, FLEET improves upon MininetFed by integrating with the widely-adopted Flower ecosystem for broad compatibility and by incorporating more advanced network modeling. Specifically, it utilizes real-life network topologies from sources like Topohub [9] and introduces background traffic with different patterns, capabilities not extensively supported in MininetFed. This holistic approach provides a unified platform for comprehensive FL research. Table I provides a detailed comparison of the core paradigms, architectures, and capabilities across these testbeds and our own.

III System Overview

We designed a highly configurable and extensible testbed that integrates a robust FL framework with a realistic network emulation environment. The core architecture combines Flower, a framework-agnostic FL library, with Containernet, a Docker-based network emulator. This integration enables researchers to conduct reproducible experiments that jointly investigate algorithmic performance and network dynamics. Each FL participant operates within an individual Docker container, connected through an emulated network where link characteristics are precisely controlled.

The entire experimental workflow is orchestrated through a unified configuration system using a set of three TOML files for FL, Containernet, and general settings. This separation promotes ease of use and reproducibility, and we provide default settings for a quick start. A user defines all experimental parameters across these files, from which the testbed automatically sets up the network, deploys the containers, initiates training, generates background traffic, and collects comprehensive metrics. This holistic approach bridges the gap between purely theoretical FL simulations and complex, real-world deployments.

III-A Federated Learning Component

The testbed leverages Flower framework, a flexible and extensible platform for building federated learning systems. Flower supports a wide range of machine learning models, aggregation strategies, and deployment scenarios, making it well-suited for research and experimentation in distributed learning. It provides built-in abstractions for client-server communication, training orchestration, and evaluation, allowing researchers to prototype and scale federated learning workflows with minimal boilerplate.

To better support our experimental goals, we extended Flower’s server and client components to enable advanced metrics collection and greater configurability. Users can easily customize or replace core components, such as models, datasets, and aggregation methods, via configuration files. Additionally, we integrated the psutil library to collect system-level resource usage from clients, enabling the server to implement resource-aware client selection strategies. These capabilities are not natively supported by Flower and were essential for our research focus on performance and resource-constrained environments.

III-B Dataset Handling and Partitioning

A critical aspect of realistic FL emulation is the ability to model heterogeneous data distributions across clients. Our testbed incorporates the Flower Datasets library, which provides a powerful abstraction for dataset access and partitioning. This library integrates seamlessly with the HuggingFace Hub, granting access to thousands of datasets across various domains, such as standard image classification benchmarks (CIFAR-10, MNIST) and natural language processing tasks (IMDB, WikiText).

To simulate data heterogeneity, the testbed supports multiple partitioning strategies. A common baseline is IID partitioning, where data is distributed uniformly among clients. To model more realistic scenarios, it also provides several non-IID mechanisms. For instance, a shard-based approach divides the dataset by class label, assigning a limited number of classes to each client. A more fine-grained method uses a Dirichlet distribution to vary class concentrations across clients, allowing for precise control over the degree of statistical heterogeneity.

III-C Network Emulation with Containernet

We use Containernet to construct the underlying network fabric for our experiments. As a fork of the Mininet emulator, Containernet replaces standard hosts with Docker containers, enabling full application stack execution within each network node. This container-based approach provides process and filesystem isolation for each FL client, closely mimicking a distributed production environment.

The network topology itself is highly customizable. A key feature is the integration with Topohub, an online repository that provides thousands of real-world and synthetic network models. This allows experiments to be grounded in realistic network structures, a critical factor for validating results. Alternatively, users can define custom structures (e.g., star, mesh) via a standard Mininet Python script. Beyond topology, the testbed offers granular control over link characteristics like bandwidth, latency, and loss rate, as well as per-container resource limits to simulate heterogeneous client hardware.

III-D Background Traffic Generation

In real-world networks, FL communication competes for bandwidth with other applications. To simulate this crucial aspect, the testbed includes a modular component for generating background traffic. This component deploys dedicated Docker containers that act as traffic generators and sinks, creating network congestion to test the resilience of FL algorithms under realistic load.

The module provides built-in support for two widely-used generation tools: Iperf3 for creating TCP and UDP flows, and TCPReplay for replaying captured network traffic. The intensity and timing of this traffic can follow various statistical patterns, summarized in Table II, to simulate different network scenarios. The architecture of this component is intentionally modular, so advanced users can easily integrate their own traffic generation tools or define custom patterns.

III-E Metrics Aggregation and Logging

A comprehensive evaluation requires correlating application-level performance with underlying system behavior. Our testbed is designed for holistic data collection, capturing metrics from all system components. The metrics fall into two main categories:

Federated Learning Metrics: These include model performance indicators like training loss and evaluation accuracy, round timings, and derived values such as communication time. 2. 2.

System and Network Metrics: These include the extended, client-specific metrics such as CPU and memory utilization, alongside network interface statistics, such as TX/RX bytes and rates, collected from Containernet.

To accommodate different analysis workflows, the testbed provides multiple logging destinations. For offline analysis, all metrics can be saved to local Logfiles and CSV files, which are easily imported into standard data analysis tools. For real-time monitoring, the testbed can stream all metrics over a ZeroMQ (ZMQ) publisher-subscriber socket, enabling the connection of external visualization dashboards. This multi-faceted approach ensures that researchers can capture the rich data needed to fully understand the complex interactions within the system.

IV Experimental Results

To validate the capabilities and demonstrate the versatility of our proposed testbed, we conducted a series of experiments designed to showcase its utility for comprehensive FL research, spanning real-time performance monitoring, in-depth analysis of network dynamics, comparative studies of learning algorithms, and the impact of realistic network congestion. The testbed has also been successfully used in other research work, including SmartFLow [10], demonstrating its practical applicability. The results underscore its ability to facilitate reproducible research into the complex interplay between FL algorithms, system resources, and network conditions.

IV-A Real-time Monitoring and Visualization

A key feature of our testbed is its capacity for real-time experiment monitoring, enabled by the integration of a ZeroMQ (ZMQ) publisher. This component streams a wide array of metrics from the server and all clients to any subscribed listener. We developed a Plotly-based dashboard to connect to this ZMQ stream, providing live visualization of the training process. This immediate feedback is invaluable for debugging, observing convergence patterns, and understanding system behavior without waiting for post-hoc analysis.

Figure 2(a) and Figure 2(b) illustrate the dashboard’s capabilities. Figure 2(a) displays the per-client CPU and memory utilization over time. This view allows a researcher to directly observe the computational footprint of the FL task on each device, providing critical insights into resource-constrained clients and the potential for system-aware client selection strategies. Simultaneously, Figure 2(b) plots the progression of training loss and evaluation accuracy for each participating client. The ability to observe both system and learning metrics provides a holistic view of the experiment as it unfolds.

IV-B Comprehensive Metrics for Holistic Analysis

Beyond real-time visualization, the testbed logs extensive metrics to CSV files, enabling detailed offline analysis. This rich dataset allows researchers to investigate phenomena that are not apparent from high-level performance indicators alone. We demonstrate this through the collection of granular network statistics and by conducting comparative algorithmic studies under diverse data distributions.

IV-B1 Network Performance Analysis

Our testbed employs custom scripts to capture detailed network interface statistics from each container. Figure 3(a) shows the cumulative transmitted (TX) and received (RX) data for the central FL server, while Figure 3(b) presents the TX and RX rate rates for a single FL client. Such data allows researchers to identify communication bottlenecks, correlate network activity with specific FL events, and analyze the fine-grained network behavior of different aggregation protocols.

IV-B2 Algorithmic and Data Heterogeneity

The true power of an FL testbed lies in its ability to systematically explore the vast parameter space of federated learning. We showcase this by conducting an experiment using the CIFAR-10 dataset [11] with a MobileNetV3-Large model [12], deployed across 15 clients in a network topology from the Gabriel collection in Topohub. We evaluated three distinct data partitioning schemes and their interaction with different aggregation algorithms. Specifically, we used Pathological non-IID with FedYogi, Dirichlet-based non-IID with FedAvgM, and an IID setup with FedProx.

The results in Figure 4 demonstrate the testbed’s ability to produce nuanced, comparative insights. Figure 4(a) presents the evaluation accuracy curves, while Figure 4(b) shows the corresponding loss trajectories. Together, these plots enable researchers to analyze not only the final performance metrics, but also the convergence behavior of different method combinations. For instance, a researcher can use such results to quantify the performance degradation an algorithm suffers when moving from IID to non-IID data, or to identify which algorithm is most robust to a specific type of data heterogeneity.

IV-C Emulating Realistic Network Conditions

Many FL simulation tools operate under an unrealistic assumption of ideal network conditions, which limits their applicability. Our testbed addresses this limitation by integrating a robust module for generating background network traffic. We demonstrate its impact through an experiment using the IMDB movie review dataset [13] and a DistilBERT model [14]. The setup involved 10 FL clients connected via the Nobel-EU topology, a real-world research network model from Topohub.

We used Iperf3 to generate background traffic between nodes, creating congestion that competes with FL communication. Figure 5(a) illustrates two of the supported traffic patterns: a smooth, predictable SineWave pattern and a bursty, unpredictable Poisson pattern. Both patterns were capped at a bandwidth of 50 Mbps on a specific link. The background traffic profoundly affects FL performance. As Figure 5(b) shows, introducing traffic significantly increases communication time compared to a no-traffic baseline. The nature of the traffic also matters, with the bursty Poisson pattern inducing higher and more variable latency than the smoother SineWave pattern. This result highlights the critical need for realistically modeling network dynamics, as an FL algorithm’s performance can depend heavily on the characteristics of the underlying network traffic.

To analyze these effects in more detail, we dissected the time spent in a single FL round. Figure 5(c) compares the distribution of round completion times across different traffic patterns, illustrating how the overall round duration varies. For a more granular view, Figure 5(d) breaks down the time each client spends in distinct phases: S2C communication , local computation, C2S communication. This detailed timing information, collected via CSV logging, enables researchers to precisely identify bottlenecks. For example, a researcher can determine whether a long round time is due to a slow network link (high S2C/C2S time) or an underpowered client (high computation time). This granular analysis is essential for interpreting the effects of network congestion and for developing network-aware scheduling or aggregation strategies that are resilient to real-world conditions.

V Conclusion and Future Work

We introduced FLEET, a comprehensive and extensible federated learning testbed designed to bridge the gap between abstract simulation and real-world network conditions. By integrating the Flower federated learning framework with the Containernet network emulator, our system provides a high-fidelity environment for evaluating the performance and resilience of FL algorithms. The architecture allows researchers to control experimental variables with precision, from data partitioning and model selection to network topology and background traffic. Key contributions of this work include the modular configuration system using TOML files, the integration with Topohub for realistic network topologies, and the extension of the Flower framework to capture client-side system metrics. This holistic approach enables reproducible research that jointly considers algorithmic behavior and the impact of underlying network and hardware heterogeneity, providing a critical tool for developing robust and efficient federated systems.

While this work provides a robust foundation, we have identified several promising directions for future development. A primary goal is to extend the emulation capabilities to include wireless networks, particularly Wi-Fi and cellular standards, to model the complexities of signal attenuation, interference, and client mobility. To support larger-scale experiments, we will evolve the testbed to operate in a distributed fashion across multiple physical hosts, leveraging graph partitioning libraries like Pymetis to intelligently split the network topology. We also plan to incorporate more sophisticated aggregation protocols. This includes implementing decentralized, peer-to-peer (P2P) aggregation to remove the central server and integrating secure aggregation techniques based on secure multi-party computation (SMPC) or homomorphic encryption to enhance privacy. Looking further ahead, we plan to integrate the testbed with container orchestration platforms like Kubernetes and introduce energy consumption models to enable the design of energy-efficient FL algorithms, a crucial requirement for battery-powered edge devices.