Quantum Generative Models

Quantum Generative Models

Quantum generative models use quantum circuits to learn and generate probability distributions:

The model is trained to match a target distribution .

Advantages: quantum circuits can represent distributions that are exponentially hard for classical models.

Quantum Born Machines

A quantum Born machine generates samples from a probability distribution defined by a quantum state:

1. Prepare a parameterized quantum state
2. Measure in the computational basis
3. The outcome distribution

Training minimizes the KL divergence:

or the Jensen-Shannon divergence for better training stability.

Quantum GANs

Quantum Generative Adversarial Networks use a quantum generator and (classical or quantum) discriminator:

Generator: quantum circuit that produces quantum states Discriminator: classical or quantum network that distinguishes real from fake

The training game:

• Generator tries to fool discriminator
• Discriminator tries to correctly classify
• Nash equilibrium: generator produces perfect samples

Quantum GANs can generate distributions that are hard for classical GANs.

Training Challenges

Training quantum generative models faces:

1. Barren plateaus: gradients vanish exponentially
2. Shot noise: finite sampling introduces noise
3. Mode collapse: generator produces limited diversity
4. Classical simulation: hard to evaluate quantum distributions classically

Solutions: local cost functions, layerwise training, noise-aware optimization.

Applications

Quantum generative models for:

1. Quantum chemistry: generate molecular configurations
2. Materials science: learn material properties
3. Drug discovery: generate molecular structures
4. Financial modeling: sample market scenarios
5. Data augmentation: generate synthetic quantum data

Python: Quantum Born Machine

import numpy as np

def quantum_born_machine(params, n_samples=1000):
    # Simplified quantum Born machine.
    theta = params[0]
    # Probability distribution: p(0) = cos^2(theta), p(1) = sin^2(theta)
    p0 = np.cos(theta)**2
    p1 = np.sin(theta)**2
    # Sample
    samples = np.random.choice([0, 1], size=n_samples, p=[p0, p1])
    return samples, p0, p1

def js_divergence(p_data, p_model):
    # Jensen-Shannon divergence.
    m = 0.5 * (p_data + p_model)
    if p_data == 0 or m == 0: kl1 = 0
    else: kl1 = p_data * np.log(p_data / m)
    if p_model == 0 or m == 0: kl2 = 0
    else: kl2 = p_model * np.log(p_model / m)
    return 0.5 * (kl1 + kl2)

# Target: p(0)=0.7, p(1)=0.3
p_target = 0.7
from scipy.optimize import minimize
def loss(theta):
    _, p0, p1 = quantum_born_machine(theta, 100)
    return js_divergence(p_target, p0)

result = minimize(loss, [0.5], method='COBYLA')
print(f"Target p(0): {p_target:.4f}")
print(f"Learned p(0): {np.cos(result.x[0])**2:.4f}")

Quantum GAN Architecture

The quantum GAN consists:

1. Generator: quantum circuit produces quantum states
2. Discriminator: classical or quantum network classifies real/fake
3. Training: adversarial game between G and D

The loss function:

Born Machine vs GAN