Struct AdaptiveBandwidthRBFSampler 

pub struct AdaptiveBandwidthRBFSampler<State = Untrained> {
    pub n_components: usize,
    pub strategy: BandwidthSelectionStrategy,
    pub objective_function: ObjectiveFunction,
    pub gamma_range: (Float, Float),
    pub n_gamma_candidates: usize,
    pub cv_folds: usize,
    pub random_state: Option<u64>,
    pub tolerance: Float,
    pub max_iterations: usize,
    /* private fields */
}

Adaptive bandwidth RBF sampler with automatic gamma selection

This sampler automatically selects the optimal bandwidth parameter (gamma) for RBF kernel approximation based on data characteristics. Multiple strategies are available for bandwidth selection, from simple heuristics to sophisticated optimization methods.

Mathematical Background

The RBF kernel with adaptive bandwidth is: K(x,y) = exp(-γ*||x-y||²) where γ is automatically selected to optimize a given objective function.

Common bandwidth selection strategies:

• Median heuristic: γ = 1/(2*median²) where median is the median pairwise distance
• Scott’s rule: γ = n^(-1/(d+4)) for n samples and d dimensions
• Cross-validation: γ = argmin CV_error(γ)

Examples

use sklears_kernel_approximation::{AdaptiveBandwidthRBFSampler, BandwidthSelectionStrategy};
use sklears_core::traits::{Transform, Fit, Untrained}
use scirs2_core::ndarray::array;

let x = array![[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]];

let sampler = AdaptiveBandwidthRBFSampler::new(100)
    .strategy(BandwidthSelectionStrategy::MedianHeuristic);

let fitted = sampler.fit(&x, &()).unwrap();
let features = fitted.transform(&x).unwrap();
let optimal_gamma = fitted.selected_gamma();

AdaptiveBandwidthRBFSampler

Fields

n_components: usize

Number of random features

strategy: BandwidthSelectionStrategy

Bandwidth selection strategy

objective_function: ObjectiveFunction

Objective function for optimization

gamma_range: (Float, Float)

Search range for gamma (min, max)

n_gamma_candidates: usize

Number of gamma candidates for grid search

cv_folds: usize

Cross-validation folds

random_state: Option<u64>

Random seed for reproducibility

tolerance: Float

Tolerance for optimization convergence

max_iterations: usize

Maximum iterations for optimization

Implementations

impl AdaptiveBandwidthRBFSampler<Untrained>

pub fn new(n_components: usize) -> Self

Create a new adaptive bandwidth RBF sampler

Arguments

• n_components - Number of random features to generate

pub fn strategy(self, strategy: BandwidthSelectionStrategy) -> Self

Set the bandwidth selection strategy

pub fn objective_function(self, objective: ObjectiveFunction) -> Self

Set the objective function for bandwidth optimization

pub fn gamma_range(self, min: Float, max: Float) -> Self

Set the search range for gamma values

pub fn n_gamma_candidates(self, n: usize) -> Self

Set the number of gamma candidates for grid search

pub fn cv_folds(self, folds: usize) -> Self

Set the number of cross-validation folds

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

Set the random state for reproducibility

pub fn tolerance(self, tol: Float) -> Self

Set optimization tolerance

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

Set maximum optimization iterations

impl AdaptiveBandwidthRBFSampler<Trained>

pub fn selected_gamma(&self) -> Result<Float>

Get the selected gamma value

pub fn optimization_history(&self) -> Option<&Vec<(Float, Float)>>

Get the optimization history (if available)

Trait Implementations

impl<State: Clone> Clone for AdaptiveBandwidthRBFSampler<State>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<State: Debug> Debug for AdaptiveBandwidthRBFSampler<State>

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

Formats the value using the given formatter.

impl Fit<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, ()> for AdaptiveBandwidthRBFSampler<Untrained>

type Fitted = AdaptiveBandwidthRBFSampler<Trained>

The fitted model type

fn fit(self, x: &Array2<Float>, _y: &()) -> 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 Transform<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>> for AdaptiveBandwidthRBFSampler<Trained>

fn transform(&self, x: &Array2<Float>) -> Result<Array2<Float>>

Transform the input data