quantrs2_ml/automl/search/

hyperparameter_optimizer.rs

//! Quantum Hyperparameter Optimizer
//!
//! This module provides hyperparameter optimization specifically for quantum ML models.

use crate::automl::config::{HyperparameterSearchSpace, QuantumHyperparameterSpace};
use crate::automl::pipeline::QuantumMLPipeline;
use crate::error::Result;
use scirs2_core::ndarray::{Array1, Array2};
use std::collections::HashMap;

/// Quantum hyperparameter optimizer
#[derive(Debug, Clone)]
pub struct QuantumHyperparameterOptimizer {
    /// Optimization strategy
    strategy: HyperparameterOptimizationStrategy,

    /// Search space
    search_space: HyperparameterSearchSpace,

    /// Optimization history
    optimization_history: OptimizationHistory,

    /// Best configuration found
    best_configuration: Option<HyperparameterConfiguration>,
}

/// Hyperparameter optimization strategies
#[derive(Debug, Clone)]
pub enum HyperparameterOptimizationStrategy {
    RandomSearch,
    GridSearch,
    BayesianOptimization,
    EvolutionarySearch,
    QuantumAnnealing,
    QuantumVariational,
    HybridQuantumClassical,
}

/// Hyperparameter configuration
#[derive(Debug, Clone)]
pub struct HyperparameterConfiguration {
    /// Classical hyperparameters
    pub classical_params: HashMap<String, f64>,

    /// Quantum hyperparameters
    pub quantum_params: HashMap<String, f64>,

    /// Architecture parameters
    pub architecture_params: HashMap<String, usize>,

    /// Performance score
    pub performance_score: f64,
}

/// Optimization history
#[derive(Debug, Clone)]
pub struct OptimizationHistory {
    /// Trial history
    pub trials: Vec<OptimizationTrial>,

    /// Best trial
    pub best_trial: Option<OptimizationTrial>,

    /// Convergence history
    pub convergence_history: Vec<f64>,
}

/// Optimization trial
#[derive(Debug, Clone)]
pub struct OptimizationTrial {
    /// Trial ID
    pub trial_id: usize,

    /// Configuration tested
    pub configuration: HyperparameterConfiguration,

    /// Performance achieved
    pub performance: f64,

    /// Resource usage
    pub resource_usage: ResourceUsage,

    /// Trial duration
    pub duration: f64,
}

/// Resource usage tracking
#[derive(Debug, Clone)]
pub struct ResourceUsage {
    /// Memory usage (MB)
    pub memory_mb: f64,

    /// Quantum resources used
    pub quantum_resources: QuantumResourceUsage,

    /// Training time
    pub training_time: f64,
}

/// Quantum resource usage
#[derive(Debug, Clone)]
pub struct QuantumResourceUsage {
    /// Qubits used
    pub qubits_used: usize,

    /// Circuit depth
    pub circuit_depth: usize,

    /// Number of gates
    pub num_gates: usize,

    /// Coherence time used
    pub coherence_time_used: f64,
}

impl QuantumHyperparameterOptimizer {
    /// Create a new hyperparameter optimizer
    pub fn new(search_space: &HyperparameterSearchSpace) -> Self {
        Self {
            strategy: HyperparameterOptimizationStrategy::BayesianOptimization,
            search_space: search_space.clone(),
            optimization_history: OptimizationHistory::new(),
            best_configuration: None,
        }
    }

    /// Optimize hyperparameters for a given pipeline
    pub fn optimize(
        &mut self,
        pipeline: QuantumMLPipeline,
        X: &Array2<f64>,
        y: &Array1<f64>,
    ) -> Result<QuantumMLPipeline> {
        match self.strategy {
            HyperparameterOptimizationStrategy::RandomSearch => self.random_search(pipeline, X, y),
            HyperparameterOptimizationStrategy::BayesianOptimization => {
                self.bayesian_optimization(pipeline, X, y)
            }
            _ => {
                // For now, default to random search
                self.random_search(pipeline, X, y)
            }
        }
    }

    /// Get the best configuration found
    pub fn best_configuration(&self) -> Option<&HyperparameterConfiguration> {
        self.best_configuration.as_ref()
    }

    /// Get optimization history
    pub fn history(&self) -> &OptimizationHistory {
        &self.optimization_history
    }

    // Private methods

