Collaborative Drift Compensation

01 · Motivation

Factories want shared models. They can't share data.

Process industries — mining, oil & gas, chemicals, manufacturing — run on machine-learning models for predictive maintenance and anomaly detection. But any single plant has too little data to train a good model, and its data is too sensitive (and too heavy) to ship elsewhere.

Federated learning (FL) squares that circle: every plant trains locally on its private data, and only the model weights travel. A central server averages them into one shared global model. Step through one round below.

This loop rests on a quiet assumption: that every client's data looks statistically the same, and stays the same. In an industrial plant, neither is true. Seasons change, valves wear out, sensors get recalibrated, operators relabel faults. The data drifts — and the shared model starts to rot.

02 · The problem

Drift: when the data moves under a frozen model

Drift comes in two flavours. Covariate drift changes the inputs, \(P(x)\) — the same faults, measured under new operating conditions. Concept drift changes the answer key, \(P(y\,|\,x)\) — the same measurements now mean something else. Try both on a live classifier trained on the original data:

Now the part that breaks existing methods: in a fleet of clients, drift is staggered in time and in space. Different plants drift at different rounds, in different directions. Press play to watch a fleet of ten clients live through ten training rounds:

One global model cannot serve a fleet whose members are living in different worlds. But letting each drifted client fend for itself throws away the whole point of federation. The question the paper answers: who should collaborate with whom, and how do you find out without ever seeing the data?

03 · Prior work

Why existing approaches fall short

Each family of prior methods fixes part of the problem and trips over the rest. Click through them — each card is a working demonstration of the failure mode.

04 · Our insight

The weights already know

A neural network's weight matrices are a function of the data they were trained on. When a client's data distribution shifts, the shift leaves a fingerprint in its weights. And federated learning hands us a free gift: every client starts each round from the same global model — a perfect common reference. Whatever differs between a client's weights and that reference was caused by that client's data.

Remember the two FedDrift clients with identical losses? Their weight fingerprints point in opposite directions. The scalar collapses the information; the weights preserve it.

05 · The algorithm

CLMA, step by step

CLMA (Collaborative Model Adaptation) runs as a thin layer on top of federated learning. Each round: clients train and self-check for drift with a loss test; drifted clients are quarantined out of their cohort; the server splits them by the direction of their weight shift (KS test), compresses their flattened weights (eigen-projection), clusters them (k-means), and spins up each cluster as a new cohort that continues federated learning among its own kind.

The simulator below runs the full pipeline on 10 clients × 10 rounds, with drifts injected exactly as in the paper's experiments. The pseudocode on the right is the paper's; the executing line lights up.

for c ← 1 to C do
  if c = 1: init cohorts H, quarantine W̅, model W
  (Wₙ, F) ← ClientLocalTraining(W, n, c)  ∀n
  W ← Aggregate({Wₙ});  Hₖ ← first cohort
  for each cohort Hₖ, each n ∈ Hₖ:
    (Wₖₙ, F) ← ClientLocalTraining(Wₖ, n, c)
    if F: W̅ ← W̅ ∪ Wₖₙ;  Hₖ ← Hₖ − {n}
  Wₖ ← Aggregate(Mₖ); send Wₖ to cohort Hₖ
  if W̅ ≠ ∅: H′ ← DriftCompensateCohorting(W̅, Wₖ)
  H ← H ∪ H′
end

if c = 1: L₋₁, Lₓ = ∞; F = False; γ = 0.1
Dₙ ← updated local data
Wₙ ← W − α∇Gₙ(W)      # local gradient steps
Lₓ ← Gₙ(Dₙ; Wₙ)         # loss on fresh data
if Lₓ > Lₓ₋₁ + γ: F ← True   # drift!
Lₓ₋₁ ← Lₓ
return Wₙ, F to server

S⁺, S⁻ ← ∅
for each drifted Wᵢ: T ← KSTest(Wᵢ, Wₖ)
  if T > 0: S⁺ ← S⁺ ∪ Flatten(Wᵢ)
  else:     S⁻ ← S⁻ ∪ Flatten(Wᵢ)
λ, V ← eig(SᵗS);  keep T largest (95% var.)
H⁺ ← KMeans(V′S⁺);  H⁻ ← KMeans(V′S⁻)
return H′ = H⁺ ∪ H⁻

Three properties are worth pausing on. Privacy-free detection: the server only ever sees weights and a boolean flag — exactly what vanilla FL already sends. Drift-agnostic: nothing in the pipeline asks what kind of drift happened, only which clients' weights moved together. Two deployment modes: the same loss test runs during training (Algorithm 2) and after deployment on live inference data (Algorithm 4), so a fielded model can call itself back for adaptation.

06 · The math, animated

Three small ideas doing the heavy lifting

6.1  Drift detection: a loss tripwire

A client flags drift when its fresh-data loss jumps by more than a threshold: \(L_c > L_{c-1} + \gamma\). The threshold trades sensitivity against false alarms — feel the trade-off yourself:

6.2  Direction of drift: the KS test on weights

The Kolmogorov–Smirnov statistic is the biggest vertical gap between two cumulative distributions. Applied to weight values — client vs. global reference — its signed statistic tells us which way the client's weights shifted. Positive shifts go to \(S^{+}\), negative to \(S^{-}\):

6.3  Grouping: eigen-projection, then k-means

A flattened weight vector has thousands of dimensions; comparing clients there is noisy and slow. CLMA keeps only the eigenvectors explaining 95% of the variance — the directions along which clients actually differ — then runs k-means in that small space. Step through the pipeline:

07 · Experiments & results

Does it work? Ten clients, real industrial data

Experiments use PRONTO, an industrial benchmark from a multiphase-flow facility: 17 process variables, five classes (Normal + four faults), split across 10 clients. Drifts are injected at rounds 3, 5, 7 and 9 on 8 of the 10 clients — covariate drift by shifting feature statistics, concept drift by moving the labelling boundary. A 1D-CNN classifies faults; the metric is F1.

7.1  Who gets grouped with whom

The heatmap shows each client's cohort at every round. CLMA resolves distinct cohorts per drift direction per round; FedDrift only ever separates "drifted" from "not drifted".

7.2  Client-level performance

F1 over communication rounds. Dashed vertical lines mark drift injections. Toggle methods in the legend; hover for exact values; switch views to see the three stories the paper tells.

Charts are interactive reconstructions of the paper's figures; values are illustrative of the reported trends — see the paper for the measured curves.

08 · Takeaways

What this changes

Where this matters: fleets of similar assets under different conditions — compressor stations across climates, production lines across factories, turbines across wind farms. Anywhere "one global model" meets "many local realities".

Open directions from the paper: adaptive (rather than fixed) thresholds \(\gamma\), richer statistical tests, stronger clustering methods, and validation on messier real-world asset data.

09 · Resources

Paper & citation

• Paper: Collaborative Drift Compensation — ACM DL (doi:10.1145/3703323.3703341)
• Venue: 8th International Conference on Data Science and Management of Data (12th ACM IKDD CODS & 30th COMAD), December 2024.
• Dataset: PRONTO multiphase-flow benchmark (Stief et al., 2019).
• Built with: TensorFlow and the Flower federated-learning framework.

@inproceedings{latha2024drift,
  author    = {Nanjaiya Latha, Adarsh and Amarlingam, Madapu and Sharma, Divyasheel},
  title     = {Collaborative Drift Compensation},
  booktitle = {Proc. 6th Joint International Conference on Data Science and Management of Data (CODS-COMAD)},
  year      = {2024},
  doi       = {10.1145/3703323.3703341}
}