quantrs2_ml/

gan.rs

//! Quantum Generative Adversarial Networks (qGANs).
//!
//! Provides hybrid classical-quantum and fully-quantum GAN architectures.
//! The generator and discriminator can each be classical networks, quantum
//! circuits, or hybrid combinations, trained via adversarial min-max optimisation.

use crate::error::{MLError, Result};
use crate::qnn::QuantumNeuralNetwork;
use quantrs2_circuit::prelude::Circuit;
use quantrs2_sim::statevector::StateVectorSimulator;
use scirs2_core::ndarray::{Array1, Array2};
use scirs2_core::random::prelude::*;
use std::fmt;

/// Type of generator to use in a quantum GAN
#[derive(Debug, Clone, Copy)]
pub enum GeneratorType {
    /// Pure classical generator
    Classical,

    /// Pure quantum generator
    QuantumOnly,

    /// Hybrid classical-quantum generator
    HybridClassicalQuantum,
}

/// Type of discriminator to use in a quantum GAN
#[derive(Debug, Clone, Copy)]
pub enum DiscriminatorType {
    /// Pure classical discriminator
    Classical,

    /// Pure quantum discriminator
    QuantumOnly,

    /// Hybrid with quantum feature extraction
    HybridQuantumFeatures,

    /// Hybrid with quantum decision function
    HybridQuantumDecision,
}

/// Training metrics for a GAN
#[derive(Debug, Clone)]
pub struct GANTrainingHistory {
    /// Generator loss at each epoch
    pub gen_losses: Vec<f64>,

    /// Discriminator loss at each epoch
    pub disc_losses: Vec<f64>,
}

/// Evaluation metrics for a GAN
#[derive(Debug, Clone)]
pub struct GANEvaluationMetrics {
    /// Accuracy of discriminator on real data
    pub real_accuracy: f64,

    /// Accuracy of discriminator on fake (generated) data
    pub fake_accuracy: f64,

    /// Overall discriminator accuracy
    pub overall_accuracy: f64,

    /// Jensen-Shannon divergence between real and generated distributions
    pub js_divergence: f64,
}

/// Trait for generator models
pub trait Generator {
    /// Generates samples from the latent space
    fn generate(&self, num_samples: usize) -> Result<Array2<f64>>;

    /// Generates samples with specific conditions
    fn generate_conditional(
        &self,
        num_samples: usize,
        conditions: &[(usize, f64)],
    ) -> Result<Array2<f64>>;

    /// Updates the generator based on discriminator feedback
    fn update(
        &mut self,
        latent_vectors: &Array2<f64>,
        discriminator_outputs: &Array1<f64>,
        learning_rate: f64,
    ) -> Result<f64>;
}

/// Trait for discriminator models
pub trait Discriminator {
    /// Discriminates between real and generated samples
    fn discriminate(&self, samples: &Array2<f64>) -> Result<Array1<f64>>;

    /// Predicts probabilities for a batch of samples
    fn predict_batch(&self, samples: &Array2<f64>) -> Result<Array1<f64>> {
        self.discriminate(samples)
    }

    /// Updates the discriminator based on real and generated samples
    fn update(
        &mut self,
        real_samples: &Array2<f64>,
        generated_samples: &Array2<f64>,
        learning_rate: f64,
    ) -> Result<f64>;
}

/// Physics-specific GAN implementations for particle physics simulations
pub mod physics_gan {
    use super::*;

    /// GAN model specialized for particle physics simulations
    pub struct ParticleGAN {
        /// The core quantum GAN implementation
        pub gan: QuantumGAN,

        /// Specialized parameters for physics simulations
        pub physics_params: PhysicsParameters,
    }

    /// Physics-specific parameters for the GAN
    #[derive(Debug, Clone)]
    pub struct PhysicsParameters {
        /// Energy scale for particle simulation
        pub energy_scale: f64,

        /// Momentum conservation factor
        pub momentum_conservation: f64,

        /// Whether to include quantum effects
        pub quantum_effects: bool,
    }

