Struct ParticleGAN 

pub struct ParticleGAN {
    pub gan: QuantumGAN,
    pub physics_params: PhysicsParameters,
}

GAN model specialized for particle physics simulations

Fields

gan: QuantumGAN

The core quantum GAN implementation

physics_params: PhysicsParameters

Specialized parameters for physics simulations

Implementations

impl ParticleGAN

pub fn new( num_qubits_gen: usize, num_qubits_disc: usize, latent_dim: usize, data_dim: usize, ) -> Result<Self>

Creates a new particle physics GAN

Examples found in repository

examples/quantum_gan.rs (lines 108-113)

fn main() -> Result<()> {
    println!("Quantum Generative Adversarial Network Example");
    println!("=============================================");

    // GAN parameters
    let num_qubits_gen = 6;
    let num_qubits_disc = 6;
    let latent_dim = 4;
    let data_dim = 8;

    println!("Creating Quantum GAN...");
    println!("  Generator: {num_qubits_gen} qubits");
    println!("  Discriminator: {num_qubits_disc} qubits");
    println!("  Latent dimension: {latent_dim}");
    println!("  Data dimension: {data_dim}");

    // Create quantum GAN
    let mut qgan = QuantumGAN::new(
        num_qubits_gen,
        num_qubits_disc,
        latent_dim,
        data_dim,
        GeneratorType::HybridClassicalQuantum,
        DiscriminatorType::HybridQuantumFeatures,
    )?;

    // Generate synthetic data for training
    println!("Generating synthetic data for training...");
    let real_data = generate_sine_wave_data(500, data_dim);

    // Train GAN
    println!("Training quantum GAN...");
    let training_params = [
        (50, 32, 0.01, 0.01, 1), // (epochs, batch_size, lr_gen, lr_disc, disc_steps)
    ];

    for (epochs, batch_size, lr_gen, lr_disc, disc_steps) in training_params {
        println!("Training with parameters:");
        println!("  Epochs: {epochs}");
        println!("  Batch size: {batch_size}");
        println!("  Generator learning rate: {lr_gen}");
        println!("  Discriminator learning rate: {lr_disc}");
        println!("  Discriminator steps per iteration: {disc_steps}");

        let start = Instant::now();
        let history = qgan.train(&real_data, epochs, batch_size, lr_gen, lr_disc, disc_steps)?;

        println!("Training completed in {:.2?}", start.elapsed());
        println!("Final losses:");
        println!(
            "  Generator: {:.4}",
            history.gen_losses.last().unwrap_or(&0.0)
        );
        println!(
            "  Discriminator: {:.4}",
            history.disc_losses.last().unwrap_or(&0.0)
        );
    }

    // Generate samples
    println!("\nGenerating samples from trained GAN...");
    let num_samples = 10;
    let generated_samples = qgan.generate(num_samples)?;

    println!("Generated {num_samples} samples");
    println!("First sample:");
    print_sample(
        &generated_samples
            .slice(scirs2_core::ndarray::s![0, ..])
            .to_owned(),
    );

    // Evaluate GAN
    println!("\nEvaluating GAN quality...");
    let eval_metrics = qgan.evaluate(&real_data, num_samples)?;

    println!("Evaluation metrics:");
    println!(
        "  Real data accuracy: {:.2}%",
        eval_metrics.real_accuracy * 100.0
    );
    println!(
        "  Fake data accuracy: {:.2}%",
        eval_metrics.fake_accuracy * 100.0
    );
    println!(
        "  Overall discriminator accuracy: {:.2}%",
        eval_metrics.overall_accuracy * 100.0
    );
    println!("  JS Divergence: {:.4}", eval_metrics.js_divergence);

    // Use physics-specific GAN
    println!("\nCreating specialized particle physics GAN...");
    let particle_gan = quantrs2_ml::gan::physics_gan::ParticleGAN::new(
        num_qubits_gen,
        num_qubits_disc,
        latent_dim,
        data_dim,
    )?;

    println!("Particle GAN created successfully");

    Ok(())
}

pub fn train( &mut self, particle_data: &Array2<f64>, epochs: usize, ) -> Result<&GANTrainingHistory>

Trains the particle GAN on real particle data

pub fn generate_particles(&self, num_particles: usize) -> Result<Array2<f64>>

Generates simulated particle data