Skip to content

Latest commit

 

History

History
127 lines (92 loc) · 6.68 KB

introduction.rst

File metadata and controls

127 lines (92 loc) · 6.68 KB

What is Federated Learning?

Federated learning (FL) is a decentralized machine learning approach. Instead of collecting data in one place, FL sends the model to where the data is—training happens locally on distributed devices or systems. The results are then aggregated into a single global model, all while keeping raw data private and secure.

Traditional machine learning

Traditional machine learning is centralized. Data from various sources is collected into a single location - typically a cloud platform or data center — and training models on that combined dataset.

This method works well in many cases, but it's increasingly limited. The rapid growth of connected devices, sensors and distributed data sources has led to an exponential increase in data volume and complexity. Meanwhile, privacy regulations and security concerns make centralizing this data difficult and expensive.

Often, the data needed for training exists across many devices, organizations, or locations. Centralizing it is challenging due to privacy risks and high transfer costs.

How federated learning works

In federated learning, models are trained across multiple devices or servers (called client nodes) without moving the data. Here's how it works:

  1. Initialize the global model - A central server starts with an initial global model—like a neural network or decision tree.
  2. Model retrieval - Selected clients download the current model parameters from the server. Their local datasets remain private.
  3. Local training - Each client updates the model using its local data. This training is repeated in several rounds — not to completion.
  4. Combining the updates - The updated models from each client are sent back to the central server, where they are combined.

This cycle repeats until the global model reaches the desired accuracy.

The Scaleout Edge framework

Scaleout Edge focuses on security, scalability, and ease of use. It supports the full development lifecycle—from early experiments to production deployments—with minimal code changes. Key design goals include:

  • Minimal server-side complexity for the end-user. Scaleout Edge handles orchestration, providing a UI, REST API, and Python interface for managing experiments and tracking metrics in real time.
  • Secure by design. Clients never need to open inbound ports. gRPC, token-based authentication (JWT) and RBAC provides flexible and secure integration.
  • ML-framework agnostic. A black-box client-side architecture lets data scientists use any ML framework.
  • Cloud native. Deploy on public cloud, private cloud, or on-prem infrastructure.
  • Scalability and resilience. Multiple combiners can balance load. Scaleout Edge handles failures in all critical components and manages intermittent client-connections.
  • Developer and DevOps friendly. Logging, tracing, and plugin architecture simplify monitoring, debugging, and extending the system.

Features

Federated learning:

  • Tiered federated learning architecture enabling massive scalability and resilience.
  • Support for any ML framework (examples for PyTorch, Tensforflow/Keras and Scikit-learn)
  • Extendable via a plug-in architecture (aggregators, load balancers, object storage backends, databases etc.)
  • Built-in federated algorithms (FedAvg, FedAdam, FedYogi, FedAdaGrad, etc.)
  • UI, CLI and Python API.
  • Implement clients in any language (Python, C++, Kotlin etc.)
  • No inbound ports required on client devices

From development to FL in production

Scaleout Edge provides a complete operational toolkit for moving federated learning from early prototypes to production deployments. The platform’s capabilities can be grouped into the following categories:

ModelOps / FL Ops

  • UI and dashboards for orchestrating FL experiments and monitoring training progress.
  • REST API for managing experiments and jobs.
  • Support for multi-round orchestration and model lifecycle management.
  • Plug-in architecture for extending aggregators, storage backends, load balancers, and orchestration components.

Observability & Telemetry

  • Built-in logging, tracing, and experiment metrics.
  • Export and integration options for external observability systems.
  • Visual dashboards showing experiment status, model performance, client activity, and system health.

Security & Trust

  • Secure, cloud-native control plane deployed on Kubernetes.
  • Token-based authentication (JWT) and role-based access control (RBAC).
  • Outbound-only connectivity for clients (no inbound ports required).
  • Trusted third-party features: manage access to the FL network, clients, and training progress.

Collaboration & Governance

  • Shared project workspaces for collaborative experimentation.
  • User and role management for multi-team or multi-organization setups.
  • Clear separation of responsibilities between data owners, model owners, and infrastructure operators.

Deployment & Infrastructure

  • Flexible deployment options: public cloud, private cloud, dedicated cloud, or fully on-premise.
  • Horizontal scalability through multiple combiners.
  • Resilience to intermittent client availability and failures across critical components.

Available client APIs:

Support

Community support is available in our Discord server.

For professionals / Enterprise, we offer Dedicated support.