    impl ParticleGAN {
        /// Creates a new particle physics GAN
        pub fn new(
            num_qubits_gen: usize,
            num_qubits_disc: usize,
            latent_dim: usize,
            data_dim: usize,
        ) -> Result<Self> {
            // Create a standard quantum GAN
            let gan = QuantumGAN::new(
                num_qubits_gen,
                num_qubits_disc,
                latent_dim,
                data_dim,
                GeneratorType::HybridClassicalQuantum,
                DiscriminatorType::HybridQuantumFeatures,
            )?;

            // Default physics parameters
            let physics_params = PhysicsParameters {
                energy_scale: 100.0, // GeV
                momentum_conservation: 0.99,
                quantum_effects: true,
            };

            Ok(ParticleGAN {
                gan,
                physics_params,
            })
        }

        /// Trains the particle GAN on real particle data
        pub fn train(
            &mut self,
            particle_data: &Array2<f64>,
            epochs: usize,
        ) -> Result<&GANTrainingHistory> {
            // Use the underlying GAN's training method
            self.gan.train(
                particle_data,
                epochs,
                32,   // batch size
                0.01, // generator learning rate
                0.01, // discriminator learning rate
                1,    // discriminator steps
            )
        }

        /// Generates simulated particle data
        pub fn generate_particles(&self, num_particles: usize) -> Result<Array2<f64>> {
            // Extends basic generation with physics constraints
            let raw_data = self.gan.generate(num_particles)?;

            // In a full implementation, we would apply physics constraints here
            // such as momentum conservation, charge conservation, etc.

            Ok(raw_data)
        }
    }
}

/// Quantum Generator for GAN
#[derive(Debug, Clone)]
pub struct QuantumGenerator {
    /// Number of qubits
    num_qubits: usize,

    /// Dimension of latent space
    latent_dim: usize,

    /// Dimension of output data
    data_dim: usize,

    /// Type of generator
    generator_type: GeneratorType,

    /// Quantum neural network for generation
    qnn: QuantumNeuralNetwork,
}

impl QuantumGenerator {
    /// Creates a new quantum generator
    pub fn new(
        num_qubits: usize,
        latent_dim: usize,
        data_dim: usize,
        generator_type: GeneratorType,
    ) -> Result<Self> {
        // Create a QNN architecture suitable for generation
        let layers = vec![
            crate::qnn::QNNLayerType::EncodingLayer {
                num_features: latent_dim,
            },
            crate::qnn::QNNLayerType::VariationalLayer {
                num_params: 2 * num_qubits,
            },
            crate::qnn::QNNLayerType::EntanglementLayer {
                connectivity: "full".to_string(),
            },
            crate::qnn::QNNLayerType::VariationalLayer {
                num_params: 2 * num_qubits,
            },
            crate::qnn::QNNLayerType::MeasurementLayer {
                measurement_basis: "computational".to_string(),
            },
        ];

        let qnn = QuantumNeuralNetwork::new(layers, num_qubits, latent_dim, data_dim)?;

        Ok(QuantumGenerator {
            num_qubits,
            latent_dim,
            data_dim,
            generator_type,
            qnn,
        })
    }
}

impl Generator for QuantumGenerator {
    fn generate(&self, num_samples: usize) -> Result<Array2<f64>> {
        // Generate random latent vectors
        let mut latent_vectors = Array2::zeros((num_samples, self.latent_dim));
        for i in 0..num_samples {
            for j in 0..self.latent_dim {
                latent_vectors[[i, j]] = thread_rng().random::<f64>() * 2.0 - 1.0;
            }
        }

        // Generate samples from latent vectors
        // In a real implementation, this would use the QNN to generate samples
        let mut samples = Array2::zeros((num_samples, self.data_dim));
        for i in 0..num_samples {
            for j in 0..self.data_dim {
                // Simple dummy implementation
                let latent_sum = latent_vectors.row(i).sum();
                samples[[i, j]] = (latent_sum + (j as f64) * 0.1).sin() * 0.5 + 0.5;
            }
        }

        Ok(samples)
    }

