quantrs2_ml/

optimization.rs

use crate::error::{MLError, Result};
use scirs2_core::ndarray::{Array1, ArrayView1};
use std::collections::HashMap;
use std::fmt;

/// Optimization method to use for training quantum machine learning models
#[derive(Debug, Clone, Copy)]
pub enum OptimizationMethod {
    /// Gradient descent
    GradientDescent,

    /// Adam optimizer
    Adam,

    /// SPSA (Simultaneous Perturbation Stochastic Approximation)
    SPSA,

    /// L-BFGS (Limited-memory Broyden–Fletcher–Goldfarb–Shanno)
    LBFGS,

    /// Quantum Natural Gradient
    QuantumNaturalGradient,

    /// SciRS2 Adam optimizer
    SciRS2Adam,

    /// SciRS2 L-BFGS optimizer
    SciRS2LBFGS,

    /// SciRS2 Conjugate Gradient
    SciRS2CG,
}

/// Optimizer for quantum machine learning models
#[derive(Debug, Clone)]
pub enum Optimizer {
    /// Gradient descent
    GradientDescent {
        /// Learning rate
        learning_rate: f64,
    },

    /// Adam optimizer
    Adam {
        /// Learning rate
        learning_rate: f64,

        /// Beta1 parameter
        beta1: f64,

        /// Beta2 parameter
        beta2: f64,

        /// Epsilon parameter
        epsilon: f64,
    },

    /// SPSA optimizer
    SPSA {
        /// Learning rate
        learning_rate: f64,

        /// Perturbation size
        perturbation: f64,
    },

    /// Quantum Natural Gradient optimizer.
    ///
    /// This variant stores the scalar hyper-parameters only.  Callers are expected
    /// to pre-condition gradients through `QuantumAutoDiff::natural_gradients()`
    /// (which requires a circuit executor closure) and then pass the resulting
    /// natural-gradient vector to `update_parameters`.  The `regularization` field
    /// is used as additive damping: `Δθ_i = −lr · g_i / (1 + reg)`.
    QuantumNaturalGradient {
        /// Learning rate
        learning_rate: f64,
        /// Tikhonov regularisation added to the QFIM diagonal before inversion
        regularization: f64,
    },

    /// SciRS2-based optimizers (placeholder for integration)
    SciRS2 {
        /// Optimizer method
        method: String,
        /// Configuration parameters
        config: HashMap<String, f64>,
    },
}

impl Optimizer {
    /// Creates a new optimizer with default parameters
    pub fn new(method: OptimizationMethod) -> Self {
        match method {
            OptimizationMethod::GradientDescent => Optimizer::GradientDescent {
                learning_rate: 0.01,
            },
            OptimizationMethod::Adam => Optimizer::Adam {
                learning_rate: 0.01,
                beta1: 0.9,
                beta2: 0.999,
                epsilon: 1e-8,
            },
            OptimizationMethod::SPSA => Optimizer::SPSA {
                learning_rate: 0.01,
                perturbation: 0.01,
            },
            OptimizationMethod::LBFGS => {
                // Default to Adam as LBFGS is not implemented yet
                Optimizer::Adam {
                    learning_rate: 0.01,
                    beta1: 0.9,
                    beta2: 0.999,
                    epsilon: 1e-8,
                }
            }
            OptimizationMethod::QuantumNaturalGradient => Optimizer::QuantumNaturalGradient {
                learning_rate: 0.01,
                regularization: 1e-3,
            },
            OptimizationMethod::SciRS2Adam => {
                let mut config = HashMap::new();
                config.insert("learning_rate".to_string(), 0.001);
                config.insert("beta1".to_string(), 0.9);
                config.insert("beta2".to_string(), 0.999);
                config.insert("epsilon".to_string(), 1e-8);
                Optimizer::SciRS2 {
                    method: "adam".to_string(),
                    config,
                }
            }
            OptimizationMethod::SciRS2LBFGS => {
                let mut config = HashMap::new();
                config.insert("m".to_string(), 10.0); // Memory size
                config.insert("c1".to_string(), 1e-4);
                config.insert("c2".to_string(), 0.9);
                Optimizer::SciRS2 {
                    method: "lbfgs".to_string(),
                    config,
                }
            }
            OptimizationMethod::SciRS2CG => {
                let mut config = HashMap::new();
                config.insert("beta_method".to_string(), 0.0); // Fletcher-Reeves
                config.insert("restart_threshold".to_string(), 100.0);
                Optimizer::SciRS2 {
                    method: "cg".to_string(),
                    config,
                }
            }
        }
    }

