Quantum ML

Quantum Generative Adversarial Network

qGAN for learning probability distributions

Quantum Generative Adversarial Networks combine a quantum generator, which prepares a data distribution as a quantum state, with a classical discriminator that distinguishes real from fake samples. This hybrid architecture can learn probability distributions with fewer parameters than fully classical GANs.

Architecture of qGANs

Generative Adversarial Networks consist of two competing neural networks: a generator G that learns to produce realistic samples from a latent noise distribution, and a discriminator D that learns to classify samples as real or fake. In the quantum variant, the generator is replaced by a parameterized quantum circuit that transforms a simple input state into a complex output distribution over measurement outcomes.

The quantum generator operates by applying a sequence of single-qubit rotations and entangling gates controlled by classical parameters θ. When measured in the computational basis, the resulting bitstrings are interpreted as samples from the learned distribution. Because n qubits can encode 2ⁿ amplitudes, the quantum generator has the potential to represent exponentially rich distributions using only polynomially many parameters.

The discriminator remains classical and is typically implemented as a small feed-forward neural network. It receives either a real data sample or a measurement outcome from the quantum generator and outputs a probability that the sample is authentic. The two networks are trained adversarially: the generator tries to fool the discriminator, while the discriminator tries to avoid being fooled.

|\psi(\theta)\rangle = U_G(\theta) |0\rangle^{\otimes n}

Generator output state

P_{\theta}(x) = |\langle x | \psi(\theta) \rangle|^2

Measurement probability

\min_{\theta} \max_{\phi} \mathbb{E}_{x \sim p_{data}}[\log D_{\phi}(x)] + \mathbb{E}_{z \sim p_z}[\log(1 - D_{\phi}(G_{\theta}(z)))]

Minimax objective

•Quantum Generator: A parameterized circuit U_G(θ) that maps a product state |0⟩⊗n to a complex superposition whose measurement statistics approximate the target distribution.
•Classical Discriminator: A neural network D(x) ∈ [0, 1] that estimates the probability that a given sample x came from the real dataset rather than the generator.
•Adversarial Objective: The generator minimizes log(1 - D(G(z))), while the discriminator maximizes log D(x) + log(1 - D(G(z))), creating a two-player zero-sum game.
•Load-Bearing Entanglement: Multi-qubit entangling gates in the generator allow the model to capture correlations that would require deep classical networks with many more parameters.

Training Dynamics and Convergence

Training a qGAN requires careful balancing of the generator and discriminator update steps. If the discriminator becomes too powerful too early, the generator receives vanishing gradients and ceases to learn. Conversely, if the generator outpaces the discriminator, the discriminator's feedback becomes uninformative.

In practice, one alternates between classical backpropagation through the discriminator and parameter-shift rule-based gradient estimation on the quantum generator. The parameter-shift rule allows exact computation of gradients for gate rotations on quantum hardware by evaluating the circuit at two shifted parameter values. This avoids the high variance associated with finite-difference methods.

Convergence of qGANs is an active research topic. Unlike classical GANs, where the global optimum corresponds to the generator perfectly replicating the data distribution, quantum generators are constrained by the expressivity of the chosen circuit ansatz. Recent work has shown that qGANs can achieve competitive performance on financial loading and image-generation benchmarks, particularly when the target distribution has low effective dimensionality.

\frac{\partial \langle O \rangle}{\partial \theta} = \frac{\langle O \rangle_{\theta + s} - \langle O \rangle_{\theta - s}}{2 \sin s}

Parameter-shift gradient

\mathcal{L}_G(\theta) = -\mathbb{E}_{z \sim p_z}[\log D_{\phi}(G_{\theta}(z))]

Generator loss

•Parameter-Shift Rule: For a rotation gate R(θ), the derivative ∂⟨O⟩/∂θ equals (⟨O⟩_{θ+s} - ⟨O⟩_{θ-s}) / (2 sin(s)), enabling exact gradient estimation.
•Barren Plateaus: Deep, unstructured quantum generators suffer from exponentially vanishing gradients, motivating the use of problem-inspired or hardware-efficient ansätze.
•Data Loading: qGANs have been successfully applied to loading financial probability distributions into quantum states for use in option pricing and risk analysis.
•Benchmarking: Relative entropy between the generated and target distributions is a common metric for assessing qGAN performance independent of the discriminator.

Code in Action

Runnable implementations you can copy and experiment with.

Qiskit qGAN Generator Circuit

This Qiskit example constructs a simple parameterized quantum generator circuit, runs it on a simulator, and prints the sampled probability distribution over computational basis states.

quantum_gan_qiskit.py

from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
import numpy as np

n_qubits = 3
shots = 8192

def generator_circuit(params):
    qc = QuantumCircuit(n_qubits)
    for i in range(n_qubits):
        qc.ry(params[i], i)
    for i in range(n_qubits - 1):
        qc.cx(i, i + 1)
    qc.measure_all()
    return qc

params = np.random.rand(n_qubits) * 2 * np.pi
qc = generator_circuit(params)

simulator = AerSimulator()
job = simulator.run(transpile(qc, simulator), shots=shots)
counts = job.result().get_counts()

probs = {k: v / shots for k, v in counts.items()}
print("Generated distribution:", probs)

PennyLane Quantum Generator

This PennyLane example defines a quantum generator as a QNode. The circuit applies RY rotations followed by CNOT entanglement, returning the full probability distribution over measurement outcomes.

quantum_gan_pennylane.py

import pennylane as qml
import pennylane.numpy as np

n_qubits = 3
dev = qml.device("default.qubit", wires=n_qubits)

@qml.qnode(dev)
def generator(params, noise):
    for i in range(n_qubits):
        qml.RY(noise[i] * np.pi, wires=i)
    for i in range(n_qubits):
        qml.RY(params[i], wires=i)
    for i in range(n_qubits - 1):
        qml.CNOT(wires=[i, i + 1])
    return qml.probs(wires=range(n_qubits))

params = np.random.rand(n_qubits, requires_grad=True)
noise = np.random.rand(n_qubits)
probs = generator(params, noise)
print("Learned distribution:", probs)

Explore next

Quantum PCA

Explore next

Variational Quantum Eigensolver

from qiskit import QuantumCircuit, transpile from qiskit_aer import AerSimulator import numpy as np n_qubits = 3 shots = 8192 def generator_circuit(params): qc = QuantumCircuit(n_qubits) for i in range(n_qubits): qc.ry(params[i], i) for i in range(n_qubits - 1): qc.cx(i, i + 1) qc.measure_all() return qc params = np.random.rand(n_qubits) * 2 * np.pi qc = generator_circuit(params) simulator = AerSimulator() job = simulator.run(transpile(qc, simulator), shots=shots) counts = job.result().get_counts() probs = {k: v / shots for k, v in counts.items()} print("Generated distribution:", probs)

import pennylane as qml import pennylane.numpy as np n_qubits = 3 dev = qml.device("default.qubit", wires=n_qubits) @qml.qnode(dev) def generator(params, noise): for i in range(n_qubits): qml.RY(noise[i] * np.pi, wires=i) for i in range(n_qubits): qml.RY(params[i], wires=i) for i in range(n_qubits - 1): qml.CNOT(wires=[i, i + 1]) return qml.probs(wires=range(n_qubits)) params = np.random.rand(n_qubits, requires_grad=True) noise = np.random.rand(n_qubits) probs = generator(params, noise) print("Learned distribution:", probs)