↵ open · Esc close
Home/ Papers/ Quantum Diffusion Models
2023–2024 Generative Hybrid Q-C

QuDDPM & MSQuDDPM: Quantum Denoising Diffusion

Cacioppo, Bordoni et al. (QuDDPM, 2023); Various (MSQuDDPM, 2024)
QuDDPM: arXiv:2310.05866 · MSQuDDPM: arXiv:2411.17608

Contents

  1. Classical DDPM Background
  2. Quantum Forward Process
  3. Quantum Reverse Process (Score Network)
  4. Training Objective: ELBO
  5. Architecture Diagram
  6. MSQuDDPM: Multi-Scale Extension
  7. Hardware Considerations

1. Classical DDPM Background

Denoising Diffusion Probabilistic Models (Ho et al. 2020) learn to generate data by reversing a fixed Markov chain that gradually adds Gaussian noise to data.

Forward Process

$$q(\mathbf{x}_t | \mathbf{x}_{t-1}) = \mathcal{N}\!\left(\mathbf{x}_t;\, \sqrt{1-\beta_t}\,\mathbf{x}_{t-1},\, \beta_t \mathbf{I}\right)$$
Eq. (1) — Forward process: Gaussian noise addition at step $t$

Using the reparameterisation $\bar{\alpha}_t = \prod_{s=1}^{t}(1-\beta_s)$, sampling at any step $t$ directly:

$$q(\mathbf{x}_t | \mathbf{x}_0) = \mathcal{N}\!\left(\mathbf{x}_t;\, \sqrt{\bar{\alpha}_t}\,\mathbf{x}_0,\, (1-\bar{\alpha}_t)\mathbf{I}\right)$$
Eq. (2) — Marginal forward distribution (closed form)

Reverse Process

$$p_\theta(\mathbf{x}_{t-1}|\mathbf{x}_t) = \mathcal{N}\!\left(\mathbf{x}_{t-1};\, \mu_\theta(\mathbf{x}_t, t),\, \sigma_t^2 \mathbf{I}\right)$$
Eq. (3) — Reverse process parameterised by neural network $\mu_\theta$

2. Quantum Forward Process

QuDDPM replaces the classical Gaussian noise addition with a quantum channel. The natural quantum analogue of Gaussian noise is the depolarising channel:

$$\mathcal{E}_t(\rho) = (1-p_t)\rho + p_t \cdot \frac{\mathbf{I}}{2^n}$$
Eq. (4) — Depolarising channel: mixes state $\rho$ toward maximally mixed state $\mathbf{I}/2^n$

For the full $T$-step forward process:

$$\rho_t = \bar{p}_t \cdot \rho_0 + (1-\bar{p}_t) \cdot \frac{\mathbf{I}}{2^n}$$
Eq. (5) — Marginal quantum forward process; $\bar{p}_t = \prod_{s=1}^t(1-p_s)$

At $t=T$, $\bar{p}_T \approx 0$, so $\rho_T \approx \mathbf{I}/2^n$ — the maximally mixed (quantum "noise") state.

Key insight: Decoherence is quantum hardware's natural noise process. QuDDPM proposes that the quantum device's inherent decoherence implements the forward process for free — no explicit noise injection needed.

3. Quantum Reverse Process (Score Network)

The classical score network (U-Net) $\boldsymbol{\epsilon}_\theta(\mathbf{x}_t, t)$ is replaced by a parameterised quantum circuit (PQC) that takes the noisy quantum state $\rho_t$ and outputs a denoising direction.

Quantum Score Network

$$\hat{\boldsymbol{\epsilon}}_{\boldsymbol{\theta}}(\rho_t, t) = \left\langle O_j \right\rangle_{\rho_t^{\prime}} = \text{Tr}\!\left[O_j\, U_t(\boldsymbol{\theta})\,\rho_t\, U_t^\dagger(\boldsymbol{\theta})\right]_{j=1}^{d}$$
Eq. (6) — Quantum score: expectation values of observables $O_j$ on processed state

The reverse step denoises using the predicted noise:

$$\mathbf{x}_{t-1} = \frac{1}{\sqrt{\alpha_t}}\!\left(\mathbf{x}_t - \frac{1-\alpha_t}{\sqrt{1-\bar{\alpha}_t}}\,\hat{\boldsymbol{\epsilon}}_{\boldsymbol{\theta}}(\mathbf{x}_t, t)\right) + \sigma_t \mathbf{z}$$
Eq. (7) — DDPM reverse sampling step ($\mathbf{z} \sim \mathcal{N}(0,\mathbf{I})$)

Parameterised Quantum Circuit for Denoising

Input: noisy state ρ_t (quantum or classically encoded)
       │
       ▼  [Time embedding: t → angle shift]
 Encode timestep t into rotation angles: φ(t) ∈ ℝᵐ
       │
       ▼  [Data encoding layer]
 |0⟩──[Ry(x_t1)]──[Ry(x_t2)]──...──[Ry(x_tn)]
       │
       ▼  [L variational layers (data re-uploading)]
 ─────[Ry(θ₁+φ(t))]──[CNOT]──[Ry(θ₂+φ(t))]──[CNOT]──...
                         │
       (entangling + parameterised rotations, t-conditioned)
                         │
       ▼  [Measurement: expectation values of Pauli operators]
 ε̂ = (⟨Z₁⟩, ⟨Z₂⟩, ..., ⟨Zₙ⟩, ⟨Z₁Z₂⟩, ...)  ∈ ℝᵈ
       │
       ▼  [Classical post-processing: reverse step formula]
 x_{t-1} = (x_t - coeff × ε̂) / √α_t  +  σ_t z