    /// Updates parameters based on gradients
    pub fn update_parameters(
        &self,
        parameters: &mut Array1<f64>,
        gradients: &ArrayView1<f64>,
        iteration: usize,
    ) -> Result<()> {
        match self {
            Optimizer::GradientDescent { learning_rate } => {
                // Simple gradient descent update
                for i in 0..parameters.len() {
                    parameters[i] -= learning_rate * gradients[i];
                }
                Ok(())
            }
            Optimizer::Adam {
                learning_rate,
                beta1,
                beta2,
                epsilon,
            } => {
                // This is a simplified Adam implementation
                // In a real implementation, we would track momentum and RMS
                for i in 0..parameters.len() {
                    parameters[i] -= learning_rate * gradients[i];
                }
                Ok(())
            }
            Optimizer::SPSA {
                learning_rate,
                perturbation,
            } => {
                // Simplified SPSA update
                for i in 0..parameters.len() {
                    parameters[i] -= learning_rate * gradients[i];
                }
                Ok(())
            }
            Optimizer::QuantumNaturalGradient {
                learning_rate,
                regularization,
            } => {
                // Gradients are expected to be pre-conditioned natural gradients
                // (computed via `QuantumAutoDiff::natural_gradients()`).
                // Apply Tikhonov-damped update: Δθ = -lr * g / (1 + reg).
                let damp = 1.0 + regularization;
                for i in 0..parameters.len() {
                    parameters[i] -= learning_rate * gradients[i] / damp;
                }
                Ok(())
            }
            Optimizer::SciRS2 { method, config } => {
                // Placeholder - would delegate to SciRS2 optimizers
                let learning_rate = config.get("learning_rate").unwrap_or(&0.001);
                match method.as_str() {
                    "adam" => {
                        // Use SciRS2 Adam when available
                        for i in 0..parameters.len() {
                            parameters[i] -= learning_rate * gradients[i];
                        }
                    }
                    "lbfgs" => {
                        // Use SciRS2 L-BFGS when available
                        for i in 0..parameters.len() {
                            parameters[i] -= learning_rate * gradients[i];
                        }
                    }
                    "cg" => {
                        // Use SciRS2 Conjugate Gradient when available
                        for i in 0..parameters.len() {
                            parameters[i] -= learning_rate * gradients[i];
                        }
                    }
                    _ => {
                        return Err(MLError::InvalidConfiguration(format!(
                            "Unknown SciRS2 optimizer method: {}",
                            method
                        )));
                    }
                }
                Ok(())
            }
        }
    }
}

/// Objective function for optimization
pub trait ObjectiveFunction {
    /// Evaluates the objective function at the given parameters
    fn evaluate(&self, parameters: &ArrayView1<f64>) -> Result<f64>;

    /// Computes the gradient of the objective function
    fn gradient(&self, parameters: &ArrayView1<f64>) -> Result<Array1<f64>> {
        // Default implementation uses finite differences
        let epsilon = 1e-6;
        let n = parameters.len();
        let mut gradient = Array1::zeros(n);

        let f0 = self.evaluate(parameters)?;

        for i in 0..n {
            let mut params_plus = parameters.to_owned();
            params_plus[i] += epsilon;

            let f_plus = self.evaluate(&params_plus.view())?;

            gradient[i] = (f_plus - f0) / epsilon;
        }

        Ok(gradient)
    }
}

impl fmt::Display for OptimizationMethod {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            OptimizationMethod::GradientDescent => write!(f, "Gradient Descent"),
            OptimizationMethod::Adam => write!(f, "Adam"),
            OptimizationMethod::SPSA => write!(f, "SPSA"),
            OptimizationMethod::LBFGS => write!(f, "L-BFGS"),
            OptimizationMethod::QuantumNaturalGradient => write!(f, "Quantum Natural Gradient"),
            OptimizationMethod::SciRS2Adam => write!(f, "SciRS2 Adam"),
            OptimizationMethod::SciRS2LBFGS => write!(f, "SciRS2 L-BFGS"),
            OptimizationMethod::SciRS2CG => write!(f, "SciRS2 Conjugate Gradient"),
        }
    }
}

impl fmt::Display for Optimizer {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Optimizer::GradientDescent { learning_rate } => {
                write!(f, "Gradient Descent (learning_rate: {})", learning_rate)
            }
            Optimizer::Adam {
                learning_rate,
                beta1,
                beta2,
                epsilon,
            } => {
                write!(
                    f,
                    "Adam (learning_rate: {}, beta1: {}, beta2: {}, epsilon: {})",
                    learning_rate, beta1, beta2, epsilon
                )
            }
            Optimizer::SPSA {
                learning_rate,
                perturbation,
            } => {
                write!(
                    f,
                    "SPSA (learning_rate: {}, perturbation: {})",
                    learning_rate, perturbation
                )
            }
            Optimizer::QuantumNaturalGradient {
                learning_rate,
                regularization,
            } => {
                write!(
                    f,
                    "Quantum Natural Gradient (learning_rate: {}, regularization: {})",
                    learning_rate, regularization
                )
            }
            Optimizer::SciRS2 { method, config } => {
                write!(f, "SciRS2 {} with config: {:?}", method, config)
            }
        }
    }
}