Federated Learning

Introduction

Every time your phone's keyboard predicts your next word or your email app spots spam, a machine-learning model is quietly working behind the scenes. Training those models traditionally demanded one thing: all the data in one place. Upload your messages to a server, mix them with everyone else's, run the learning algorithm, ship the model back.

That bargain made AI powerful — and it made privacy advocates nervous.

In 2016 a team at Google asked a different question: what if the data never had to move? Instead of pulling raw examples to a central server, you could push the learning algorithm out to the devices themselves. Each device trains on its own local data, computes a small set of model updates (the direction the model should improve), and sends only those updates — not the data — back to a coordinator. The coordinator averages the updates, improves the global model, and ships the new model back. Repeat.

This is federated learning (McMahan et al., 2017). The raw data stays home. What travels is the gradient — a compact mathematical summary of what the data implied, not the data itself. The result is a model that has effectively "seen" the data on millions of devices without any single copy ever leaving a phone or a hospital server.

Federated learning sits at the intersection of neural network training and distributed systems, and it brings a new set of hard problems: communication cost, stragglers, non-uniform data, and the surprisingly subtle question of whether gradients alone are truly private.

Try It: Federated Averaging

Below are three devices, each holding a small private dataset of labeled points. The goal is to train a shared linear classifier that separates red dots (class 1) from blue dots (class 0).

Click Train one round to run one federated round: each device trains locally for a few steps, then their weight updates are averaged into a new global model. Watch the decision boundary shift as the rounds accumulate — no raw data ever leaves a device.

<div id="app">
  <div id="devices-row">
    <div class="device" id="dev0">
      <div class="dev-label">Device A</div>
      <canvas class="dev-canvas" width="140" height="120"></canvas>
      <div class="dev-info" id="info0">—</div>
    </div>
    <div class="device" id="dev1">
      <div class="dev-label">Device B</div>
      <canvas class="dev-canvas" width="140" height="120"></canvas>
      <div class="dev-info" id="info1">—</div>
    </div>
    <div class="device" id="dev2">
      <div class="dev-label">Device C</div>
      <canvas class="dev-canvas" width="140" height="120"></canvas>
      <div class="dev-info" id="info2">—</div>
    </div>
  </div>
  <div id="global-box">
    <div class="dev-label">Global Model (FedAvg)</div>
    <canvas id="global-canvas" width="320" height="200"></canvas>
    <div id="global-info">Round 0 — click Train one round to start.</div>
  </div>
  <div id="controls">
    <button id="btn-round">Train one round</button>
    <button id="btn-reset" class="ghost">Reset</button>
    <span id="round-counter">Round 0</span>
  </div>
</div>

