Decentralized Training of Quantum Neural Networks

39 concepts24 papers1 proposal

Quantum Machine Learning (QML) promises extraordinary computational advantages, particularly in processing high-dimensional data and identifying complex patterns. However, modern quantum computing faces a dual bottleneck. On the hardware side, Noisy Intermediate-Scale Quantum (NISQ) devices are limited by low qubit counts and high error rates. On the data side, training powerful models requires massive, diverse datasets that are often siloed across different institutions due to strict privacy regulations.

To resolve these constraints, researchers are merging quantum computing with federated learning. This paradigm allows decentralized quantum devices to collaboratively train a shared global model without ever exchanging raw, sensitive local data. By distributing the computational workload and keeping data on-site, this approach bypasses single-processor hardware limits while inherently preserving privacy.

The Core Mechanism: Hybrid Parameter Exchange

To understand why decentralized quantum training works, we must look at how a Variational Quantum Circuit (VQC) or Quantum Neural Network (QNN) is structured. A VQC relies on quantum gates whose operations are dictated by tunable classical parameters—essentially, rotation angles ($\theta$) applied to qubits.

In a standard federated loop, the training process follows a distinct classical-quantum hybrid cycle:

  1. Local Optimization: A central server distributes a global set of variational circuit parameters to decentralized clients. Each client encodes its private, local data into quantum states and optimizes the VQC parameters on its own quantum hardware. This local optimization typically relies on the parameter-shift rule to compute gradients directly from quantum measurements.
  2. Classical Communication: Instead of transmitting fragile quantum states or raw datasets, clients send only their updated classical parameter weights back to the central server. As Chen et al. demonstrated in their foundational framework, this hybrid approach achieves classification accuracy nearly identical to centralized training methods.
  3. Global Aggregation: The central server aggregates these local updates—often using standard averaging strategies like Federated Averaging (FedAvg)—to synthesize a new global model, which is then sent back out for the next round of training.
  ┌────────────────────────────────────────────────────────┐
  │                     Central Server                     │
  │          (Aggregates Classical Parameters θ)           │
  └───────────────────────┬────────▲───────────────────────┘
                          │        │
     Distributes Global   │        │ Sends Updated Local
     Parameters (θ_glob)  │        │ Parameters (θ_local)
                          ▼        │
  ┌────────────────────────────────────────────────────────┐
  │                     Client Nodes                       │
  │  ┌──────────────────┐            ┌──────────────────┐  │
  │  │  Quantum Edge    │            │  Quantum Edge    │  │
  │  │  Device (VQC)    │            │  Device (VQC)    │  │
  │  └────────▲─────────┘            └────────▲─────────┘  │
  │           │                               │            │
  │   Private Local Data              Private Local Data   │
  └────────────────────────────────────────────────────────┘

By communicating only classical parameter updates, decentralized systems completely bypass the immense physical hurdles of secure quantum communication and the need for a mature Quantum Internet, utilizing existing classical infrastructure like 5G instead (Chehimi et al.; Innan et al.).

However, this classical aggregation strategy introduces a unique theoretical challenge. As Innan et al. point out, simply averaging the classical angles of parameterized gates may not be the optimal way to handle quantum state agglomeration. Because the mapping between gate parameters and the resulting quantum state space is highly non-linear, developing specialized, quantum-specific aggregation mechanisms remains an active frontier.

Scaling Beyond Single-Device Constraints

Why distribute quantum training if centralized quantum computers are becoming more powerful? The answer lies in modularity.

Current quantum processors cannot scale indefinitely on a single chip due to physical cross-talk and manufacturing constraints. Ismail et al. emphasize that scaling QML to handle large-scale datasets requires moving past single-processor limitations toward modular, distributed systems.

By segmenting data and circuits across multiple low-qubit machines, frameworks can execute massive QML tasks collaboratively. For example, the DQuLearn framework introduced by D'Onofrio Jr. et al. orchestrates resources in multi-tenant environments to achieve massive runtime reductions without sacrificing model accuracy. This proves that data and circuit segmentation is a robust method for scaling quantum applications.