    fn generate_conditional(
        &self,
        num_samples: usize,
        conditions: &[(usize, f64)],
    ) -> Result<Array2<f64>> {
        // Generate samples
        let mut samples = self.generate(num_samples)?;

        // Apply conditions
        for &(feature_idx, value) in conditions {
            if feature_idx < self.data_dim {
                for i in 0..num_samples {
                    samples[[i, feature_idx]] = value;
                }
            }
        }

        Ok(samples)
    }

    fn update(
        &mut self,
        _latent_vectors: &Array2<f64>,
        _discriminator_outputs: &Array1<f64>,
        _learning_rate: f64,
    ) -> Result<f64> {
        // Dummy implementation
        Ok(0.5)
    }
}

/// Quantum Discriminator for GAN
#[derive(Debug, Clone)]
pub struct QuantumDiscriminator {
    /// Number of qubits
    num_qubits: usize,

    /// Dimension of input data
    data_dim: usize,

    /// Type of discriminator
    discriminator_type: DiscriminatorType,

    /// Quantum neural network for discrimination
    qnn: QuantumNeuralNetwork,
}

impl QuantumDiscriminator {
    /// Creates a new quantum discriminator
    pub fn new(
        num_qubits: usize,
        data_dim: usize,
        discriminator_type: DiscriminatorType,
    ) -> Result<Self> {
        // Create a QNN architecture suitable for discrimination
        let layers = vec![
            crate::qnn::QNNLayerType::EncodingLayer {
                num_features: data_dim,
            },
            crate::qnn::QNNLayerType::VariationalLayer {
                num_params: 2 * num_qubits,
            },
            crate::qnn::QNNLayerType::EntanglementLayer {
                connectivity: "full".to_string(),
            },
            crate::qnn::QNNLayerType::VariationalLayer {
                num_params: 2 * num_qubits,
            },
            crate::qnn::QNNLayerType::MeasurementLayer {
                measurement_basis: "computational".to_string(),
            },
        ];

        let qnn = QuantumNeuralNetwork::new(
            layers, num_qubits, data_dim, 1, // Binary output (real or fake)
        )?;

        Ok(QuantumDiscriminator {
            num_qubits,
            data_dim,
            discriminator_type,
            qnn,
        })
    }
}

impl Discriminator for QuantumDiscriminator {
    fn discriminate(&self, samples: &Array2<f64>) -> Result<Array1<f64>> {
        // This is a dummy implementation
        // In a real system, this would use the QNN to discriminate

        let num_samples = samples.nrows();
        let mut outputs = Array1::zeros(num_samples);

        for i in 0..num_samples {
            // Simple dummy calculation
            let sum = samples.row(i).sum();
            outputs[i] = (sum * 0.1).sin() * 0.5 + 0.5;
        }

        Ok(outputs)
    }

    fn update(
        &mut self,
        _real_samples: &Array2<f64>,
        _generated_samples: &Array2<f64>,
        _learning_rate: f64,
    ) -> Result<f64> {
        // Dummy implementation
        Ok(0.5)
    }
}

/// Quantum Generative Adversarial Network
#[derive(Debug, Clone)]
pub struct QuantumGAN {
    /// Generator model
    pub generator: QuantumGenerator,

    /// Discriminator model
    pub discriminator: QuantumDiscriminator,

    /// Training history
    pub training_history: GANTrainingHistory,
}

impl QuantumGAN {
    /// Creates a new quantum GAN
    pub fn new(
        num_qubits_gen: usize,
        num_qubits_disc: usize,
        latent_dim: usize,
        data_dim: usize,
        generator_type: GeneratorType,
        discriminator_type: DiscriminatorType,
    ) -> Result<Self> {
        let generator =
            QuantumGenerator::new(num_qubits_gen, latent_dim, data_dim, generator_type)?;

        let discriminator =
            QuantumDiscriminator::new(num_qubits_disc, data_dim, discriminator_type)?;

        let training_history = GANTrainingHistory {
            gen_losses: Vec::new(),
            disc_losses: Vec::new(),
        };

        Ok(QuantumGAN {
            generator,
            discriminator,
            training_history,
        })
    }

