Struct AdaptiveSVM 

pub struct AdaptiveSVM<State = Untrained> { /* private fields */ }

Adaptive regularization SVM wrapper

Implementations

impl AdaptiveSVM<Untrained>

pub fn new() -> Self

Create a new adaptive SVM

pub fn with_strategy(self, strategy: AdaptiveStrategy) -> Self

Set the adaptive strategy

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

Set initial C parameter

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

Set maximum iterations

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

Set tolerance

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

Enable verbose output

pub fn with_svm_config(self, config: SvcConfig) -> Self

Set base SVM configuration

impl AdaptiveSVM<Trained>

pub fn optimal_c(&self) -> f64

Get the optimal regularization parameter

pub fn optimization_history(&self) -> &[(f64, f64)]

Get the optimization history

pub fn base_svm(&self) -> &SVC<Trained>

Get the underlying trained SVM

Trait Implementations

impl<State: Clone> Clone for AdaptiveSVM<State>

fn clone(&self) -> AdaptiveSVM<State>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<State: Debug> Debug for AdaptiveSVM<State>

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

Formats the value using the given formatter.

impl Default for AdaptiveSVM<Untrained>

fn default() -> Self

Returns the “default value” for a type.

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

type Fitted = AdaptiveSVM<Trained>

The fitted model type

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

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

impl Predict<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>> for AdaptiveSVM<Trained>

fn predict(&self, x: &Array2<f64>) -> Result<Array1<f64>>

Make predictions on the provided data

fn predict_with_uncertainty( &self, x: &X, ) -> Result<(Output, UncertaintyMeasure), SklearsError>

Make predictions with confidence intervals