* { box-sizing: border-box; margin: 0; padding: 0; }
body { font-family: system-ui, sans-serif; color: #222; background: #f8f9fa; padding: 12px; }
#app { display: flex; flex-direction: column; gap: 12px; align-items: center; }
#devices-row { display: flex; gap: 10px; flex-wrap: wrap; justify-content: center; }
.device { background: #fff; border: 1.5px solid #dde3ea; border-radius: 10px;
          padding: 8px; display: flex; flex-direction: column; align-items: center; gap: 4px;
          box-shadow: 0 1px 4px rgba(0,0,0,.07); }
.dev-label { font-size: .75rem; font-weight: 700; color: #5a7088; text-transform: uppercase; letter-spacing: .05em; }
.dev-canvas { border-radius: 6px; border: 1px solid #eee; display: block; }
.dev-info { font-size: .72rem; color: #555; min-height: 1.1em; }
#global-box { background: #fff; border: 2px solid #1d3557; border-radius: 10px;
              padding: 10px; display: flex; flex-direction: column; align-items: center; gap: 6px;
              box-shadow: 0 2px 8px rgba(29,53,87,.12); }
#global-canvas { border-radius: 6px; border: 1px solid #cdd9e3; display: block; }
#global-info { font-size: .8rem; color: #333; font-weight: 600; min-height: 1.2em; }
#controls { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; justify-content: center; }
button { font: 600 13px system-ui; padding: .4rem .85rem; border: 1.5px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
#round-counter { font-size: .8rem; color: #5a7088; font-weight: 600; }

const fmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Federated Averaging (FedAvg) simulation.
// Model: logistic regression y = sigmoid(w0*x + w1*y + b).
// 3 devices each hold a private cluster of labeled 2-D points.
// Each round: local gradient descent steps → average weights → update global model.

const sigmoid = t => 1 / (1 + Math.exp(-t));

// ── Dataset generation ───────────────────────────────────────────────────
function makeCluster(cx, cy, label, n, seed) {
  const pts = [];
  let s = seed;
  const rng = () => { s = (s * 1664525 + 1013904223) & 0xffffffff; return (s >>> 0) / 0xffffffff; };
  for (let i = 0; i < n; i++) {
    // Box-Muller
    const u = rng() || 1e-9, v = rng();
    const z0 = Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
    const z1 = Math.sqrt(-2 * Math.log(u)) * Math.sin(2 * Math.PI * v);
    pts.push({ x: cx + z0 * 0.18, y: cy + z1 * 0.18, label });
  }
  return pts;
}

// Three devices, each with two small clusters (one per class)
const DEVICES = [
  // Device A: top-left region
  [...makeCluster(0.22, 0.28, 1, 6, 7), ...makeCluster(0.38, 0.55, 0, 6, 13)],
  // Device B: centre
  [...makeCluster(0.50, 0.30, 1, 6, 31), ...makeCluster(0.62, 0.65, 0, 6, 53)],
  // Device C: bottom-right region
  [...makeCluster(0.65, 0.25, 1, 6, 71), ...makeCluster(0.78, 0.60, 0, 6, 97)],
];

// ── Model ────────────────────────────────────────────────────────────────
const LR = 0.8;   // learning rate
const LOCAL_STEPS = 8;

function predict(w, pt) { return sigmoid(w[0] * pt.x + w[1] * pt.y + w[2]); }

function localTrain(w, data, steps) {
  const wc = [...w];
  for (let s = 0; s < steps; s++) {
    let g0 = 0, g1 = 0, g2 = 0;
    for (const pt of data) {
      const err = predict(wc, pt) - pt.label;
      g0 += err * pt.x; g1 += err * pt.y; g2 += err;
    }
    const n = data.length;
    wc[0] -= LR * g0 / n;
    wc[1] -= LR * g1 / n;
    wc[2] -= LR * g2 / n;
  }
  return wc;
}

function accuracy(w, data) {
  let ok = 0;
  for (const pt of data) { if ((predict(w, pt) >= 0.5 ? 1 : 0) === pt.label) ok++; }
  return ok / data.length;
}

// ── State ────────────────────────────────────────────────────────────────
let globalW = [0, 0, 0];
let round = 0;

function fedRound() {
  // Each device does local training from current globalW
  const localWs = DEVICES.map(data => localTrain([...globalW], data, LOCAL_STEPS));
  // FedAvg: simple mean of weights
  const n = localWs.length;
  globalW = [0, 0, 0];
  for (const w of localWs) { globalW[0] += w[0] / n; globalW[1] += w[1] / n; globalW[2] += w[2] / n; }
  round++;
  return localWs;
}

// ── Drawing ──────────────────────────────────────────────────────────────
const RED = '#e63946', BLUE = '#457b9d', LIGHT_RED = '#ffb3b8', LIGHT_BLUE = '#a8d5ea';

function drawCanvas(canvas, w, data, small) {
  const ctx = canvas.getContext('2d');
  const W = canvas.width, H = canvas.height;
  ctx.clearRect(0, 0, W, H);

  // Background: colour the half-planes using the current model
  const id = ctx.createImageData(W, H);
  for (let py = 0; py < H; py++) {
    for (let px = 0; px < W; px++) {
      const fx = px / W, fy = py / H;
      const p = predict(w, { x: fx, y: fy });
      const idx = (py * W + px) * 4;
      if (p >= 0.5) { id.data[idx]=230; id.data[idx+1]=57; id.data[idx+2]=70; id.data[idx+3]=35; }
      else          { id.data[idx]=69; id.data[idx+1]=123; id.data[idx+2]=157; id.data[idx+3]=35; }
    }
  }
  ctx.putImageData(id, 0, 0);

  // Decision boundary: find x at the middle row
  // w0*px + w1*py + w2 = 0 => draw the line
  ctx.beginPath(); ctx.strokeStyle = '#1d3557'; ctx.lineWidth = 2;
  for (let px = 0; px <= W; px++) {
    const fx = px / W;
    if (Math.abs(w[1]) > 1e-6) {
      const fy = -(w[0] * fx + w[2]) / w[1];
      const py = fy * H;
      if (px === 0) ctx.moveTo(px, py); else ctx.lineTo(px, py);
    }
  }
  ctx.stroke();

  // Points
  const r = small ? 4 : 6;
  for (const pt of data) {
    const px = pt.x * W, py = pt.y * H;
    ctx.beginPath(); ctx.arc(px, py, r, 0, 2 * Math.PI);
    ctx.fillStyle = pt.label === 1 ? RED : BLUE;
    ctx.strokeStyle = '#fff'; ctx.lineWidth = 1.5;
    ctx.fill(); ctx.stroke();
  }
}

// ── Render all ───────────────────────────────────────────────────────────
function render(localWs) {
  const devCanvases = document.querySelectorAll('.dev-canvas');
  DEVICES.forEach((data, i) => {
    const w = localWs ? localWs[i] : globalW;
    drawCanvas(devCanvases[i], w, data, true);
    const acc = accuracy(w, data);
    document.getElementById('info' + i).textContent =
      fmt('Local acc: %v%%', { v: (acc * 100).toFixed(0) });
  });

  // Global: all data
  const allData = DEVICES.flat();
  drawCanvas(document.getElementById('global-canvas'), globalW, allData, false);
  const gacc = accuracy(globalW, allData);
  document.getElementById('global-info').textContent =
    fmt('Round %round% — Global accuracy: %v%% (%length% points across all devices)', { round: round, v: (gacc * 100).toFixed(0), length: allData.length });
  document.getElementById('round-counter').textContent = fmt('Round: %round%', { round: round });
}

// ── Controls ─────────────────────────────────────────────────────────────
document.getElementById('btn-round').addEventListener('click', () => {
  const localWs = fedRound();
  render(localWs);
});
document.getElementById('btn-reset').addEventListener('click', () => {
  globalW = [0, 0, 0]; round = 0;
  render(null);
});

// Initial draw
render(null);

// Verification (node-compatible summary for test)
if (typeof module !== 'undefined') {
  module.exports = { localTrain, accuracy, fedRound: () => {
    const localWs = DEVICES.map(data => localTrain([...globalW], data, LOCAL_STEPS));
    const n = localWs.length;
    globalW = [0,0,0];
    for (const w of localWs) { globalW[0]+=w[0]/n; globalW[1]+=w[1]/n; globalW[2]+=w[2]/n; }
    round++;
    return localWs;
  }, globalW: () => globalW, round: () => round, DEVICES, sigmoid };
}

<div id="app">
  <div id="devices-row">
    <div class="device" id="dev0">
      <div class="dev-label">Device A</div>
      <canvas class="dev-canvas" width="140" height="120"></canvas>
      <div class="dev-info" id="info0">—</div>
    </div>
    <div class="device" id="dev1">
      <div class="dev-label">Device B</div>
      <canvas class="dev-canvas" width="140" height="120"></canvas>
      <div class="dev-info" id="info1">—</div>
    </div>
    <div class="device" id="dev2">
      <div class="dev-label">Device C</div>
      <canvas class="dev-canvas" width="140" height="120"></canvas>
      <div class="dev-info" id="info2">—</div>
    </div>
  </div>
  <div id="global-box">
    <div class="dev-label">Global Model (FedAvg)</div>
    <canvas id="global-canvas" width="320" height="200"></canvas>
    <div id="global-info">Round 0 — click Train one round to start.</div>
  </div>
  <div id="controls">
    <button id="btn-round">Train one round</button>
    <button id="btn-reset" class="ghost">Reset</button>
    <span id="round-counter">Round 0</span>
  </div>
</div>

* { box-sizing: border-box; margin: 0; padding: 0; }
body { font-family: system-ui, sans-serif; color: #222; background: #f8f9fa; padding: 12px; }
#app { display: flex; flex-direction: column; gap: 12px; align-items: center; }
#devices-row { display: flex; gap: 10px; flex-wrap: wrap; justify-content: center; }
.device { background: #fff; border: 1.5px solid #dde3ea; border-radius: 10px;
          padding: 8px; display: flex; flex-direction: column; align-items: center; gap: 4px;
          box-shadow: 0 1px 4px rgba(0,0,0,.07); }
.dev-label { font-size: .75rem; font-weight: 700; color: #5a7088; text-transform: uppercase; letter-spacing: .05em; }
.dev-canvas { border-radius: 6px; border: 1px solid #eee; display: block; }
.dev-info { font-size: .72rem; color: #555; min-height: 1.1em; }
#global-box { background: #fff; border: 2px solid #1d3557; border-radius: 10px;
              padding: 10px; display: flex; flex-direction: column; align-items: center; gap: 6px;
              box-shadow: 0 2px 8px rgba(29,53,87,.12); }
#global-canvas { border-radius: 6px; border: 1px solid #cdd9e3; display: block; }
#global-info { font-size: .8rem; color: #333; font-weight: 600; min-height: 1.2em; }
#controls { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; justify-content: center; }
button { font: 600 13px system-ui; padding: .4rem .85rem; border: 1.5px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
#round-counter { font-size: .8rem; color: #5a7088; font-weight: 600; }

const fmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Federated Averaging (FedAvg) simulation.
// Model: logistic regression y = sigmoid(w0*x + w1*y + b).
// 3 devices each hold a private cluster of labeled 2-D points.
// Each round: local gradient descent steps → average weights → update global model.

const sigmoid = t => 1 / (1 + Math.exp(-t));

// ── Dataset generation ───────────────────────────────────────────────────
function makeCluster(cx, cy, label, n, seed) {
  const pts = [];
  let s = seed;
  const rng = () => { s = (s * 1664525 + 1013904223) & 0xffffffff; return (s >>> 0) / 0xffffffff; };
  for (let i = 0; i < n; i++) {
    // Box-Muller
    const u = rng() || 1e-9, v = rng();
    const z0 = Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
    const z1 = Math.sqrt(-2 * Math.log(u)) * Math.sin(2 * Math.PI * v);
    pts.push({ x: cx + z0 * 0.18, y: cy + z1 * 0.18, label });
  }
  return pts;
}

// Three devices, each with two small clusters (one per class)
const DEVICES = [
  // Device A: top-left region
  [...makeCluster(0.22, 0.28, 1, 6, 7), ...makeCluster(0.38, 0.55, 0, 6, 13)],
  // Device B: centre
  [...makeCluster(0.50, 0.30, 1, 6, 31), ...makeCluster(0.62, 0.65, 0, 6, 53)],
  // Device C: bottom-right region
  [...makeCluster(0.65, 0.25, 1, 6, 71), ...makeCluster(0.78, 0.60, 0, 6, 97)],
];

// ── Model ────────────────────────────────────────────────────────────────
const LR = 0.8;   // learning rate
const LOCAL_STEPS = 8;

function predict(w, pt) { return sigmoid(w[0] * pt.x + w[1] * pt.y + w[2]); }

function localTrain(w, data, steps) {
  const wc = [...w];
  for (let s = 0; s < steps; s++) {
    let g0 = 0, g1 = 0, g2 = 0;
    for (const pt of data) {
      const err = predict(wc, pt) - pt.label;
      g0 += err * pt.x; g1 += err * pt.y; g2 += err;
    }
    const n = data.length;
    wc[0] -= LR * g0 / n;
    wc[1] -= LR * g1 / n;
    wc[2] -= LR * g2 / n;
  }
  return wc;
}

function accuracy(w, data) {
  let ok = 0;
  for (const pt of data) { if ((predict(w, pt) >= 0.5 ? 1 : 0) === pt.label) ok++; }
  return ok / data.length;
}

// ── State ────────────────────────────────────────────────────────────────
let globalW = [0, 0, 0];
let round = 0;

function fedRound() {
  // Each device does local training from current globalW
  const localWs = DEVICES.map(data => localTrain([...globalW], data, LOCAL_STEPS));
  // FedAvg: simple mean of weights
  const n = localWs.length;
  globalW = [0, 0, 0];
  for (const w of localWs) { globalW[0] += w[0] / n; globalW[1] += w[1] / n; globalW[2] += w[2] / n; }
  round++;
  return localWs;
}

// ── Drawing ──────────────────────────────────────────────────────────────
const RED = '#e63946', BLUE = '#457b9d', LIGHT_RED = '#ffb3b8', LIGHT_BLUE = '#a8d5ea';

function drawCanvas(canvas, w, data, small) {
  const ctx = canvas.getContext('2d');
  const W = canvas.width, H = canvas.height;
  ctx.clearRect(0, 0, W, H);

  // Background: colour the half-planes using the current model
  const id = ctx.createImageData(W, H);
  for (let py = 0; py < H; py++) {
    for (let px = 0; px < W; px++) {
      const fx = px / W, fy = py / H;
      const p = predict(w, { x: fx, y: fy });
      const idx = (py * W + px) * 4;
      if (p >= 0.5) { id.data[idx]=230; id.data[idx+1]=57; id.data[idx+2]=70; id.data[idx+3]=35; }
      else          { id.data[idx]=69; id.data[idx+1]=123; id.data[idx+2]=157; id.data[idx+3]=35; }
    }
  }
  ctx.putImageData(id, 0, 0);

  // Decision boundary: find x at the middle row
  // w0*px + w1*py + w2 = 0 => draw the line
  ctx.beginPath(); ctx.strokeStyle = '#1d3557'; ctx.lineWidth = 2;
  for (let px = 0; px <= W; px++) {
    const fx = px / W;
    if (Math.abs(w[1]) > 1e-6) {
      const fy = -(w[0] * fx + w[2]) / w[1];
      const py = fy * H;
      if (px === 0) ctx.moveTo(px, py); else ctx.lineTo(px, py);
    }
  }
  ctx.stroke();

  // Points
  const r = small ? 4 : 6;
  for (const pt of data) {
    const px = pt.x * W, py = pt.y * H;
    ctx.beginPath(); ctx.arc(px, py, r, 0, 2 * Math.PI);
    ctx.fillStyle = pt.label === 1 ? RED : BLUE;
    ctx.strokeStyle = '#fff'; ctx.lineWidth = 1.5;
    ctx.fill(); ctx.stroke();
  }
}

// ── Render all ───────────────────────────────────────────────────────────
function render(localWs) {
  const devCanvases = document.querySelectorAll('.dev-canvas');
  DEVICES.forEach((data, i) => {
    const w = localWs ? localWs[i] : globalW;
    drawCanvas(devCanvases[i], w, data, true);
    const acc = accuracy(w, data);
    document.getElementById('info' + i).textContent =
      fmt('Local acc: %v%%', { v: (acc * 100).toFixed(0) });
  });

  // Global: all data
  const allData = DEVICES.flat();
  drawCanvas(document.getElementById('global-canvas'), globalW, allData, false);
  const gacc = accuracy(globalW, allData);
  document.getElementById('global-info').textContent =
    fmt('Round %round% — Global accuracy: %v%% (%length% points across all devices)', { round: round, v: (gacc * 100).toFixed(0), length: allData.length });
  document.getElementById('round-counter').textContent = fmt('Round: %round%', { round: round });
}

// ── Controls ─────────────────────────────────────────────────────────────
document.getElementById('btn-round').addEventListener('click', () => {
  const localWs = fedRound();
  render(localWs);
});
document.getElementById('btn-reset').addEventListener('click', () => {
  globalW = [0, 0, 0]; round = 0;
  render(null);
});

// Initial draw
render(null);

// Verification (node-compatible summary for test)
if (typeof module !== 'undefined') {
  module.exports = { localTrain, accuracy, fedRound: () => {
    const localWs = DEVICES.map(data => localTrain([...globalW], data, LOCAL_STEPS));
    const n = localWs.length;
    globalW = [0,0,0];
    for (const w of localWs) { globalW[0]+=w[0]/n; globalW[1]+=w[1]/n; globalW[2]+=w[2]/n; }
    round++;
    return localWs;
  }, globalW: () => globalW, round: () => round, DEVICES, sigmoid };
}

Result

Console

Notice the key asymmetry: each device sees only its own cluster of points, yet after a few rounds the global boundary generalises across all three datasets. The averaging step — called FedAvg — is what makes this possible. More rounds bring the boundary closer to what you would get from pooling all data centrally, but communication cost grows with each round: that tradeoff is the heart of federated learning research.

The Real Tradeoffs

Federated learning sounds elegant, but engineering it at scale surfaces a cluster of genuinely hard problems.

Non-IID data. Devices are not random samples of the global distribution — your phone's messages look nothing like your colleague's. When local data is highly skewed (non-independent and identically distributed), local gradients point in wildly different directions, and naive averaging can hurt rather than help. Convergence guarantees that hold for uniform data often break down here.
Communication cost. A modern neural network has millions of parameters. Sending a full gradient vector every round over a cellular connection is expensive. Research therefore focuses on gradient compression, quantization, and sparse updates — sending only the most informative fraction.
Stragglers and dropouts. In a system with thousands of devices, many will be slow, offline, or on low battery. Waiting for the last device would stall training; ignoring slow devices creates a selection bias toward fast (often wealthier) users. Asynchronous and partial-participation protocols address this at the cost of added complexity.
Privacy is not automatic. Gradients leak more than you might expect. Gradient inversion attacks (Zhu et al., 2019) demonstrated that it is often possible to reconstruct the original training images from their gradients alone — a surprising result that punctured early claims that "only gradients travel the wire, so privacy is preserved." The correct solution is to add differential privacy noise to the updates before transmission, accepting a small accuracy cost in exchange for a formal privacy guarantee.
Byzantine robustness. If even one device sends maliciously crafted updates, a plain average can poison the global model. Robust aggregation rules — trimmed means, coordinate-wise medians — are provably harder to fool but also slower to converge.

Unlike P vs NP, none of these problems are provably unsolvable; they are engineering and statistical challenges. But they explain why federated learning in production requires considerably more than a simple average.

Where It Matters

Federated learning has moved from a 2017 research paper to a production technology remarkably quickly, driven by data-protection regulations and growing user expectations around privacy:

Mobile keyboards. Google's Gboard was one of the first large-scale deployments: next-word prediction models are trained across millions of Android phones, with each phone contributing gradient updates but never raw keystrokes. Apple uses similar techniques for QuickType and Siri.
Medical imaging. Hospitals cannot legally share patient scans across jurisdictions. Federated learning lets hospitals in different countries collectively train a radiology AI without any scan leaving its origin institution — a partnership that would be impossible under central-server ML.
Fraud detection. Banks share statistical patterns about fraudulent transactions without revealing customer records. A federated model trained across competing banks can detect emerging fraud patterns that no single bank's data would reveal alone.
Internet of Things. Smart factory sensors, autonomous vehicles, and wearable devices all generate data that is expensive to transmit in full. On-device training reduces bandwidth and latency while keeping proprietary operational data on-premises.
Regulatory driver. GDPR in Europe and similar laws elsewhere forbid transferring personal data across borders in many contexts. Federated learning is often the only architecture that makes a product both globally functional and legally compliant.

The common thread is data that is sensitive, large, or legally constrained — the exact situations where central aggregation is impossible but collaboration is still valuable.

Conclusion

The classic machine-learning recipe — collect everything, train centrally — was never going to survive contact with a world that cares about privacy. Federated learning inverts the recipe: move the algorithm to the data, average what you learn, discard the evidence.

The idea is simple enough to demonstrate on three toy datasets. The engineering is hard enough to occupy hundreds of researchers. And the implications — for healthcare AI, for personal devices, for globally compliant products — are large enough that federated learning has become one of the defining ideas in applied machine learning.

What remains open is the privacy guarantee. Differential privacy provides rigorous bounds, but those bounds come with an accuracy cost that practitioners often find too steep. Closing that gap — more privacy, less accuracy loss — is the active frontier. For now, federated learning is the most honest answer the field has to the question: can AI learn from your data without ever seeing it?

Comments

Loading comments...

https://www.kipuhub.com/en/article/federated-learning/Content licensed under CC BY-NC 4.0.

Cookies & privacy

How devices collaborate to train AI while keeping data private