    /// Trains the GAN on a dataset
    pub fn train(
        &mut self,
        real_data: &Array2<f64>,
        epochs: usize,
        batch_size: usize,
        gen_learning_rate: f64,
        disc_learning_rate: f64,
        disc_steps: usize,
    ) -> Result<&GANTrainingHistory> {
        let mut gen_losses = Vec::with_capacity(epochs);
        let mut disc_losses = Vec::with_capacity(epochs);

        for _epoch in 0..epochs {
            // Train discriminator for several steps
            let mut disc_loss_sum = 0.0;
            for _step in 0..disc_steps {
                // Generate fake samples
                let fake_samples = self.generator.generate(batch_size)?;

                // Sample real data (random batch)
                let real_batch = sample_batch(real_data, batch_size)?;

                // Update discriminator
                let disc_loss =
                    self.discriminator
                        .update(&real_batch, &fake_samples, disc_learning_rate)?;
                disc_loss_sum += disc_loss;
            }
            let avg_disc_loss = disc_loss_sum / disc_steps as f64;

            // Train generator
            let latent_vectors = Array2::zeros((batch_size, self.generator.latent_dim));
            let fake_outputs = Array1::zeros(batch_size);
            let gen_loss =
                self.generator
                    .update(&latent_vectors, &fake_outputs, gen_learning_rate)?;

            // Record losses
            gen_losses.push(gen_loss);
            disc_losses.push(avg_disc_loss);
        }

        self.training_history = GANTrainingHistory {
            gen_losses,
            disc_losses,
        };

        Ok(&self.training_history)
    }

    /// Generates samples from the trained generator
    pub fn generate(&self, num_samples: usize) -> Result<Array2<f64>> {
        self.generator.generate(num_samples)
    }

    /// Generates samples with specific conditions
    pub fn generate_conditional(
        &self,
        num_samples: usize,
        conditions: &[(usize, f64)],
    ) -> Result<Array2<f64>> {
        self.generator.generate_conditional(num_samples, conditions)
    }

    /// Evaluates the GAN model
    pub fn evaluate(
        &self,
        real_data: &Array2<f64>,
        num_samples: usize,
    ) -> Result<GANEvaluationMetrics> {
        // Generate fake samples
        let fake_samples = self.generate(num_samples)?;

        // Evaluate discriminator on real data
        let real_preds = self.discriminator.predict_batch(real_data)?;
        let real_correct = real_preds.iter().filter(|&&p| p > 0.5).count();
        let real_accuracy = real_correct as f64 / real_preds.len() as f64;

        // Evaluate discriminator on fake data
        let fake_preds = self.discriminator.predict_batch(&fake_samples)?;
        let fake_correct = fake_preds.iter().filter(|&&p| p < 0.5).count();
        let fake_accuracy = fake_correct as f64 / fake_preds.len() as f64;

        // Overall accuracy
        let overall_correct = real_correct + fake_correct;
        let overall_total = real_preds.len() + fake_preds.len();
        let overall_accuracy = overall_correct as f64 / overall_total as f64;

        // Calculate Jensen-Shannon divergence between real and fake data distributions
        // This is a simplified placeholder calculation
        let js_divergence = calculate_js_divergence(real_data, &fake_samples)?;

        Ok(GANEvaluationMetrics {
            real_accuracy,
            fake_accuracy,
            overall_accuracy,
            js_divergence,
        })
    }
}

