Struct SparseSVM 

pub struct SparseSVM {
    pub c: f64,
    pub loss: String,
    pub tol: f64,
    pub max_iter: usize,
    pub fit_intercept: bool,
    pub positive: bool,
    pub selection: String,
    pub verbose: bool,
    pub random_state: Option<u64>,
}

Sparse Support Vector Machine with L1 regularization

This implementation uses coordinate descent optimization with L1 penalty to automatically select relevant features and produce sparse solutions. The resulting model will have many zero coefficients, effectively performing feature selection during training.

Parameters

• C - Regularization parameter (default: 1.0)
• loss - Loss function type (‘hinge’ or ‘squared_hinge’, default: ‘squared_hinge’)
• tol - Tolerance for stopping criterion (default: 1e-4)
• max_iter - Maximum number of iterations (default: 1000)
• fit_intercept - Whether to fit an intercept term (default: true)
• positive - Force coefficients to be positive (default: false)
• selection - Selection strategy (‘cyclic’ or ‘random’, default: ‘cyclic’)
• random_state - Random seed for reproducible results (default: None)

Example

use sklears_svm::SparseSVM;
use sklears_core::traits::{Predict, Fit};
use scirs2_core::ndarray::array;

let X = array![[1.0, 2.0, 0.0], [2.0, 3.0, 1.0], [3.0, 3.0, 0.0], [2.0, 1.0, 1.0]];
let y = array![0, 1, 1, 0];

let model = SparseSVM::new()
    .with_c(1.0)
    .with_max_iter(1000);

let trained_model = model.fit(&X, &y).expect("SparseSVM fit should succeed on valid input");
let predictions = trained_model.predict(&X).expect("SparseSVM predict should succeed on valid input");

Fields

c: f64

Regularization parameter

loss: String

Loss function (‘hinge’ or ‘squared_hinge’)

tol: f64

Tolerance for stopping criterion

max_iter: usize

Maximum number of iterations

fit_intercept: bool

Whether to fit an intercept term

positive: bool

Force coefficients to be positive

selection: String

Selection strategy (‘cyclic’ or ‘random’)

verbose: bool

Verbose output

random_state: Option<u64>

Random seed

Implementations

impl SparseSVM

pub fn new() -> Self

Create a new SparseSVM with default parameters

pub fn with_c(self, c: f64) -> Self

Set the regularization parameter C

pub fn with_loss(self, loss: &str) -> Self

Set the loss function

pub fn with_tol(self, tol: f64) -> Self

Set the tolerance for stopping criterion

pub fn with_max_iter(self, max_iter: usize) -> Self

Set the maximum number of iterations

pub fn with_fit_intercept(self, fit_intercept: bool) -> Self

Set whether to fit an intercept

pub fn with_positive(self, positive: bool) -> Self

Set whether to force positive coefficients

pub fn with_selection(self, selection: &str) -> Self

Set the selection strategy

pub fn with_verbose(self, verbose: bool) -> Self

Set verbose output

pub fn with_random_state(self, random_state: u64) -> Self

Set random state for reproducible results

Trait Implementations

impl Clone for SparseSVM

fn clone(&self) -> SparseSVM

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SparseSVM

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SparseSVM

fn default() -> Self

Returns the “default value” for a type.

impl Estimator for SparseSVM

type Config = SparseSVM

Configuration type for the estimator

type Error = SklearsError

Error type for the estimator

type Float = f64

The numeric type used by this estimator

fn config(&self) -> &Self::Config

Get estimator configuration

fn validate_config(&self) -> Result<(), SklearsError>

Validate estimator configuration with detailed error context

fn check_compatibility( &self, n_samples: usize, n_features: usize, ) -> Result<(), SklearsError>

Check if estimator is compatible with given data dimensions

fn metadata(&self) -> EstimatorMetadata

Get estimator metadata

impl Fit<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, ArrayBase<OwnedRepr<i32>, Dim<[usize; 1]>>> for SparseSVM

type Fitted = TrainedSparseSVM

The fitted model type

fn fit(self, x: &Array2<f64>, y: &Array1<i32>) -> Result<TrainedSparseSVM>

Fit the model to the provided data with validation

fn fit_with_validation( self, x: &X, y: &Y, _x_val: Option<&X>, _y_val: Option<&Y>, ) -> Result<(Self::Fitted, FitMetrics), SklearsError>

where Self: Sized,

Fit with custom validation and early stopping