    fn random_search(
        &mut self,
        mut pipeline: QuantumMLPipeline,
        X: &Array2<f64>,
        y: &Array1<f64>,
    ) -> Result<QuantumMLPipeline> {
        let num_trials = 20; // Configurable
        let mut best_pipeline = pipeline.clone();
        let mut best_score = f64::NEG_INFINITY;

        for trial_id in 0..num_trials {
            let trial_start = std::time::Instant::now();

            // Generate random configuration
            let config = self.generate_random_configuration();

            // Apply configuration to pipeline
            pipeline.apply_hyperparameters(&config)?;

            // Evaluate pipeline
            let score = self.evaluate_configuration(&pipeline, X, y)?;

            let elapsed = trial_start.elapsed().as_secs_f64();

            // Record trial
            let trial = OptimizationTrial {
                trial_id,
                configuration: config.clone(),
                performance: score,
                resource_usage: ResourceUsage::default(),
                duration: elapsed,
            };
            self.optimization_history.trials.push(trial);

            // Update best if better
            if score > best_score {
                best_score = score;
                best_pipeline = pipeline.clone();
                self.best_configuration = Some(config);
                self.optimization_history.best_trial = Some(
                    self.optimization_history
                        .trials
                        .last()
                        .expect("trials should not be empty")
                        .clone(),
                );
            }

            self.optimization_history
                .convergence_history
                .push(best_score);
        }

        Ok(best_pipeline)
    }

    fn bayesian_optimization(
        &mut self,
        pipeline: QuantumMLPipeline,
        X: &Array2<f64>,
        y: &Array1<f64>,
    ) -> Result<QuantumMLPipeline> {
        // Simplified Bayesian optimization
        // In practice, this would use a Gaussian Process
        self.random_search(pipeline, X, y)
    }

    fn generate_random_configuration(&self) -> HyperparameterConfiguration {
        use fastrand;

        let mut classical_params = HashMap::new();
        let mut quantum_params = HashMap::new();
        let mut architecture_params = HashMap::new();

        // Sample learning rate
        let lr_min = self.search_space.learning_rates.0;
        let lr_max = self.search_space.learning_rates.1;
        let learning_rate = lr_min + fastrand::f64() * (lr_max - lr_min);
        classical_params.insert("learning_rate".to_string(), learning_rate);

        // Sample regularization
        let reg_min = self.search_space.regularization.0;
        let reg_max = self.search_space.regularization.1;
        let regularization = reg_min + fastrand::f64() * (reg_max - reg_min);
        classical_params.insert("regularization".to_string(), regularization);

        // Sample batch size
        if !self.search_space.batch_sizes.is_empty() {
            let batch_size_idx = fastrand::usize(..self.search_space.batch_sizes.len());
            let batch_size = self.search_space.batch_sizes[batch_size_idx] as f64;
            classical_params.insert("batch_size".to_string(), batch_size);
        }

        // Sample quantum parameters
        let qubit_min = self.search_space.quantum_params.num_qubits.0;
        let qubit_max = self.search_space.quantum_params.num_qubits.1;
        let num_qubits = qubit_min + fastrand::usize(..(qubit_max - qubit_min + 1));
        quantum_params.insert("num_qubits".to_string(), num_qubits as f64);

        let depth_min = self.search_space.quantum_params.circuit_depth.0;
        let depth_max = self.search_space.quantum_params.circuit_depth.1;
        let circuit_depth = depth_min + fastrand::usize(..(depth_max - depth_min + 1));
        quantum_params.insert("circuit_depth".to_string(), circuit_depth as f64);

        HyperparameterConfiguration {
            classical_params,
            quantum_params,
            architecture_params,
            performance_score: 0.0,
        }
    }

    fn evaluate_configuration(
        &self,
        pipeline: &QuantumMLPipeline,
        X: &Array2<f64>,
        y: &Array1<f64>,
    ) -> Result<f64> {
        // Simple holdout evaluation
        let split_point = (X.nrows() as f64 * 0.8) as usize;

        let X_train = X
            .slice(scirs2_core::ndarray::s![0..split_point, ..])
            .to_owned();
        let y_train = y.slice(scirs2_core::ndarray::s![0..split_point]).to_owned();
        let X_val = X
            .slice(scirs2_core::ndarray::s![split_point.., ..])
            .to_owned();
        let y_val = y.slice(scirs2_core::ndarray::s![split_point..]).to_owned();

        let mut pipeline_copy = pipeline.clone();
        pipeline_copy.fit(&X_train, &y_train)?;
        let predictions = pipeline_copy.predict(&X_val)?;

        // Calculate accuracy or R2 score
        let score = predictions
            .iter()
            .zip(y_val.iter())
            .map(|(pred, true_val)| (pred - true_val).powi(2))
            .sum::<f64>()
            / predictions.len() as f64;

        Ok(-score) // Negative MSE (higher is better)
    }
}

impl OptimizationHistory {
    fn new() -> Self {
        Self {
            trials: Vec::new(),
            best_trial: None,
            convergence_history: Vec::new(),
        }
    }
}

impl Default for ResourceUsage {
    fn default() -> Self {
        Self {
            memory_mb: 0.0,
            quantum_resources: QuantumResourceUsage::default(),
            training_time: 0.0,
        }
    }
}

impl Default for QuantumResourceUsage {
    fn default() -> Self {
        Self {
            qubits_used: 0,
            circuit_depth: 0,
            num_gates: 0,
            coherence_time_used: 0.0,
        }
    }
}