Furthermore, empirical evidence from Sünkel et al. confirms that decentralized quantum training achieves performance parity with centralized models, meaning that data privacy can be maintained without a significant loss in predictive power compared to pooling all quantum data in a single location.

Overcoming Noise and Security Vulnerabilities

Deploying machine learning across distributed networks introduces two major vulnerabilities: hardware noise and adversarial privacy attacks.

Mitigating NISQ Noise

Quantum hardware in the NISQ era is inherently noisy, meaning environmental interference can corrupt local gradient calculations. Interestingly, collaborative quantum training shows a natural resilience to this noise. Al Zami et al. note that decentralized architectures demonstrate superior accuracy and lower loss compared to classical deep learning frameworks, suggesting that collaborative quantum training is inherently efficient at complex pattern recognition in distributed environments.

To maximize this resilience, advanced frameworks adaptively manage node updates. For instance, the sporadic learning approach (SpoQFL) dynamically scales or skips model updates from highly noisy quantum devices during aggregation. This prevents faulty local hardware from derailing global convergence, allowing quantum federated models to maintain high accuracy on complex image classification tasks even under severe hardware noise.

Cryptographic Privacy Enhancements

While federated learning prevents the direct sharing of raw data, it is still vulnerable to gradient inversion attacks, where an adversary reconstructs private data by analyzing intercepted parameter updates.

To achieve absolute privacy, researchers integrate quantum homomorphic encryption (QHE) into the federated loop. In a framework proposed by Innan, local quantum models are trained on-site, and their parameters are encrypted before being transmitted.

Similarly, the CryptoQFL framework designed by Chu et al. combines quantum homomorphic encryption with a custom quantum adder. This allows the central server to mathematically aggregate the encrypted parameters without ever decrypting them, ensuring that neither raw data nor local gradients are exposed to the central server or potential eavesdroppers.

  ┌──────────────────────────────┐
  │  Local Quantum Model Update  │
  └──────────────┬───────────────┘
                 │
                 ▼
  ┌──────────────────────────────┐
  │ Quantum Homomorphic Encr.    │ ──► Parameters transformed into encrypted states
  └──────────────┬───────────────┘
                 │
                 ▼
  ┌──────────────────────────────┐
  │  Central Server Aggregation  │ ──► Performs math directly on encrypted data;
  └──────────────────────────────┘     zero visibility into raw weights or data

The Quantum-State Communication Alternative

While exchanging classical parameters over classical networks is the most practical approach today, a parallel research direction explores exchanging actual quantum states.

If we assume the existence of a functional Quantum Internet, we can partition neural network layers across multiple distinct quantum devices. In this setup, explored by Gilboa et al., intermediate representations of data are passed between devices as quantum states (qubits) rather than classical bitstrings during the forward and backward passes.

Because quantum states can exist in superpositions, they can encode exponentially more information than classical bits. Gilboa et al. proved that this approach yields an exponential reduction in communication overhead for a generic class of distributed models. This represents the ultimate convergence of the field: utilizing quantum mechanics not just to compute locally, but to fundamentally alter how distributed nodes communicate and learn.

Key Foundational Work

Federated Quantum Machine Learning (2021) — contributed 2 concept elements to this direction.
Quantum distributed deep learning architectures: Models, discussions, and applications (2023) — contributed 1 concept elements to this direction.
CryptoQFL: Quantum Federated Learning on Encrypted Data (2023) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_quantum_federated_learning_8f53aa05,
  title = {quantum federated learning},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/quantum-federated-learning/rdr_8f53aa05c59743fc80687995d7439e66},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_quantum_federated_learning_8f53aa05_v1,
  title = {quantum federated learning},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/quantum-federated-learning/rdr_8f53aa05c59743fc80687995d7439e66/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake