sklears_svm/

nusvr.rs

//! Nu Support Vector Regression
//!
//! This module implements Nu-SVR, an alternative formulation of SVM regression
//! that uses a parameter nu instead of C and epsilon for controlling the
//! regularization and error tolerance.

use crate::kernels::{Kernel, KernelType};
use scirs2_core::ndarray::{Array1, Array2};
use sklears_core::{
    error::{Result, SklearsError},
    traits::{Fit, Predict, Trained, Untrained},
    types::Float,
};
use std::marker::PhantomData;

/// Nu Support Vector Regression Configuration
#[derive(Debug, Clone)]
pub struct NuSVRConfig {
    /// Nu parameter (0 < nu <= 1)
    pub nu: Float,
    /// Kernel function to use
    pub kernel: KernelType,
    /// Tolerance for stopping criterion
    pub tol: Float,
    /// Maximum number of iterations
    pub max_iter: usize,
    /// Random seed
    pub random_state: Option<u64>,
}

impl Default for NuSVRConfig {
    fn default() -> Self {
        Self {
            nu: 0.5,
            kernel: KernelType::Rbf { gamma: 1.0 },
            tol: 1e-3,
            max_iter: 200,
            random_state: None,
        }
    }
}

/// Nu Support Vector Regression
///
/// Nu-SVR is an alternative formulation of SVR that uses a parameter nu
/// instead of C and epsilon. The parameter nu controls the fraction of
/// support vectors and roughly corresponds to the fraction of training
/// points that lie outside the epsilon-tube.
#[derive(Debug)]
pub struct NuSVR<State = Untrained> {
    config: NuSVRConfig,
    state: PhantomData<State>,
    // Fitted attributes
    support_vectors_: Option<Array2<Float>>,
    support_: Option<Array1<usize>>,
    dual_coef_: Option<Array1<Float>>,
    intercept_: Option<Float>,
    n_features_in_: Option<usize>,
    n_support_: Option<usize>,
    epsilon_: Option<Float>,
}

impl NuSVR<Untrained> {
    /// Create a new Nu-SVR regressor
    pub fn new() -> Self {
        Self {
            config: NuSVRConfig::default(),
            state: PhantomData,
            support_vectors_: None,
            support_: None,
            dual_coef_: None,
            intercept_: None,
            n_features_in_: None,
            n_support_: None,
            epsilon_: None,
        }
    }

    /// Set the nu parameter (0 < nu <= 1)
    pub fn nu(mut self, nu: Float) -> Result<Self> {
        if nu <= 0.0 || nu > 1.0 {
            return Err(SklearsError::InvalidParameter {
                name: "nu".to_string(),
                reason: "must be in the range (0, 1]".to_string(),
            });
        }
        self.config.nu = nu;
        Ok(self)
    }

    /// Set the kernel type
    pub fn kernel(mut self, kernel: KernelType) -> Self {
        self.config.kernel = kernel;
        self
    }

    /// Set the tolerance for stopping criterion
    pub fn tol(mut self, tol: Float) -> Self {
        self.config.tol = tol;
        self
    }

    /// Set the maximum number of iterations
    pub fn max_iter(mut self, max_iter: usize) -> Self {
        self.config.max_iter = max_iter;
        self
    }

    /// Set the random state
    pub fn random_state(mut self, random_state: u64) -> Self {
        self.config.random_state = Some(random_state);
        self
    }
}

impl Default for NuSVR<Untrained> {
    fn default() -> Self {
        Self::new()
    }
}

impl Fit<Array2<Float>, Array1<Float>> for NuSVR<Untrained> {
    type Fitted = NuSVR<Trained>;

    fn fit(self, x: &Array2<Float>, y: &Array1<Float>) -> Result<Self::Fitted> {
        if x.nrows() != y.len() {
            return Err(SklearsError::InvalidInput(format!(
                "Shape mismatch: X has {} samples, y has {} samples",
                x.nrows(),
                y.len()
            )));
        }

        if x.nrows() == 0 {
            return Err(SklearsError::InvalidInput("Empty dataset".to_string()));
        }

        let n_features = x.ncols();
        let n_samples = x.nrows();

        // Estimate epsilon from the data and nu parameter
        // This is a simplified approach - in practice, epsilon is determined
        // during the optimization process
        let y_std = {
            let mean = y.mean().unwrap_or(0.0);
            let variance =
                y.iter().map(|&val| (val - mean).powi(2)).sum::<Float>() / n_samples as Float;
            variance.sqrt()
        };
        let epsilon = self.config.nu * y_std;

        // Convert nu to C parameter for SVR
        // This is a simplified conversion
        let _c = 1.0 / (self.config.nu * n_samples as Float);

        // For regression, we create a modified problem
        // This is a placeholder implementation - actual Nu-SVR requires
        // a specialized solver

        // Create a simple linear approximation for now
        // In practice, this would use a proper Nu-SVR solver

        // Placeholder: Use mean prediction
        let intercept = y.mean().unwrap_or(0.0);

        // For simplicity, use all points as support vectors in this placeholder
        let support_indices: Vec<usize> = (0..n_samples).collect();
        let support_vectors = x.clone();
        let dual_coef = Array1::zeros(n_samples);
        let support = Array1::from_vec(support_indices);

        Ok(NuSVR {
            config: self.config,
            state: PhantomData,
            support_vectors_: Some(support_vectors),
            support_: Some(support),
            dual_coef_: Some(dual_coef),
            intercept_: Some(intercept),
            n_features_in_: Some(n_features),
            n_support_: Some(n_samples),
            epsilon_: Some(epsilon),
        })
    }
}

impl Predict<Array2<Float>, Array1<Float>> for NuSVR<Trained> {
    fn predict(&self, x: &Array2<Float>) -> Result<Array1<Float>> {
        if x.ncols()
            != self
                .n_features_in_
                .expect("n_features_in_ not available - model not fitted")
        {
            return Err(SklearsError::InvalidInput(format!(
                "Feature mismatch: expected {} features, got {}",
                self.n_features_in_
                    .expect("n_features_in_ not available - model not fitted"),
                x.ncols()
            )));
        }

        let support_vectors = self
            .support_vectors_
            .as_ref()
            .expect("support_vectors_ not available - model not fitted");
        let dual_coef = self
            .dual_coef_
            .as_ref()
            .expect("dual_coef_ not available - model not fitted");
        let intercept = self
            .intercept_
            .expect("intercept_ not available - model not fitted");

        let kernel = match &self.config.kernel {
            KernelType::Linear => Box::new(crate::kernels::LinearKernel) as Box<dyn Kernel>,
            KernelType::Rbf { gamma } => {
                Box::new(crate::kernels::RbfKernel::new(*gamma)) as Box<dyn Kernel>
            }
            _ => Box::new(crate::kernels::RbfKernel::new(1.0)) as Box<dyn Kernel>, // Default fallback
        };
        let mut predictions = Array1::zeros(x.nrows());

        for i in 0..x.nrows() {
            let mut prediction = intercept;
            for (j, &coef) in dual_coef.iter().enumerate() {
                let k_val = kernel.compute(x.row(i), support_vectors.row(j));
                prediction += coef * k_val;
            }
            predictions[i] = prediction;
        }

        Ok(predictions)
    }
}

impl NuSVR<Trained> {
    /// Get the support vectors
    pub fn support_vectors(&self) -> &Array2<Float> {
        self.support_vectors_
            .as_ref()
            .expect("support_vectors_ not available - model not fitted")
    }

    /// Get the indices of support vectors
    pub fn support(&self) -> &Array1<usize> {
        self.support_
            .as_ref()
            .expect("support_ not available - model not fitted")
    }

    /// Get the dual coefficients
    pub fn dual_coef(&self) -> &Array1<Float> {
        self.dual_coef_
            .as_ref()
            .expect("dual_coef_ not available - model not fitted")
    }

    /// Get the intercept
    pub fn intercept(&self) -> Float {
        self.intercept_
            .expect("intercept_ not available - model not fitted")
    }

    /// Get the number of support vectors
    pub fn n_support(&self) -> usize {
        self.n_support_
            .expect("n_support_ not available - model not fitted")
    }

    /// Get the number of features
    pub fn n_features_in(&self) -> usize {
        self.n_features_in_
            .expect("n_features_in_ not available - model not fitted")
    }

    /// Get the epsilon parameter
    pub fn epsilon(&self) -> Float {
        self.epsilon_
            .expect("epsilon_ not available - model not fitted")
    }
}

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

    #[test]
    fn test_nusvr_creation() {
        let nusvr = NuSVR::new()
            .nu(0.3)
            .expect("valid parameter")
            .kernel(KernelType::Linear)
            .tol(1e-4)
            .max_iter(500)
            .random_state(42);

        assert_eq!(nusvr.config.nu, 0.3);
        assert_eq!(nusvr.config.tol, 1e-4);
        assert_eq!(nusvr.config.max_iter, 500);
        assert_eq!(nusvr.config.random_state, Some(42));
    }

    #[test]
    fn test_nusvr_invalid_nu() {
        let result = NuSVR::new().nu(1.5);
        assert!(result.is_err());
    }

    #[test]
    fn test_nusvr_regression() {
        let x = array![[1.0], [2.0], [3.0], [4.0], [5.0], [6.0],];
        let y = array![2.0, 4.0, 6.0, 8.0, 10.0, 12.0]; // y = 2*x

        let nusvr = NuSVR::new()
            .nu(0.5)
            .expect("valid parameter")
            .kernel(KernelType::Linear);
        let fitted_model = nusvr.fit(&x, &y).expect("model fitting should succeed");

        assert_eq!(fitted_model.n_features_in(), 1);
        assert!(fitted_model.epsilon() > 0.0);

        let predictions = fitted_model.predict(&x).expect("prediction should succeed");
        assert_eq!(predictions.len(), 6);

        // Check that predictions are finite
        for &pred in predictions.iter() {
            assert!(pred.is_finite());
        }
    }

    #[test]
    fn test_nusvr_shape_mismatch() {
        let x = array![[1.0, 2.0], [3.0, 4.0]];
        let y = array![1.0]; // Wrong length

        let nusvr = NuSVR::new();
        let result = nusvr.fit(&x, &y);

        assert!(result.is_err());
        assert!(result.unwrap_err().to_string().contains("Shape mismatch"));
    }

    #[test]
    fn test_nusvr_feature_mismatch() {
        let x_train = array![[1.0, 2.0], [3.0, 4.0]];
        let y_train = array![1.0, 2.0];
        let x_test = array![[1.0, 2.0, 3.0]]; // Wrong number of features

        let nusvr = NuSVR::new();
        let fitted_model = nusvr
            .fit(&x_train, &y_train)
            .expect("model fitting should succeed");
        let result = fitted_model.predict(&x_test);

        assert!(result.is_err());
        assert!(result.unwrap_err().to_string().contains("Feature"));
    }

    #[test]
    fn test_nusvr_empty_data() {
        let x: Array2<f64> = Array2::zeros((0, 2));
        let y: Array1<f64> = Array1::zeros(0);

        let nusvr = NuSVR::new();
        let result = nusvr.fit(&x, &y);

        assert!(result.is_err());
        assert!(result.unwrap_err().to_string().contains("Empty dataset"));
    }

    #[test]
    fn test_nusvr_different_kernels() {
        let x = array![[1.0], [2.0], [3.0], [4.0]];
        let y = array![1.0, 4.0, 9.0, 16.0]; // y = x^2

        let kernels = vec![
            KernelType::Linear,
            KernelType::Rbf { gamma: 0.1 },
            KernelType::Polynomial {
                gamma: 1.0,
                degree: 2.0,
                coef0: 0.0,
            },
        ];

        for kernel in kernels {
            let nusvr = NuSVR::new().kernel(kernel);
            let fitted_model = nusvr.fit(&x, &y).expect("model fitting should succeed");
            let predictions = fitted_model.predict(&x).expect("prediction should succeed");

            assert_eq!(predictions.len(), 4);
            for &pred in predictions.iter() {
                assert!(pred.is_finite());
            }
        }
    }
}