Federated Continual Learning

FCL models learn from non-i.i.d. (non-independent and identically distributed) and non-stationary data streams that arrive sequentially across many independent clients (e.g., smartphones, IoT sensors). Unlike batch learning, data is not centrally available and its statistical properties change over time at each device. This requires algorithms that can adapt to local concept drift while aggregating knowledge globally.

• Example: A keyboard prediction model on millions of phones must adapt to new slang and typing patterns on each device without accessing the raw text data.

A foundational constraint is that raw training data never leaves the local device. Only model updates (e.g., gradients, parameters) are shared with a central server. This is often combined with additional privacy techniques like Differential Privacy (DP), which adds calibrated noise to updates, or Secure Aggregation, a cryptographic protocol that prevents the server from inspecting any single client's update. This addresses regulatory requirements (GDPR, HIPAA) for sensitive data.

A primary technical challenge is catastrophic forgetting—the tendency for a neural network to overwrite knowledge of previous tasks when learning new ones. In FCL, this is exacerbated because the server never sees the global data distribution. Solutions are adapted from continual learning:

• Regularization Methods: Penalize changes to parameters important for past global knowledge (e.g., Elastic Weight Consolidation).
• Rehearsal Methods: Devices store a small replay buffer of past local data to interleave with new data.
• Architectural Methods: Dynamically expand the global model or use masking to isolate parameters for different data distributions.

FCL must minimize the cost of transmitting model updates between edge devices and a central server, as bandwidth and device energy are limited. This drives techniques like:

• Compression: Sending only the most significant gradient updates via sparsification or quantization.
• Partial Participation: Only a subset of clients (e.g., 1-10%) train and communicate in each federated round.
• Local Training Rounds: Performing multiple stochastic gradient descent steps on the device before communicating, reducing total communication rounds. The goal is to achieve high accuracy with the fewest bits transmitted.

Data across clients is inherently heterogeneous—the distribution of data on one device (e.g., a user's photo library) is not representative of the global population. This statistical heterogeneity causes client drift, where local models diverge significantly, complicating the aggregation of a single, globally performant model. FCL algorithms must be robust to this, often employing techniques like client-specific personalization layers or adaptive aggregation (e.g., weighting updates based on data volume or similarity).

The federated network consists of devices with vastly different capabilities (system heterogeneity). This includes variations in:

• Compute Power: From microcontrollers to smartphones.
• Network Connectivity: Intermittent, slow, or metered connections.
• Battery Life: Training must be energy-efficient.
• Availability: Devices may drop in and out of training (stragglers).

FCL systems must handle this gracefully, often using asynchronous aggregation or allowing devices to perform variable amounts of local work based on their resources.

Smartphone assistants and predictive keyboards use FCL to learn from individual user interactions—typing habits, app usage, location patterns—without uploading private data. The local model sequentially adapts to new slang, schedule changes, or emerging interests. Key challenges include managing battery consumption during local training and ensuring backward transfer so learning a new language doesn't degrade existing autocorrect performance.

A fleet of vehicles encounters diverse, non-stationary driving conditions (e.g., new construction zones, seasonal weather). Each vehicle performs on-device training to adapt its perception model to local anomalies. Federated aggregation at a central server merges these adaptations into a global model that improves safety for the entire fleet. This addresses the stability-plasticity dilemma at scale, ensuring the model learns new road signs without forgetting how to recognize standard ones.

Hospitals worldwide use FCL to collaboratively improve a medical imaging model (e.g., for tumor detection) as new patient data and rare case studies emerge. Each institution trains locally on sequential patient batches, preserving data sovereignty. The global model evolves without catastrophic forgetting of previously learned pathologies. Techniques like gradient episodic memory (GEM) are crucial to prevent learning from a new cancer subtype from degrading performance on common diagnoses.

Networks of factory sensors monitor machinery. Each sensor's local model learns sequentially from its unique vibration and thermal data stream, adapting to wear patterns. A global FCL model synthesizes these learnings to predict failures across different machine types and environments. This requires efficient replay buffers on memory-constrained devices and robust aggregation to handle non-IID data—sensors in one plant may experience very different failure modes.

Streaming platforms use FCL on smart TVs and phones to personalize recommendations. The local model continually learns from a user's evolving viewing sessions (a non-stationary data stream). Federated updates allow the global model to discover emerging trends (e.g., a new show going viral) across millions of users without accessing individual watch histories. This system must balance online continual learning (immediate adaptation) with privacy guarantees like differential privacy during update transmission.

Remote acoustic sensors in a forest use FCL to adaptively classify animal sounds as species migrate or new vocalizations are discovered. Each sensor trains on a sequential stream of audio clips. Federated aggregation creates a robust, evolving bio-acoustic model. This application epitomizes edge-CL challenges: extreme resource constraints, unreliable connectivity, and the need for lifelong learning over years without human intervention.

A machine learning paradigm where a model learns sequentially from a non-stationary data stream, accumulating knowledge over time without catastrophic forgetting of previous tasks. Core challenges include the stability-plasticity dilemma. Primary methodological families include:

• Regularization-based methods (e.g., EWC, SI) that penalize changes to important parameters.
• Rehearsal-based methods (e.g., Experience Replay) that store/replay past data.
• Architectural methods (e.g., Progressive Networks) that dynamically expand the model.

The phenomenon where a neural network abruptly and drastically loses performance on previously learned tasks when trained on new data. It occurs due to unconstrained parameter overwriting and represents the core problem continual learning aims to solve. In federated settings, this is exacerbated by data heterogeneity across clients, where local updates can pull the global model in conflicting directions, erasing knowledge relevant to other devices.

A rehearsal-based continual learning technique where a subset of past training data (or their latent representations) is stored in a replay buffer. During training on new tasks, these stored examples are interleaved with new data, allowing the model to rehearse old knowledge. In federated continual learning, managing this buffer on resource-constrained edge devices is a key challenge, often requiring strategies like core-set selection or generative replay to minimize memory footprint.

A regularization-based continual learning algorithm that mitigates forgetting by slowing down learning on parameters deemed important for previous tasks. It calculates a Fisher information matrix to estimate each parameter's importance and applies a quadratic penalty to changes proportional to this importance. In federated settings, EWC can be applied locally on devices to protect task-specific knowledge before updates are sent to the server, though aggregating these local importance measures globally is non-trivial.

The process of performing forward and backward passes to update a model's parameters directly on an edge device (e.g., smartphone, microcontroller) using locally generated data. This is a fundamental requirement for both federated learning and continual learning on edge. It imposes severe constraints on memory, compute, and energy consumption, driving the need for techniques like selective activation, micro-batching, and optimized kernels for low-power hardware.