/// Calculate Jensen-Shannon divergence between two datasets using histogram estimation.
///
/// For each column (feature dimension), estimates the probability distributions
/// with a fixed-bin histogram, then computes JS = 0.5 * KL(p||m) + 0.5 * KL(q||m)
/// where m = (p + q) / 2.  Results are averaged across columns.
fn calculate_js_divergence(data1: &Array2<f64>, data2: &Array2<f64>) -> Result<f64> {
    if data1.ncols() == 0 || data1.nrows() == 0 || data2.nrows() == 0 {
        return Ok(0.0);
    }

    let n_bins: usize = 20;
    let n_cols = data1.ncols().min(data2.ncols());
    let mut total_js = 0.0;

    for col in 0..n_cols {
        let col1: Vec<f64> = data1.column(col).to_vec();
        let col2: Vec<f64> = data2.column(col).to_vec();

        let min_val = col1
            .iter()
            .chain(col2.iter())
            .cloned()
            .fold(f64::INFINITY, f64::min);
        let max_val = col1
            .iter()
            .chain(col2.iter())
            .cloned()
            .fold(f64::NEG_INFINITY, f64::max);

        if (max_val - min_val).abs() < 1e-14 {
            // All values identical across both datasets → JS divergence is 0
            continue;
        }

        let bin_width = (max_val - min_val) / n_bins as f64;
        let mut hist1 = vec![0.0f64; n_bins];
        let mut hist2 = vec![0.0f64; n_bins];

        for &v in &col1 {
            let bin = ((v - min_val) / bin_width) as usize;
            let bin = bin.min(n_bins - 1);
            hist1[bin] += 1.0;
        }
        for &v in &col2 {
            let bin = ((v - min_val) / bin_width) as usize;
            let bin = bin.min(n_bins - 1);
            hist2[bin] += 1.0;
        }

        let n1 = col1.len() as f64;
        let n2 = col2.len() as f64;
        for i in 0..n_bins {
            hist1[i] /= n1;
            hist2[i] /= n2;
        }

        // JS = 0.5 * KL(p || m) + 0.5 * KL(q || m),  m = (p + q) / 2
        let mut js = 0.0f64;
        for i in 0..n_bins {
            let p = hist1[i];
            let q = hist2[i];
            let m = (p + q) * 0.5;
            if m > 1e-14 {
                if p > 1e-14 {
                    js += 0.5 * p * (p / m).ln();
                }
                if q > 1e-14 {
                    js += 0.5 * q * (q / m).ln();
                }
            }
        }
        total_js += js;
    }

    Ok(if n_cols > 0 {
        total_js / n_cols as f64
    } else {
        0.0
    })
}

// Helper function to sample a random batch from a dataset
fn sample_batch(data: &Array2<f64>, batch_size: usize) -> Result<Array2<f64>> {
    let num_samples = data.nrows();
    let mut batch = Array2::zeros((batch_size.min(num_samples), data.ncols()));

    for i in 0..batch_size.min(num_samples) {
        let idx = fastrand::usize(0..num_samples);
        batch.row_mut(i).assign(&data.row(idx));
    }

    Ok(batch)
}

#[cfg(test)]
mod tests {
    use super::*;
    use scirs2_core::ndarray::Array2;

    #[test]
    fn test_js_divergence_identical() {
        let data = Array2::from_shape_vec((4, 2), vec![0.0, 1.0, 0.5, 0.5, 0.2, 0.8, 0.7, 0.3])
            .expect("array creation failed");
        let js = calculate_js_divergence(&data, &data).expect("divergence failed");
        assert!(js < 0.01, "JS(p,p) should be ≈0, got {js}");
    }

    #[test]
    fn test_js_divergence_bounded() {
        let data1 =
            Array2::from_shape_vec((4, 1), vec![0.0, 0.0, 0.0, 0.0]).expect("array creation");
        let data2 =
            Array2::from_shape_vec((4, 1), vec![1.0, 1.0, 1.0, 1.0]).expect("array creation");
        let js = calculate_js_divergence(&data1, &data2).expect("divergence failed");
        assert!(js >= 0.0 && js <= 1.0, "JS should be in [0, 1], got {js}");
    }
}

impl fmt::Display for GeneratorType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            GeneratorType::Classical => write!(f, "Classical"),
            GeneratorType::QuantumOnly => write!(f, "Quantum Only"),
            GeneratorType::HybridClassicalQuantum => write!(f, "Hybrid Classical-Quantum"),
        }
    }
}

impl fmt::Display for DiscriminatorType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            DiscriminatorType::Classical => write!(f, "Classical"),
            DiscriminatorType::QuantumOnly => write!(f, "Quantum Only"),
            DiscriminatorType::HybridQuantumFeatures => write!(f, "Hybrid with Quantum Features"),
            DiscriminatorType::HybridQuantumDecision => write!(f, "Hybrid with Quantum Decision"),
        }
    }
}