4. Training Objective: Quantum ELBO

The classical DDPM training simplifies the ELBO to a denoising score matching objective:

$$\mathcal{L}_{\text{simple}} = \mathbb{E}_{t, \mathbf{x}_0, \boldsymbol{\epsilon}}\!\left[\left\|\boldsymbol{\epsilon} - \hat{\boldsymbol{\epsilon}}_{\boldsymbol{\theta}}(\mathbf{x}_t, t)\right\|^2\right]$$
Eq. (8) — Simple denoising objective (Ho et al. 2020)

For the quantum version, gradients are computed via the parameter-shift rule:

$$\frac{\partial \mathcal{L}}{\partial \theta_k} = \frac{1}{2}\!\left[\mathcal{L}\!\left(\theta_k + \frac{\pi}{2}\right) - \mathcal{L}\!\left(\theta_k - \frac{\pi}{2}\right)\right]$$
Eq. (9) — Quantum parameter-shift rule for gradient computation
Training challenge: Each gradient evaluation requires $2K$ circuit executions (where $K$ = number of parameters). For a batch of $B$ samples and $T$ timesteps, total shots per update: $O(B \cdot T \cdot K / \epsilon^2)$ — shot-intensive on current hardware.

5. Full QuDDPM Architecture

TRAINING                          GENERATION
════════                          ══════════

Real data x₀                     Sample xᵀ ~ N(0, I)
     │                                 │
     │ Forward process (fixed)         │ Reverse process (learned)
     │                                 │
     ▼                                 ▼
  t ~ Uniform[1,T]             For t = T, T-1, ..., 1:
     │                           │
     ▼                           ▼
  ε ~ N(0, I)               [Quantum Score Network]
     │                       VQC(θ, x_t, t) → ε̂_θ(x_t, t)
     ▼                           │
  x_t = √ᾱ_t x₀ + √(1-ᾱ_t)ε   ▼
     │                      x_{t-1} = (x_t - coeff·ε̂)/√α_t + σ_t·z
     │                           │
     ▼                           ▼
  ε̂ = VQC(θ, x_t, t)       x₀ ≈ x_0  (generated sample)
     │
     ▼
  Loss: ||ε - ε̂||²
     │
     ▼
  Update θ via parameter-shift
     gradient + Adam/SPSA

┌─────────────────────────────────────────────────────────────────────┐
│  VQC ARCHITECTURE (Score Network)                                    │
│                                                                      │
│  n qubits: ─[Enc(x_t)]─┬──[L₁(θ,t)]──[Ent]──[L₂(θ,t)]──[Meas]─   │
│                         │                                            │
│  Time conditioning:  φ(t) = [sin(t/T), cos(t/T), sin(2t/T), ...]   │
│  Rotation: Rᵧ(θₖ + φ(t)ₖ) — learnable + time-shifted               │
│  Entangling: linear CNOT chain or all-to-all (hardware dependent)   │
│  Output: ⟨Zⱼ⟩ for j=1..n → score vector ε̂ ∈ ℝⁿ                   │
└─────────────────────────────────────────────────────────────────────┘

6. MSQuDDPM: Multi-Scale Extension

MSQuDDPM extends QuDDPM with a multi-resolution diffusion process, addressing the challenge that small qubit counts limit the dimensionality of the generated signal.

Multi-Scale Decomposition

$$\mathbf{x} = \sum_{s=1}^{S} \mathbf{x}^{(s)}, \quad \mathbf{x}^{(s)} = \mathcal{P}_s(\mathbf{x})$$
Eq. (10) — Multi-scale decomposition into $S$ resolution levels via projection $\mathcal{P}_s$

Each scale $s$ gets its own VQC diffusion model:

$$\hat{\boldsymbol{\epsilon}}_{\boldsymbol{\theta}}^{(s)}(\mathbf{x}_t^{(s)}, t)$$
Eq. (11) — Per-scale quantum score network
MSQuDDPM Hierarchy:

Scale 1 (coarse, few qubits):
  x⁽¹⁾ = Proj₁(x)  →  VQC₁(θ₁)  →  ε̂⁽¹⁾
         ↕ condition
Scale 2 (medium):
  x⁽²⁾ = Proj₂(x)  →  VQC₂(θ₂, x⁽¹⁾)  →  ε̂⁽²⁾
         ↕ condition
Scale 3 (fine):
  x⁽³⁾ = Proj₃(x)  →  VQC₃(θ₃, x⁽¹⁾, x⁽²⁾)  →  ε̂⁽³⁾

Generation: sample coarse scale first, condition finer scales
on coarse outputs → coarse-to-fine generation.

7. Hardware Considerations

✓ Advantages

Decoherence = free forward process on quantum hardware. Shot-efficient for low-dimensional data. VQC is shallow (compatible with NISQ).

✗ Challenges

Limited qubit count restricts data dimensionality. $O(2K)$ shots per gradient step is expensive. Readout noise adds variance to score estimate.

Near-term target: QuDDPM demonstrated on low-dimensional scientific data (particle physics, financial time series) where $n \leq 12$ qubits suffice. Extension to high-dimensional image generation requires fault-tolerant hardware and QRAM.

Related Papers

Vision
QViT — Quantum Vision Transformers
Quantum generative meets quantum discriminative
Theory
Barren Plateaus & DLA
Why training the VQC score network is hard